XRP Ledger API

v1.0.0

Base URLs

https://xrp.nownodes.ioNOWNodes XRP Ledger JSON-RPC endpoint.

https://xrp-evm.nownodes.ioNOWNodes XRP EVM JSON-RPC endpoint.

Returns information about an account's Payment Channels. This includes all channels where the specified account is the source of the channel.

Authentication

api-keyAuthapiKey

NOWNodes API key passed in the api-key header.

API Key: api-key in header

Account

account_channels

account_channels operations.

account_channels

POST

https://xrp.nownodes.io/

Returns information about an account's Payment Channels. This includes all channels where the specified account is the source of the channel.

Body

application/json

Returns information about an account's Payment Channels. This includes all channels where the specified account is the source of the channel.

JSON-RPC request payload.

methodstringaccount_channelsrequired

The JSON-RPC method name

paramsArray<object>required

Ordered JSON-RPC method parameters.

Show child attributes

accountstringrequired

The unique identifier of the account, typically an XRP Ledger address in base58 format. This is the source account of the payment channels.

destination_accountstring

(Optional) Filter results to payment channels with a specific destination account. If provided, only channels to this destination are returned.

ledger_hashstring

(Optional) A 20-byte hex string identifying a specific ledger version to use for the request.

ledger_indexstringvalidatedclosedcurrent

The ledger index of the ledger to use for the request.

"validated": The most recent validated ledger
"closed": The most recent closed ledger
"current": The current working ledger

limitinteger

(Optional) Limit the number of channels to retrieve. The server is not required to honor this value.

markerobject

(Optional) Value from a previous paginated response. Resume retrieving data where that response left off.

Response

200OK

HTTP 200 response for account_channels. The body contains either a successful result or a method-level JSON-RPC error.

400Bad Request

Bad Request. The request body is malformed or contains invalid JSON-RPC parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or node failed while processing the request.

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

account_channels

curl -X POST 'https://xrp.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "method": "account_channels",
    "params": [
      {
        "account": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn",
        "destination_account": "ra5nK24KXen9AHvsdFTKHSANinZseWnPcX",
        "ledger_index": "validated"
      }
    ]
  }'

const response = await fetch('https://xrp.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "method": "account_channels",
      "params": [
        {
          "account": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn",
          "destination_account": "ra5nK24KXen9AHvsdFTKHSANinZseWnPcX",
          "ledger_index": "validated"
        }
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "method": "account_channels",
  "params": [
    {
      "account": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn",
      "destination_account": "ra5nK24KXen9AHvsdFTKHSANinZseWnPcX",
      "ledger_index": "validated"
    }
  ]
}

response = requests.post('https://xrp.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "method": "account_channels",
  "params": [
    {
      "account": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn",
      "destination_account": "ra5nK24KXen9AHvsdFTKHSANinZseWnPcX",
      "ledger_index": "validated"
    }
  ]
}

{
  "result": {
    "ledger_index": 105281656,
    "status": "success",
    "validated": true
  }
}

{
  "result": {
    "error": "invalidParams",
    "error_code": 31,
    "error_message": "Invalid parameters.",
    "request": {
      "method": "account_channels",
      "params": [
        {}
      ]
    },
    "status": "error"
  }
}

{
  "code": 400,
  "message": "Bad Request"
}

Unknown API_key

Method Not Allowed

Missing API_key

{
  "code": 500,
  "message": "Internal Server Error"
}

account_currencies

account_currencies operations.

account_currencies

POST

https://xrp.nownodes.io/

Returns a list of currencies that an account can send or receive, based on its trust lines. This method only returns currencies that the account can use in payments, not currencies that the account holds but cannot use in payments.

Body

application/json

JSON-RPC request payload.

methodstringaccount_currenciesrequired

The JSON-RPC method name

paramsArray<object>required

Ordered JSON-RPC method parameters.

Show child attributes

accountstringrequired

The unique identifier of the account, typically an XRP Ledger address in base58 format. This is the account whose currencies are being queried.

account_indexinteger

(Optional) The unique identifier of the account, as a number. This is an alternative way to specify the account.

ledger_hashstring

(Optional) A 20-byte hex string identifying a specific ledger version to use for the request.

ledger_indexstringvalidatedclosedcurrent

The ledger index of the ledger to use for the request.

"validated": The most recent validated ledger (recommended)
"closed": The most recent closed ledger
"current": The current working ledger

strictboolean

(Optional) If true, only accept a public key or XRP Ledger address for the account parameter. Otherwise, try to derive the account from other types like seeds.

Response

200OK

HTTP 200 response for account_currencies. The body contains either a successful result or a method-level JSON-RPC error.

400Bad Request

Bad Request. The request body is malformed or contains invalid JSON-RPC parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or node failed while processing the request.

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

account_currencies

curl -X POST 'https://xrp.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "method": "account_currencies",
    "params": [
      {
        "account": "r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59",
        "account_index": 0,
        "ledger_index": "validated"
      }
    ]
  }'

const response = await fetch('https://xrp.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "method": "account_currencies",
      "params": [
        {
          "account": "r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59",
          "account_index": 0,
          "ledger_index": "validated"
        }
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "method": "account_currencies",
  "params": [
    {
      "account": "r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59",
      "account_index": 0,
      "ledger_index": "validated"
    }
  ]
}

response = requests.post('https://xrp.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "method": "account_currencies",
  "params": [
    {
      "account": "r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59",
      "account_index": 0,
      "ledger_index": "validated"
    }
  ]
}

{
  "result": {
    "ledger_index": 105281656,
    "status": "success",
    "validated": true
  }
}

{
  "result": {
    "error": "invalidParams",
    "error_code": 31,
    "error_message": "Invalid parameters.",
    "request": {
      "method": "account_currencies",
      "params": [
        {}
      ]
    },
    "status": "error"
  }
}

{
  "code": 400,
  "message": "Bad Request"
}

Unknown API_key

Method Not Allowed

Missing API_key

{
  "code": 500,
  "message": "Internal Server Error"
}

account_info

account_info operations.

account_info

POST

https://xrp.nownodes.io/

Returns information about an account, its activity, and its XRP balance. This includes all information stored in the account's root ledger object. When querying the current ledger, can also return information about queued transactions.

Body

application/json

JSON-RPC request payload.

methodstringaccount_inforequired

The JSON-RPC method name

paramsArray<object>required

Ordered JSON-RPC method parameters.

Show child attributes

accountstringrequired

The unique identifier of the account, typically an XRP Ledger address in base58 format.

ledger_hashstring

(Optional) A 20-byte hex string identifying a specific ledger version to use for the request.

ledger_indexstringvalidatedclosedcurrent

The ledger index of the ledger to use for the request.

"validated": The most recent validated ledger
"closed": The most recent closed ledger
"current": The current working ledger (required for queue data)

queueboolean

If true, and querying the current ledger, returns information about any transactions queued for this account. Ignored for validated ledgers.

signer_listsboolean

If true, and the account has a signer list, returns the signer list(s) associated with the account.

strictboolean

If true, only accept a public key or XRP Ledger address for the account parameter.

Response

200OK

HTTP 200 response for account_info. The body contains either a successful result or a method-level JSON-RPC error.

400Bad Request

Bad Request. The request body is malformed or contains invalid JSON-RPC parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or node failed while processing the request.

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

account_info

curl -X POST 'https://xrp.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "method": "account_info",
    "params": [
      {
        "account": "rG1QQv2nh2gr7RCZ1P8YYcBUKCCN633jCn",
        "ledger_index": "current",
        "queue": true
      }
    ]
  }'

const response = await fetch('https://xrp.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "method": "account_info",
      "params": [
        {
          "account": "rG1QQv2nh2gr7RCZ1P8YYcBUKCCN633jCn",
          "ledger_index": "current",
          "queue": true
        }
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "method": "account_info",
  "params": [
    {
      "account": "rG1QQv2nh2gr7RCZ1P8YYcBUKCCN633jCn",
      "ledger_index": "current",
      "queue": True
    }
  ]
}

response = requests.post('https://xrp.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "method": "account_info",
  "params": [
    {
      "account": "rG1QQv2nh2gr7RCZ1P8YYcBUKCCN633jCn",
      "ledger_index": "current",
      "queue": true
    }
  ]
}

{
  "result": {
    "account_data": {
      "Account": "rJ8hb4jMHgRNhEQ7BTGz6vt14kWn2z6H78",
      "Balance": "2386569461551",
      "Flags": 0,
      "LedgerEntryType": "AccountRoot",
      "OwnerCount": 1,
      "PreviousTxnID": "85EA53E35541E4057CE45A37D06F7837804CE5B46D38D5EB8647D61846E8440C",
      "PreviousTxnLgrSeq": 105281644,
      "Sequence": 92896976,
      "index": "5139D633ED1CE7DDD48BD0C5FDD05A80068F448E2DA7D0030859BBA9438AEB01"
    },
    "account_flags": {
      "defaultRipple": false,
      "depositAuth": false,
      "disableMasterKey": false,
      "disallowIncomingXRP": false,
      "requireDestinationTag": false
    },
    "ledger_hash": "0A824975FBA175094870C813DD564E6033999D55A1D4B6C6CEA5F6B5880D75FC",
    "ledger_index": 105281656,
    "status": "success",
    "validated": true
  }
}

{
  "result": {
    "error": "invalidParams",
    "error_code": 31,
    "error_message": "Invalid parameters.",
    "request": {
      "method": "account_info",
      "params": [
        {}
      ]
    },
    "status": "error"
  }
}

{
  "code": 400,
  "message": "Bad Request"
}

Unknown API_key

Method Not Allowed

Missing API_key

{
  "code": 500,
  "message": "Internal Server Error"
}

account_lines

account_lines operations.

account_lines

POST

https://xrp.nownodes.io/

Returns information about an account's trust lines (non-XRP balances). This includes all trust lines where the account has a non-zero balance or a non-zero limit. Trust lines represent relationships between accounts for holding non-XRP currencies.

Body

application/json

JSON-RPC request payload.

methodstringaccount_linesrequired

The JSON-RPC method name

paramsArray<object>required

Ordered JSON-RPC method parameters.

Show child attributes

accountstringrequired

The unique identifier of the account, typically an XRP Ledger address in base58 format. This is the account whose trust lines are being queried.

api_versioninteger

(Optional) The API version to use. Version 2 provides enhanced response formatting.

ledger_hashstring

(Optional) A 20-byte hex string identifying a specific ledger version to use for the request.

ledger_indexstringvalidatedclosedcurrent

The ledger index of the ledger to use for the request.

"validated": The most recent validated ledger
"closed": The most recent closed ledger
"current": The current working ledger

peerstring

(Optional) Filter results to trust lines with a specific counterparty account. If provided, only trust lines with this peer are returned.

limitinteger

(Optional) Limit the number of trust lines to retrieve. The server is not required to honor this value.

markerobject

(Optional) Value from a previous paginated response. Resume retrieving data where that response left off.

Response

200OK

HTTP 200 response for account_lines. The body contains either a successful result or a method-level JSON-RPC error.

400Bad Request

Bad Request. The request body is malformed or contains invalid JSON-RPC parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or node failed while processing the request.

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

account_lines

curl -X POST 'https://xrp.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "method": "account_lines",
    "params": [
      {
        "account": "r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59",
        "api_version": 2
      }
    ]
  }'

const response = await fetch('https://xrp.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "method": "account_lines",
      "params": [
        {
          "account": "r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59",
          "api_version": 2
        }
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "method": "account_lines",
  "params": [
    {
      "account": "r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59",
      "api_version": 2
    }
  ]
}

response = requests.post('https://xrp.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "method": "account_lines",
  "params": [
    {
      "account": "r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59",
      "api_version": 2
    }
  ]
}

{
  "result": {
    "ledger_index": 105281656,
    "status": "success",
    "validated": true
  }
}

{
  "result": {
    "error": "invalidParams",
    "error_code": 31,
    "error_message": "Invalid parameters.",
    "request": {
      "method": "account_lines",
      "params": [
        {}
      ]
    },
    "status": "error"
  }
}

{
  "code": 400,
  "message": "Bad Request"
}

Unknown API_key

Method Not Allowed

Missing API_key

{
  "code": 500,
  "message": "Internal Server Error"
}

account_nfts

account_nfts operations.

account_nfts

POST

https://xrp.nownodes.io/

Returns a list of non-fungible tokens (NFTs) owned by the specified account. NFTs on the XRP Ledger are unique digital assets that can represent ownership of digital or physical items.

Body

application/json

Returns a list of non-fungible tokens (NFTs) owned by the specified account. NFTs on the XRP Ledger are unique digital assets that can represent ownership of digital or physical items.

JSON-RPC request payload.

methodstringaccount_nftsrequired

The JSON-RPC method name

paramsArray<object>required

Ordered JSON-RPC method parameters.

Show child attributes

accountstringrequired

The unique identifier of the account, typically an XRP Ledger address in base58 format. This is the account whose NFTs are being queried.

ledger_hashstring

(Optional) A 20-byte hex string identifying a specific ledger version to use for the request.

ledger_indexstringvalidatedclosedcurrent

The ledger index of the ledger to use for the request.

"validated": The most recent validated ledger (recommended for NFTs)
"closed": The most recent closed ledger
"current": The current working ledger

limitinteger

(Optional) Limit the number of NFTs to retrieve. The server is not required to honor this value.

markerobject

(Optional) Value from a previous paginated response. Resume retrieving data where that response left off.

Response

200OK

HTTP 200 response for account_nfts. The body contains either a successful result or a method-level JSON-RPC error.

400Bad Request

Bad Request. The request body is malformed or contains invalid JSON-RPC parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or node failed while processing the request.

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

account_nfts

curl -X POST 'https://xrp.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "method": "account_nfts",
    "params": [
      {
        "account": "rsuHaTvJh1bDmDoxX9QcKP7HEBSBt4XsHx",
        "ledger_index": "validated"
      }
    ]
  }'

const response = await fetch('https://xrp.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "method": "account_nfts",
      "params": [
        {
          "account": "rsuHaTvJh1bDmDoxX9QcKP7HEBSBt4XsHx",
          "ledger_index": "validated"
        }
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "method": "account_nfts",
  "params": [
    {
      "account": "rsuHaTvJh1bDmDoxX9QcKP7HEBSBt4XsHx",
      "ledger_index": "validated"
    }
  ]
}

response = requests.post('https://xrp.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "method": "account_nfts",
  "params": [
    {
      "account": "rsuHaTvJh1bDmDoxX9QcKP7HEBSBt4XsHx",
      "ledger_index": "validated"
    }
  ]
}

{
  "result": {
    "ledger_index": 105281656,
    "status": "success",
    "validated": true
  }
}

{
  "result": {
    "error": "invalidParams",
    "error_code": 31,
    "error_message": "Invalid parameters.",
    "request": {
      "method": "account_nfts",
      "params": [
        {}
      ]
    },
    "status": "error"
  }
}

{
  "code": 400,
  "message": "Bad Request"
}

Unknown API_key

Method Not Allowed

Missing API_key

{
  "code": 500,
  "message": "Internal Server Error"
}

account_objects

account_objects operations.

account_objects

POST

https://xrp.nownodes.io/

Returns the raw ledger format for all objects owned by an account. This includes various types of ledger objects such as trust lines, offers, escrows, payment channels, signer lists, and more.

Body

application/json

Returns the raw ledger format for all objects owned by an account. This includes various types of ledger objects such as trust lines, offers, escrows, payment channels, signer lists, and more.

JSON-RPC request payload.

methodstringaccount_objectsrequired

The JSON-RPC method name

paramsArray<object>required

Ordered JSON-RPC method parameters.

Show child attributes

accountstringrequired

The unique identifier of the account, typically an XRP Ledger address in base58 format. This is the account whose ledger objects are being queried.

ledger_hashstring

(Optional) A 20-byte hex string identifying a specific ledger version to use for the request.

ledger_indexstringvalidatedclosedcurrent

The ledger index of the ledger to use for the request.

"validated": The most recent validated ledger (recommended)
"closed": The most recent closed ledger
"current": The current working ledger

typestringcheckdeposit_preauthescrowofferpayment_channelsigner_liststate

(Optional) Filter results to a single type of ledger object.

"state": Trust lines (RippleState entries)
"offer": Order book offers
"escrow": Escrow objects
"check": Check objects
"payment_channel": Payment channels
"signer_list": Multi-signing lists
"deposit_preauth": Deposit preauthorizations

deletion_blockers_onlyboolean

If true, limit results to objects that can block account deletion. Account deletion requires that the account owns no objects except those that can be removed.

limitinteger

(Optional) Limit the number of objects to retrieve. The server is not required to honor this value.

markerobject

(Optional) Value from a previous paginated response. Resume retrieving data where that response left off.

Response

200OK

HTTP 200 response for account_objects. The body contains either a successful result or a method-level JSON-RPC error.

400Bad Request

Bad Request. The request body is malformed or contains invalid JSON-RPC parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or node failed while processing the request.

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

account_objects

curl -X POST 'https://xrp.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "method": "account_objects",
    "params": [
      {
        "account": "r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59",
        "ledger_index": "validated",
        "type": "state",
        "deletion_blockers_only": false,
        "limit": 10
      }
    ]
  }'

const response = await fetch('https://xrp.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "method": "account_objects",
      "params": [
        {
          "account": "r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59",
          "ledger_index": "validated",
          "type": "state",
          "deletion_blockers_only": false,
          "limit": 10
        }
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "method": "account_objects",
  "params": [
    {
      "account": "r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59",
      "ledger_index": "validated",
      "type": "state",
      "deletion_blockers_only": False,
      "limit": 10
    }
  ]
}

response = requests.post('https://xrp.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "method": "account_objects",
  "params": [
    {
      "account": "r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59",
      "ledger_index": "validated",
      "type": "state",
      "deletion_blockers_only": false,
      "limit": 10
    }
  ]
}

{
  "result": {
    "ledger_index": 105281656,
    "status": "success",
    "validated": true
  }
}

{
  "result": {
    "error": "invalidParams",
    "error_code": 31,
    "error_message": "Invalid parameters.",
    "request": {
      "method": "account_objects",
      "params": [
        {}
      ]
    },
    "status": "error"
  }
}

{
  "code": 400,
  "message": "Bad Request"
}

Unknown API_key

Method Not Allowed

Missing API_key

{
  "code": 500,
  "message": "Internal Server Error"
}

account_offers

account_offers operations.

account_offers

POST

https://xrp.nownodes.io/

Returns information about an account's outstanding offers (orders) in the decentralized exchange. This includes all active offers placed by the account in the XRP Ledger's order books.

Body

application/json

Returns information about an account's outstanding offers (orders) in the decentralized exchange. This includes all active offers placed by the account in the XRP Ledger's order books.

JSON-RPC request payload.

methodstringaccount_offersrequired

The JSON-RPC method name

paramsArray<object>required

Ordered JSON-RPC method parameters.

Show child attributes

accountstringrequired

The unique identifier of the account, typically an XRP Ledger address in base58 format. This is the account whose offers are being queried.

ledger_hashstring

(Optional) A 20-byte hex string identifying a specific ledger version to use for the request.

ledger_indexstringvalidatedclosedcurrent

The ledger index of the ledger to use for the request.

"validated": The most recent validated ledger
"closed": The most recent closed ledger
"current": The current working ledger (common for offers)

limitinteger

(Optional) Limit the number of offers to retrieve. The server is not required to honor this value.

markerobject

(Optional) Value from a previous paginated response. Resume retrieving data where that response left off.

Response

200OK

HTTP 200 response for account_offers. The body contains either a successful result or a method-level JSON-RPC error.

400Bad Request

Bad Request. The request body is malformed or contains invalid JSON-RPC parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or node failed while processing the request.

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

account_offers

curl -X POST 'https://xrp.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "method": "account_offers",
    "params": [
      {
        "account": "rpP2JgiMyTF5jR5hLG3xHCPi1knBb1v9cM"
      }
    ]
  }'

const response = await fetch('https://xrp.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "method": "account_offers",
      "params": [
        {
          "account": "rpP2JgiMyTF5jR5hLG3xHCPi1knBb1v9cM"
        }
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "method": "account_offers",
  "params": [
    {
      "account": "rpP2JgiMyTF5jR5hLG3xHCPi1knBb1v9cM"
    }
  ]
}

response = requests.post('https://xrp.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "method": "account_offers",
  "params": [
    {
      "account": "rpP2JgiMyTF5jR5hLG3xHCPi1knBb1v9cM"
    }
  ]
}

{
  "result": {
    "ledger_index": 105281656,
    "status": "success",
    "validated": true
  }
}

{
  "result": {
    "error": "invalidParams",
    "error_code": 31,
    "error_message": "Invalid parameters.",
    "request": {
      "method": "account_offers",
      "params": [
        {}
      ]
    },
    "status": "error"
  }
}

{
  "code": 400,
  "message": "Bad Request"
}

Unknown API_key

Method Not Allowed

Missing API_key

{
  "code": 500,
  "message": "Internal Server Error"
}

account_tx

account_tx operations.

account_tx

POST

https://xrp.nownodes.io/

Retrieves the transaction history for a specific account. Returns an array of transactions that affected the specified account in some way. This includes payments, trust lines, offers, and other transaction types.

Body

application/json

JSON-RPC request payload.

methodstringaccount_txrequired

The JSON-RPC method name

paramsArray<object>required

Ordered JSON-RPC method parameters.

Show child attributes

accountstringrequired

The unique identifier of the account, typically an XRP Ledger address in base58 format. This is the account whose transaction history is being queried.

api_versioninteger

(Optional) The API version to use. Version 2 provides enhanced response formatting.

binaryboolean

If true, return transactions as hex strings instead of JSON. When false (recommended), transactions are returned in parsed JSON format.

forwardboolean

If true, return results in ascending ledger order (oldest first). If false, return results in descending ledger order (newest first).

ledger_hashstring

(Optional) A 20-byte hex string identifying a specific ledger version to use for the request.

ledger_indexstringvalidatedclosedcurrent

The ledger index of the ledger to use for the request.

ledger_index_mininteger

The minimum ledger index to search from. Use -1 to start from the earliest available ledger.

ledger_index_maxinteger

The maximum ledger index to search to. Use -1 to search up to the most recent available ledger.

limitinteger

(Optional) Limit the number of transactions to retrieve. The server is not required to honor this value.

markerobject

(Optional) Value from a previous paginated response. Resume retrieving data where that response left off.

Response

200OK

HTTP 200 response for account_tx. The body contains either a successful result or a method-level JSON-RPC error.

400Bad Request

Bad Request. The request body is malformed or contains invalid JSON-RPC parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or node failed while processing the request.

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

account_tx

curl -X POST 'https://xrp.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "method": "account_tx",
    "params": [
      {
        "account": "rLNaPoKeeBjZe2qs6x52yVPZpZ8td4dc6w",
        "binary": false,
        "forward": false,
        "ledger_index_max": -1,
        "ledger_index_min": -1,
        "limit": 2,
        "api_version": 2
      }
    ]
  }'

const response = await fetch('https://xrp.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "method": "account_tx",
      "params": [
        {
          "account": "rLNaPoKeeBjZe2qs6x52yVPZpZ8td4dc6w",
          "binary": false,
          "forward": false,
          "ledger_index_max": -1,
          "ledger_index_min": -1,
          "limit": 2,
          "api_version": 2
        }
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "method": "account_tx",
  "params": [
    {
      "account": "rLNaPoKeeBjZe2qs6x52yVPZpZ8td4dc6w",
      "binary": False,
      "forward": False,
      "ledger_index_max": -1,
      "ledger_index_min": -1,
      "limit": 2,
      "api_version": 2
    }
  ]
}

response = requests.post('https://xrp.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "method": "account_tx",
  "params": [
    {
      "account": "rLNaPoKeeBjZe2qs6x52yVPZpZ8td4dc6w",
      "binary": false,
      "forward": false,
      "ledger_index_max": -1,
      "ledger_index_min": -1,
      "limit": 2,
      "api_version": 2
    }
  ]
}

{
  "result": {
    "Account": "rJ8hb4jMHgRNhEQ7BTGz6vt14kWn2z6H78",
    "Amount": "10481740797",
    "Destination": "r3uX3Vsy1E4NG8uo4Vx1Jx66MN9TowkX2t",
    "Fee": "10000",
    "Flags": 2147483648,
    "LastLedgerSequence": 105291628,
    "Sequence": 92896974,
    "TransactionType": "Payment",
    "hash": "C6F5A09685595EF5401C8EAB11A5CA9DF3C8CC064DE1CA470B4432AD03251648",
    "ledger_index": 105281633,
    "date": 836151662,
    "meta": {
      "AffectedNodes": [
        {
          "ModifiedNode": {
            "LedgerEntryType": "AccountRoot",
            "LedgerIndex": "5139D633ED1CE7DDD48BD0C5FDD05A80068F448E2DA7D0030859BBA9438AEB01"
          }
        },
        {
          "ModifiedNode": {
            "LedgerEntryType": "AccountRoot",
            "LedgerIndex": "8C1ABF682E8C5CC85545157139CFDEB76F20904AB5FFC73B5371606B31CA3C16"
          }
        }
      ],
      "TransactionIndex": 0,
      "TransactionResult": "tesSUCCESS",
      "delivered_amount": "10481740797"
    },
    "status": "success",
    "validated": true
  }
}

{
  "result": {
    "error": "invalidParams",
    "error_code": 31,
    "error_message": "Invalid parameters.",
    "request": {
      "method": "account_tx",
      "params": [
        {}
      ]
    },
    "status": "error"
  }
}

{
  "code": 400,
  "message": "Bad Request"
}

Unknown API_key

Method Not Allowed

Missing API_key

{
  "code": 500,
  "message": "Internal Server Error"
}

gateway_balances

gateway_balances operations.

gateway_balances

POST

https://xrp.nownodes.io/

Calculates the total balances issued by a given account, optionally excluding amounts held by operational addresses (hot wallets). This method is primarily used by gateway operators to calculate their net obligations to users.

Body

application/json

JSON-RPC request payload.

methodstringgateway_balancesrequired

The JSON-RPC method name

paramsArray<object>required

Ordered JSON-RPC method parameters.

Show child attributes

accountstringrequired

The unique identifier of the gateway's issuing address, typically an XRP Ledger address in base58 format. This is the account that issues the currencies (the gateway operator).

hotwalletArray<string>

(Optional) An array of operational addresses (hot wallets) to exclude from the balances. Amounts held by these addresses are not counted as obligations to users.

ledger_hashstring

(Optional) A 20-byte hex string identifying a specific ledger version to use for the request.

ledger_indexstringvalidatedclosedcurrent

The ledger index of the ledger to use for the request.

"validated": The most recent validated ledger (recommended for accurate balances)
"closed": The most recent closed ledger
"current": The current working ledger

strictboolean

If true, only accept a public key or XRP Ledger address for the account parameter.

Response

200OK

HTTP 200 response for gateway_balances. The body contains either a successful result or a method-level JSON-RPC error.

400Bad Request

Bad Request. The request body is malformed or contains invalid JSON-RPC parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or node failed while processing the request.

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

gateway_balances

curl -X POST 'https://xrp.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "method": "gateway_balances",
    "params": [
      {
        "account": "rMwjYedjc7qqtKYVLiAccJSmCwih4LnE2q",
        "hotwallet": [
          "rKm4uWpg9tfwbVSeATv4KxDe6mpE9yPkgJ",
          "ra7JkEzrgeKHdzKgo4EUUVBnxggY4z37kt"
        ],
        "ledger_index": "validated",
        "strict": true
      }
    ]
  }'

const response = await fetch('https://xrp.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "method": "gateway_balances",
      "params": [
        {
          "account": "rMwjYedjc7qqtKYVLiAccJSmCwih4LnE2q",
          "hotwallet": [
            "rKm4uWpg9tfwbVSeATv4KxDe6mpE9yPkgJ",
            "ra7JkEzrgeKHdzKgo4EUUVBnxggY4z37kt"
          ],
          "ledger_index": "validated",
          "strict": true
        }
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "method": "gateway_balances",
  "params": [
    {
      "account": "rMwjYedjc7qqtKYVLiAccJSmCwih4LnE2q",
      "hotwallet": [
        "rKm4uWpg9tfwbVSeATv4KxDe6mpE9yPkgJ",
        "ra7JkEzrgeKHdzKgo4EUUVBnxggY4z37kt"
      ],
      "ledger_index": "validated",
      "strict": True
    }
  ]
}

response = requests.post('https://xrp.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "method": "gateway_balances",
  "params": [
    {
      "account": "rMwjYedjc7qqtKYVLiAccJSmCwih4LnE2q",
      "hotwallet": [
        "rKm4uWpg9tfwbVSeATv4KxDe6mpE9yPkgJ",
        "ra7JkEzrgeKHdzKgo4EUUVBnxggY4z37kt"
      ],
      "ledger_index": "validated",
      "strict": true
    }
  ]
}

{
  "result": {
    "ledger_index": 105281656,
    "status": "success",
    "validated": true
  }
}

{
  "result": {
    "error": "invalidParams",
    "error_code": 31,
    "error_message": "Invalid parameters.",
    "request": {
      "method": "gateway_balances",
      "params": [
        {}
      ]
    },
    "status": "error"
  }
}

{
  "code": 400,
  "message": "Bad Request"
}

Unknown API_key

Method Not Allowed

Missing API_key

{
  "code": 500,
  "message": "Internal Server Error"
}

noripple_check

noripple_check operations.

noripple_check

POST

https://xrp.nownodes.io/

Checks an account's NoRipple settings and provides recommendations for improving liquidity and connectivity in the XRP Ledger. This method helps identify trust lines that have rippling disabled, which can limit an account's ability to send and receive payments through the decentralized exchange.

Body

application/json

JSON-RPC request payload.

methodstringnoripple_checkrequired

The JSON-RPC method name

paramsArray<object>required

Ordered JSON-RPC method parameters.

Show child attributes

accountstringrequired

The unique identifier of the account, typically an XRP Ledger address in base58 format. This is the account whose NoRipple settings are being checked.

rolestringgatewayuserrequired

The role of the account, which determines the recommended NoRipple settings.

"gateway": Account issues currencies and should generally enable rippling
"user": Regular user account that may want to disable rippling for specific use cases

ledger_hashstring

(Optional) A 20-byte hex string identifying a specific ledger version to use for the request.

ledger_indexstringvalidatedclosedcurrent

The ledger index of the ledger to use for the request.

"validated": The most recent validated ledger
"closed": The most recent closed ledger
"current": The current working ledger

limitinteger

(Optional) Limit the number of problems to identify. The server is not required to honor this value.

transactionsboolean

If true, include suggested transactions to fix the identified problems. These are unsigned transaction skeletons that need to be signed and submitted.

Response

200OK

HTTP 200 response for noripple_check. The body contains either a successful result or a method-level JSON-RPC error.

400Bad Request

Bad Request. The request body is malformed or contains invalid JSON-RPC parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or node failed while processing the request.

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

noripple_check

curl -X POST 'https://xrp.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "method": "noripple_check",
    "params": [
      {
        "account": "r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59",
        "ledger_index": "current",
        "limit": 2,
        "role": "gateway",
        "transactions": true
      }
    ]
  }'

const response = await fetch('https://xrp.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "method": "noripple_check",
      "params": [
        {
          "account": "r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59",
          "ledger_index": "current",
          "limit": 2,
          "role": "gateway",
          "transactions": true
        }
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "method": "noripple_check",
  "params": [
    {
      "account": "r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59",
      "ledger_index": "current",
      "limit": 2,
      "role": "gateway",
      "transactions": True
    }
  ]
}

response = requests.post('https://xrp.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "method": "noripple_check",
  "params": [
    {
      "account": "r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59",
      "ledger_index": "current",
      "limit": 2,
      "role": "gateway",
      "transactions": true
    }
  ]
}

{
  "result": {
    "ledger_index": 105281656,
    "status": "success",
    "validated": true
  }
}

{
  "result": {
    "error": "invalidParams",
    "error_code": 31,
    "error_message": "Invalid parameters.",
    "request": {
      "method": "noripple_check",
      "params": [
        {}
      ]
    },
    "status": "error"
  }
}

{
  "code": 400,
  "message": "Bad Request"
}

Unknown API_key

Method Not Allowed

Missing API_key

{
  "code": 500,
  "message": "Internal Server Error"
}

Clio

ledger

ledger operations.

ledger

POST

https://xrp.nownodes.io/

Retrieve information about a specific ledger in the XRP Ledger. This method returns detailed information about a ledger's header, hash, and metadata.

Body

application/json

Retrieve information about a specific ledger in the XRP Ledger. This method returns detailed information about a ledger's header, hash, and metadata.

JSON-RPC request payload.

methodstringledgerrequired

The JSON-RPC method name

paramsArray<object>required

Ordered JSON-RPC method parameters.

Show child attributes

ledger_indexstringvalidatedcurrentclosed

The ledger index to retrieve. "validated" returns the most recent validated ledger.

ledger_hashstring

A 20-byte hex string for the ledger version to use (not recommended)

transactionsboolean

If true, include transactions in the ledger data. Defaults to false.

expandboolean

If true, include full transaction details rather than only transaction hashes. Only applies when transactions is true.

owner_fundsboolean

If true, include owner_funds field in OfferCreate transactions. Only applies when transactions and expand are both true.

diffboolean

If true, include a diff of ledger state changes. This can significantly increase response size.

Response

200OK

HTTP 200 response for ledger. The body contains either a successful result or a method-level JSON-RPC error.

400Bad Request

Bad Request. The request body is malformed or contains invalid JSON-RPC parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or node failed while processing the request.

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

ledger

curl -X POST 'https://xrp.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "method": "ledger",
    "params": [
      {
        "ledger_index": "validated",
        "transactions": false,
        "expand": false,
        "owner_funds": false,
        "diff": false
      }
    ]
  }'

const response = await fetch('https://xrp.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "method": "ledger",
      "params": [
        {
          "ledger_index": "validated",
          "transactions": false,
          "expand": false,
          "owner_funds": false,
          "diff": false
        }
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "method": "ledger",
  "params": [
    {
      "ledger_index": "validated",
      "transactions": False,
      "expand": False,
      "owner_funds": False,
      "diff": False
    }
  ]
}

response = requests.post('https://xrp.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "method": "ledger",
  "params": [
    {
      "ledger_index": "validated",
      "transactions": false,
      "expand": false,
      "owner_funds": false,
      "diff": false
    }
  ]
}

{
  "result": {
    "ledger": {
      "account_hash": "2D46C219F557BAD8DFE620D1218578CB39E5BC8D95AEAC06F303A255483E480E",
      "close_flags": 0,
      "close_time": 836151662,
      "close_time_iso": "2026-06-30T16:21:02Z",
      "closed": true,
      "ledger_hash": "E9105459DEA958C82F89AE9CE7C1057689BF40628A89DAC61B702748AFE2F261",
      "ledger_index": "105281633",
      "parent_hash": "EC0DE5294940350D17CC3341F3E2D5E61067122C9F9AA962EEF6EBB1E025D633",
      "total_coins": "99985641689667131",
      "transaction_hash": "9D142E002BFC9C52F4E5637D6D683F522BBCBD0C9D468886CB7378AB8FAFC4CF"
    },
    "ledger_hash": "E9105459DEA958C82F89AE9CE7C1057689BF40628A89DAC61B702748AFE2F261",
    "ledger_index": 105281633,
    "status": "success",
    "validated": true
  }
}

{
  "result": {
    "error": "invalidParams",
    "error_code": 31,
    "error_message": "Invalid parameters.",
    "request": {
      "method": "ledger",
      "params": [
        {}
      ]
    },
    "status": "error"
  }
}

{
  "code": 400,
  "message": "Bad Request"
}

Unknown API_key

Method Not Allowed

Missing API_key

{
  "code": 500,
  "message": "Internal Server Error"
}

server_info

server_info operations.

server_info

POST

https://xrp.nownodes.io/

Retrieve information about the server's current state, performance metrics, and configuration. This method provides detailed statistics about RPC method usage, cache status, and ETL processes.

Body

application/json

Retrieve information about the server's current state, performance metrics, and configuration. This method provides detailed statistics about RPC method usage, cache status, and ETL processes.

JSON-RPC request payload.

methodstringserver_inforequired

The JSON-RPC method name

paramsArray<object>required

Ordered JSON-RPC method parameters.

Response

200OK

HTTP 200 response for server_info. The body contains either a successful result or a method-level JSON-RPC error.

400Bad Request

Bad Request. The request body is malformed or contains invalid JSON-RPC parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or node failed while processing the request.

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

server_info

curl -X POST 'https://xrp.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "method": "server_info",
    "params": [
      {}
    ]
  }'

const response = await fetch('https://xrp.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "method": "server_info",
      "params": [
        {}
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "method": "server_info",
  "params": [
    {}
  ]
}

response = requests.post('https://xrp.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "method": "server_info",
  "params": [
    {}
  ]
}

{
  "result": {
    "info": {
      "build_version": "3.2.0",
      "complete_ledgers": "104506102-105281655",
      "load_factor": 1,
      "server_state": "full",
      "peers": 10
    },
    "status": "success"
  }
}

{
  "result": {
    "error": "invalidParams",
    "error_code": 31,
    "error_message": "Invalid parameters.",
    "request": {
      "method": "server_info",
      "params": [
        {}
      ]
    },
    "status": "error"
  }
}

{
  "code": 400,
  "message": "Bad Request"
}

Unknown API_key

Method Not Allowed

Missing API_key

{
  "code": 500,
  "message": "Internal Server Error"
}

Ledger

ledger

ledger operations.

ledger

POST

https://xrp.nownodes.io/

Returns information about a specific ledger version or the current working ledger. This method provides comprehensive details about the state of the ledger at a particular point in time.

Body

application/json

Returns information about a specific ledger version or the current working ledger. This method provides comprehensive details about the state of the ledger at a particular point in time.

JSON-RPC request payload.

methodstringledgerrequired

The JSON-RPC method name

paramsArray<object>required

Ordered JSON-RPC method parameters.

Show child attributes

ledger_hashstring

(Optional) A 20-byte hex string identifying a specific ledger version to use for the request.

ledger_indexstringvalidatedclosedcurrent

The ledger index of the ledger to use for the request.

"validated": The most recent validated ledger (recommended for production use)
"closed": The most recent closed ledger
"current": The current working ledger (in-progress, subject to change)

accountsboolean

If true, include a list of all accounts in the ledger. This can generate a very large response and should be used with caution.

fullboolean

If true, include the entire ledger contents including all transactions and state data. This generates an extremely large response and is rarely needed.

transactionsboolean

If true, include a list of transaction IDs in the ledger. If expand is also true, include full transaction details instead of just IDs.

expandboolean

If true, expand transactions and other ledger objects to include full JSON content instead of just hashes or IDs.

owner_fundsboolean

If true, include an owner_funds field in Offer objects (if present). This field indicates how much the offer creator can afford to pay.

binaryboolean

If true, return ledger data as hex strings instead of JSON. This can be more efficient for some applications.

queueboolean

If true, include information about the current transaction queue. Only applicable when querying the current ledger.

Response

200OK

HTTP 200 response for ledger. The body contains either a successful result or a method-level JSON-RPC error.

400Bad Request

Bad Request. The request body is malformed or contains invalid JSON-RPC parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or node failed while processing the request.

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

ledger

curl -X POST 'https://xrp.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "method": "ledger",
    "params": [
      {
        "ledger_index": "validated",
        "transactions": false,
        "expand": false,
        "owner_funds": false
      }
    ]
  }'

const response = await fetch('https://xrp.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "method": "ledger",
      "params": [
        {
          "ledger_index": "validated",
          "transactions": false,
          "expand": false,
          "owner_funds": false
        }
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "method": "ledger",
  "params": [
    {
      "ledger_index": "validated",
      "transactions": False,
      "expand": False,
      "owner_funds": False
    }
  ]
}

response = requests.post('https://xrp.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "method": "ledger",
  "params": [
    {
      "ledger_index": "validated",
      "transactions": false,
      "expand": false,
      "owner_funds": false
    }
  ]
}

{
  "result": {
    "ledger": {
      "account_hash": "2D46C219F557BAD8DFE620D1218578CB39E5BC8D95AEAC06F303A255483E480E",
      "close_flags": 0,
      "close_time": 836151662,
      "close_time_iso": "2026-06-30T16:21:02Z",
      "closed": true,
      "ledger_hash": "E9105459DEA958C82F89AE9CE7C1057689BF40628A89DAC61B702748AFE2F261",
      "ledger_index": "105281633",
      "parent_hash": "EC0DE5294940350D17CC3341F3E2D5E61067122C9F9AA962EEF6EBB1E025D633",
      "total_coins": "99985641689667131",
      "transaction_hash": "9D142E002BFC9C52F4E5637D6D683F522BBCBD0C9D468886CB7378AB8FAFC4CF"
    },
    "ledger_hash": "E9105459DEA958C82F89AE9CE7C1057689BF40628A89DAC61B702748AFE2F261",
    "ledger_index": 105281633,
    "status": "success",
    "validated": true
  }
}

{
  "result": {
    "error": "invalidParams",
    "error_code": 31,
    "error_message": "Invalid parameters.",
    "request": {
      "method": "ledger",
      "params": [
        {}
      ]
    },
    "status": "error"
  }
}

{
  "code": 400,
  "message": "Bad Request"
}

Unknown API_key

Method Not Allowed

Missing API_key

{
  "code": 500,
  "message": "Internal Server Error"
}

ledger_closed

ledger_closed operations.

ledger_closed

POST

https://xrp.nownodes.io/

Returns the most recently closed ledger index and hash. This method provides a quick way to get the latest validated ledger information without retrieving the full ledger contents.

Body

application/json

Returns the most recently closed ledger index and hash. This method provides a quick way to get the latest validated ledger information without retrieving the full ledger contents.

JSON-RPC request payload.

methodstringledger_closedrequired

The JSON-RPC method name

paramsArray<object>required

Ordered JSON-RPC method parameters.

Response

200OK

HTTP 200 response for ledger_closed. The body contains either a successful result or a method-level JSON-RPC error.

400Bad Request

Bad Request. The request body is malformed or contains invalid JSON-RPC parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or node failed while processing the request.

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

ledger_closed

curl -X POST 'https://xrp.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "method": "ledger_closed",
    "params": [
      {}
    ]
  }'

const response = await fetch('https://xrp.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "method": "ledger_closed",
      "params": [
        {}
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "method": "ledger_closed",
  "params": [
    {}
  ]
}

response = requests.post('https://xrp.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "method": "ledger_closed",
  "params": [
    {}
  ]
}

{
  "result": {
    "ledger_hash": "E9105459DEA958C82F89AE9CE7C1057689BF40628A89DAC61B702748AFE2F261",
    "ledger_index": 105281633,
    "status": "success"
  }
}

{
  "result": {
    "error": "invalidParams",
    "error_code": 31,
    "error_message": "Invalid parameters.",
    "request": {
      "method": "ledger_closed",
      "params": [
        {}
      ]
    },
    "status": "error"
  }
}

{
  "code": 400,
  "message": "Bad Request"
}

Unknown API_key

Method Not Allowed

Missing API_key

{
  "code": 500,
  "message": "Internal Server Error"
}

ledger_current

ledger_current operations.

ledger_current

POST

https://xrp.nownodes.io/

Returns the current working ledger index that is in the process of being built. This ledger is still open and accepting transactions, and has not yet been closed or validated. The contents of this ledger are subject to change until it is closed and validated.

Body

application/json

JSON-RPC request payload.

methodstringledger_currentrequired

The JSON-RPC method name

paramsArray<object>required

Ordered JSON-RPC method parameters.

Response

200OK

HTTP 200 response for ledger_current. The body contains either a successful result or a method-level JSON-RPC error.

400Bad Request

Bad Request. The request body is malformed or contains invalid JSON-RPC parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or node failed while processing the request.

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

ledger_current

curl -X POST 'https://xrp.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "method": "ledger_current",
    "params": [
      {}
    ]
  }'

const response = await fetch('https://xrp.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "method": "ledger_current",
      "params": [
        {}
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "method": "ledger_current",
  "params": [
    {}
  ]
}

response = requests.post('https://xrp.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "method": "ledger_current",
  "params": [
    {}
  ]
}

{
  "result": {
    "ledger_current_index": 105281656,
    "status": "success"
  }
}

{
  "result": {
    "error": "invalidParams",
    "error_code": 31,
    "error_message": "Invalid parameters.",
    "request": {
      "method": "ledger_current",
      "params": [
        {}
      ]
    },
    "status": "error"
  }
}

{
  "code": 400,
  "message": "Bad Request"
}

Unknown API_key

Method Not Allowed

Missing API_key

{
  "code": 500,
  "message": "Internal Server Error"
}

ledger_data

ledger_data operations.

ledger_data

POST

https://xrp.nownodes.io/

Returns the raw contents of a specified ledger, including all state data (accounts, trust lines, offers, etc.). This method provides low-level access to the ledger's state tree and is useful for deep analysis, data export, or building custom indexers.

Body

application/json

JSON-RPC request payload.

methodstringledger_datarequired

The JSON-RPC method name

paramsArray<object>required

Ordered JSON-RPC method parameters.

Show child attributes

ledger_hashstring

A 20-byte hex string identifying a specific ledger version to use for the request. Either ledger_hash or ledger_index must be specified.

ledger_indexstringvalidatedclosedcurrent

The ledger index of the ledger to use for the request.

"validated": The most recent validated ledger
"closed": The most recent closed ledger
"current": The current working ledger

binaryboolean

If true, return ledger objects as hex strings instead of JSON. This is more efficient for processing and storage but requires decoding.

limitinteger

(Optional) Limit the number of ledger objects to retrieve. The server is not required to honor this value.

markerstring

(Optional) Value from a previous paginated response. Resume retrieving data where that response left off.

Response

200OK

HTTP 200 response for ledger_data. The body contains either a successful result or a method-level JSON-RPC error.

400Bad Request

Bad Request. The request body is malformed or contains invalid JSON-RPC parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or node failed while processing the request.

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

ledger_data

curl -X POST 'https://xrp.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "method": "ledger_data",
    "params": [
      {
        "binary": true,
        "ledger_hash": "842B57C1CC0613299A686D3E9F310EC0422C84D3911E5056389AA7E5808A93C8",
        "limit": 5
      }
    ]
  }'

const response = await fetch('https://xrp.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "method": "ledger_data",
      "params": [
        {
          "binary": true,
          "ledger_hash": "842B57C1CC0613299A686D3E9F310EC0422C84D3911E5056389AA7E5808A93C8",
          "limit": 5
        }
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "method": "ledger_data",
  "params": [
    {
      "binary": True,
      "ledger_hash": "842B57C1CC0613299A686D3E9F310EC0422C84D3911E5056389AA7E5808A93C8",
      "limit": 5
    }
  ]
}

response = requests.post('https://xrp.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "method": "ledger_data",
  "params": [
    {
      "binary": true,
      "ledger_hash": "842B57C1CC0613299A686D3E9F310EC0422C84D3911E5056389AA7E5808A93C8",
      "limit": 5
    }
  ]
}

{
  "result": {
    "ledger_index": 105281656,
    "status": "success",
    "validated": true
  }
}

{
  "result": {
    "error": "invalidParams",
    "error_code": 31,
    "error_message": "Invalid parameters.",
    "request": {
      "method": "ledger_data",
      "params": [
        {}
      ]
    },
    "status": "error"
  }
}

{
  "code": 400,
  "message": "Bad Request"
}

Unknown API_key

Method Not Allowed

Missing API_key

{
  "code": 500,
  "message": "Internal Server Error"
}

EVM

eth_accounts

eth_accounts operations.

Ethereum method - eth_accounts

POST

https://xrp.nownodes.io/

Returns an array of addresses controlled by the client.

Body

application/json

Returns an array of addresses controlled by the client.

JSON-RPC request payload.

jsonrpcstringrequired

JSON-RPC version identifier

methodstringeth_accountsrequired

Name of the JSON-RPC method

paramsarrayrequired

No parameters are required for this method. This must be an empty array.

idintegerrequired

Unique identifier for the JSON-RPC request

Response

200OK

HTTP 200 response for eth_accounts. The body contains either a successful result or a method-level JSON-RPC error.

400Bad Request

Bad Request. The request body is malformed or contains invalid JSON-RPC parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or node failed while processing the request.

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

Ethereum method - eth_accounts

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

const response = await fetch('https://xrp.nownodes.io/', {
  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://xrp.nownodes.io/', json=payload)
data = response.json()

Request Body

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

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

{
  "jsonrpc": "2.0",
  "id": 1,
  "error": {
    "code": -32602,
    "message": "invalid argument 0: invalid parameter for eth_accounts"
  }
}

{
  "code": 400,
  "message": "Bad Request"
}

Unknown API_key

Method Not Allowed

Missing API_key

{
  "code": 500,
  "message": "Internal Server Error"
}

eth_blockNumber

eth_blockNumber operations.

Ethereum method - eth_blockNumber

POST

https://xrp.nownodes.io/

Returns the number of the latest block on the chain in hexadecimal format.

Body

application/json

Returns the number of the latest block on the chain in hexadecimal format.

JSON-RPC request payload.

jsonrpcstringrequired

The JSON-RPC protocol version

methodstringeth_blockNumberrequired

Name of the method being called

paramsarrayrequired

This method does not take parameters; always send an empty array.

idintegerrequired

A unique ID for the request

Response

200OK

HTTP 200 response for eth_blockNumber. The body contains either a successful result or a method-level JSON-RPC error.

400Bad Request

Bad Request. The request body is malformed or contains invalid JSON-RPC parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or node failed while processing the request.

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

Ethereum method - eth_blockNumber

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

const response = await fetch('https://xrp.nownodes.io/', {
  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://xrp.nownodes.io/', json=payload)
data = response.json()

Request Body

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

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

{
  "jsonrpc": "2.0",
  "id": 1,
  "error": {
    "code": -32602,
    "message": "invalid argument 0: invalid parameter for eth_blockNumber"
  }
}

{
  "code": 400,
  "message": "Bad Request"
}

Unknown API_key

Method Not Allowed

Missing API_key

{
  "code": 500,
  "message": "Internal Server Error"
}

eth_call

eth_call operations.

Ethereum method - eth_call

POST

https://xrp.nownodes.io/

Executes a call to a contract or address and returns the result without broadcasting a transaction.

Body

application/json

Executes a call to a contract or address and returns the result without broadcasting a transaction.

JSON-RPC request payload.

jsonrpcstringrequired

JSON-RPC protocol version.

methodstringeth_callrequired

JSON-RPC method name.

paramsArray<object | string>required

The first object specifies the call transaction object. The second (optional) parameter specifies the block context.

Show child attributes

Single positional parameter entry.

One of

fromstring

Address the call is sent from (optional)

tostringrequired

Target address for the call (required)

gasstring

Gas provided for the call, as hex

gasPricestring

Gas price in wei, as hex

valuestring

Amount of ETH sent, as hex (optional)

datastring

Compiled contract method call data

(Optional) Integer block number, or the string "latest", "earliest", or "pending".

string

idintegerrequired

Client request identifier echoed by the server.

Response

200OK

HTTP 200 response for eth_call. The body contains either a successful result or a method-level JSON-RPC error.

400Bad Request

Bad Request. The request body is malformed or contains invalid JSON-RPC parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or node failed while processing the request.

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

Ethereum method - eth_call

curl -X POST 'https://xrp.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_call",
    "params": [
      {
        "from": "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
        "to": "0xdAC17F958D2ee523a2206206994597C13D831ec7",
        "gas": "0x76c0",
        "gasPrice": "0x9184e72a000",
        "value": "0x0",
        "data": "0x70a08231000000000000000000000000a0df350d2637096571f7a701cbc1c5fd..."
      }
    ],
    "id": 1
  }'

const response = await fetch('https://xrp.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_call",
      "params": [
        {
          "from": "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
          "to": "0xdAC17F958D2ee523a2206206994597C13D831ec7",
          "gas": "0x76c0",
          "gasPrice": "0x9184e72a000",
          "value": "0x0",
          "data": "0x70a08231000000000000000000000000a0df350d2637096571f7a701cbc1c5fd..."
        }
      ],
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_call",
  "params": [
    {
      "from": "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
      "to": "0xdAC17F958D2ee523a2206206994597C13D831ec7",
      "gas": "0x76c0",
      "gasPrice": "0x9184e72a000",
      "value": "0x0",
      "data": "0x70a08231000000000000000000000000a0df350d2637096571f7a701cbc1c5fd..."
    }
  ],
  "id": 1
}

response = requests.post('https://xrp.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_call",
  "params": [
    {
      "from": "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
      "to": "0xdAC17F958D2ee523a2206206994597C13D831ec7",
      "gas": "0x76c0",
      "gasPrice": "0x9184e72a000",
      "value": "0x0",
      "data": "0x70a08231000000000000000000000000a0df350d2637096571f7a701cbc1c5fd..."
    }
  ],
  "id": 1
}

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

{
  "jsonrpc": "2.0",
  "id": 1,
  "error": {
    "code": -32602,
    "message": "invalid argument 0: invalid parameter for eth_call"
  }
}

{
  "code": 400,
  "message": "Bad Request"
}

Unknown API_key

Method Not Allowed

Missing API_key

{
  "code": 500,
  "message": "Internal Server Error"
}

eth_chainId

eth_chainId operations.

Ethereum method - eth_chainId

POST

https://xrp.nownodes.io/

Returns the hexadecimal string of the current chain ID.

Body

application/json

Returns the hexadecimal string of the current chain ID.

JSON-RPC request payload.

jsonrpcstringrequired

JSON-RPC protocol version

methodstringeth_chainIdrequired

Name of the method to call

paramsarrayrequired

This method does not require parameters. Use an empty array.

idintegerrequired

Unique identifier for the request

Response

200OK

HTTP 200 response for eth_chainId. The body contains either a successful result or a method-level JSON-RPC error.

400Bad Request

Bad Request. The request body is malformed or contains invalid JSON-RPC parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or node failed while processing the request.

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

Ethereum method - eth_chainId

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

const response = await fetch('https://xrp.nownodes.io/', {
  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://xrp.nownodes.io/', json=payload)
data = response.json()

Request Body

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

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

{
  "jsonrpc": "2.0",
  "id": 1,
  "error": {
    "code": -32602,
    "message": "invalid argument 0: invalid parameter for eth_chainId"
  }
}

{
  "code": 400,
  "message": "Bad Request"
}

Unknown API_key

Method Not Allowed

Missing API_key

{
  "code": 500,
  "message": "Internal Server Error"
}

eth_estimateGas

eth_estimateGas operations.

Estimate Gas for Transaction

POST

https://xrp.nownodes.io/

Simulates a transaction and returns an estimate of how much gas would be used.

Body

application/json

Simulates a transaction and returns an estimate of how much gas would be used.

JSON-RPC request payload.

jsonrpcstringrequired

JSON-RPC protocol version

methodstringeth_estimateGasrequired

The method name

paramsArray<object | string>required

The transaction call object and an optional block tag.

Show child attributes

Single positional parameter entry.

One of

fromstring

Address the transaction is sent from (optional)

tostringrequired

Destination address of the call

gasstring

Gas limit provided for execution (optional)

gasPricestring

Gas price in wei (optional)

valuestring

Amount of ETH to send, in hexadecimal wei (optional)

datastring

The compiled input data for the transaction (optional)

Optional block tag (e.g., "latest", "earliest", or a block number)

string

idintegerrequired

Request identifier

Response

200OK

HTTP 200 response for eth_estimateGas. The body contains either a successful result or a method-level JSON-RPC error.

400Bad Request

Bad Request. The request body is malformed or contains invalid JSON-RPC parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or node failed while processing the request.

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

Estimate Gas for Transaction

curl -X POST 'https://xrp.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_estimateGas",
    "params": [
      {
        "from": "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
        "to": "0x6b175474e89094c44da98b954eedeac495271d0f",
        "gas": "0x76c0",
        "gasPrice": "0x9184e72a000",
        "value": "0x0",
        "data": "0x70a08231000000000000000000000000a0df350d2637096571f7a701cbc1c5fd"
      }
    ],
    "id": 1
  }'

const response = await fetch('https://xrp.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_estimateGas",
      "params": [
        {
          "from": "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
          "to": "0x6b175474e89094c44da98b954eedeac495271d0f",
          "gas": "0x76c0",
          "gasPrice": "0x9184e72a000",
          "value": "0x0",
          "data": "0x70a08231000000000000000000000000a0df350d2637096571f7a701cbc1c5fd"
        }
      ],
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_estimateGas",
  "params": [
    {
      "from": "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
      "to": "0x6b175474e89094c44da98b954eedeac495271d0f",
      "gas": "0x76c0",
      "gasPrice": "0x9184e72a000",
      "value": "0x0",
      "data": "0x70a08231000000000000000000000000a0df350d2637096571f7a701cbc1c5fd"
    }
  ],
  "id": 1
}

response = requests.post('https://xrp.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_estimateGas",
  "params": [
    {
      "from": "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
      "to": "0x6b175474e89094c44da98b954eedeac495271d0f",
      "gas": "0x76c0",
      "gasPrice": "0x9184e72a000",
      "value": "0x0",
      "data": "0x70a08231000000000000000000000000a0df350d2637096571f7a701cbc1c5fd"
    }
  ],
  "id": 1
}

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

{
  "jsonrpc": "2.0",
  "id": 1,
  "error": {
    "code": -32602,
    "message": "invalid argument 0: invalid parameter for eth_estimateGas"
  }
}

{
  "code": 400,
  "message": "Bad Request"
}

Unknown API_key

Method Not Allowed

Missing API_key

{
  "code": 500,
  "message": "Internal Server Error"
}

eth_feeHistory

eth_feeHistory operations.

eth_feeHistory

POST

https://xrp.nownodes.io/

Returns fee market information for a range of blocks. This is typically used by wallets and other tools to estimate appropriate gas prices.

Body

application/json

Returns fee market information for a range of blocks. This is typically used by wallets and other tools to estimate appropriate gas prices.

JSON-RPC request payload.

jsonrpcstringrequired

JSON-RPC protocol version.

methodstringeth_feeHistoryrequired

JSON-RPC method name.

paramsArray<string | integer | Array<number>>required

Parameters:

blockCount — number of blocks in the requested range.
newestBlock — highest block number in the requested range (can be "latest").
rewardPercentiles — list of percentile values to sample priority fees from each block (optional).

Show child attributes

Single positional parameter entry.

Any of

Any Of[0] value.

string

Any Of[1] value.

integer

Array<number>

idintegerrequired

Client request identifier echoed by the server.

Response

200OK

HTTP 200 response for eth_feeHistory. The body contains either a successful result or a method-level JSON-RPC error.

400Bad Request

Bad Request. The request body is malformed or contains invalid JSON-RPC parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or node failed while processing the request.

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

eth_feeHistory

curl -X POST 'https://xrp.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_feeHistory",
    "params": [
      "0x5",
      "latest",
      [
        10,
        50,
        90
      ]
    ],
    "id": 1
  }'

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

const data = await response.json();

import requests

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

response = requests.post('https://xrp.nownodes.io/', json=payload)
data = response.json()

Request Body

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

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

{
  "jsonrpc": "2.0",
  "id": 1,
  "error": {
    "code": -32602,
    "message": "invalid argument 0: invalid parameter for eth_feeHistory"
  }
}

{
  "code": 400,
  "message": "Bad Request"
}

Unknown API_key

Method Not Allowed

Missing API_key

{
  "code": 500,
  "message": "Internal Server Error"
}

eth_gasPrice

eth_gasPrice operations.

Get Suggested Gas Price

POST

https://xrp.nownodes.io/

Returns the current gas price in wei as a hexadecimal string. This value is a node estimate based on recent blocks and mempool activity.

Body

application/json

Returns the current gas price in wei as a hexadecimal string. This value is a node estimate based on recent blocks and mempool activity.

JSON-RPC request payload.

jsonrpcstringrequired

JSON-RPC version

methodstringeth_gasPricerequired

JSON-RPC method name

paramsarrayrequired

This method takes an empty array.

idintegerrequired

Request identifier

Response

200OK

HTTP 200 response for eth_gasPrice. The body contains either a successful result or a method-level JSON-RPC error.

400Bad Request

Bad Request. The request body is malformed or contains invalid JSON-RPC parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or node failed while processing the request.

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

Get Suggested Gas Price

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

const response = await fetch('https://xrp.nownodes.io/', {
  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://xrp.nownodes.io/', json=payload)
data = response.json()

Request Body

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

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

{
  "jsonrpc": "2.0",
  "id": 1,
  "error": {
    "code": -32602,
    "message": "invalid argument 0: invalid parameter for eth_gasPrice"
  }
}

{
  "code": 400,
  "message": "Bad Request"
}

Unknown API_key

Method Not Allowed

Missing API_key

{
  "code": 500,
  "message": "Internal Server Error"
}

eth_getBalance

eth_getBalance operations.

Get ETH Balance of an Address

POST

https://xrp.nownodes.io/

Retrieves the balance (in wei) of a given Ethereum address. You can specify the block parameter to get the balance at a specific block.

Body

application/json

Retrieves the balance (in wei) of a given Ethereum address. You can specify the block parameter to get the balance at a specific block.

JSON-RPC request payload.

jsonrpcstringrequired

JSON-RPC version

methodstringeth_getBalancerequired

JSON-RPC method name

paramsArray<string>required

Array with 2 parameters:

Address (20-byte hex string with '0x' prefix)
Block tag (e.g., 'latest', 'earliest', 'pending', or block number in hex)

idintegerrequired

Request ID

Response

200OK

HTTP 200 response for eth_getBalance. The body contains either a successful result or a method-level JSON-RPC error.

400Bad Request

Bad Request. The request body is malformed or contains invalid JSON-RPC parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or node failed while processing the request.

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

Get ETH Balance of an Address

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

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

const data = await response.json();

import requests

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

response = requests.post('https://xrp.nownodes.io/', json=payload)
data = response.json()

Request Body

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

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

{
  "jsonrpc": "2.0",
  "id": 1,
  "error": {
    "code": -32602,
    "message": "invalid argument 0: invalid parameter for eth_getBalance"
  }
}

{
  "code": 400,
  "message": "Bad Request"
}

Unknown API_key

Method Not Allowed

Missing API_key

{
  "code": 500,
  "message": "Internal Server Error"
}

eth_getBlockByHash

eth_getBlockByHash operations.

Get Block by Hash

POST

https://xrp.nownodes.io/

Returns the block information for the specified block hash. The second parameter indicates whether to return full transaction objects or just transaction hashes.

Body

application/json

Returns the block information for the specified block hash. The second parameter indicates whether to return full transaction objects or just transaction hashes.

JSON-RPC request payload.

jsonrpcstringrequired

JSON-RPC version

methodstringeth_getBlockByHashrequired

JSON-RPC method name

paramsArray<string>required

Array of parameters:

Block hash (string)
Boolean flag — if true, return full transactions; if false, only hashes.

idintegerrequired

Request ID

Response

200OK

HTTP 200 response for eth_getBlockByHash. The body contains either a successful result or a method-level JSON-RPC error.

400Bad Request

Bad Request. The request body is malformed or contains invalid JSON-RPC parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or node failed while processing the request.

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

Get Block by Hash

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

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

const data = await response.json();

import requests

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

response = requests.post('https://xrp.nownodes.io/', json=payload)
data = response.json()

Request Body

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

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "baseFeePerGas": "0x2208c4c0",
    "difficulty": "0x0",
    "extraData": "0x",
    "gasLimit": "0x1406f40",
    "gasUsed": "0x0",
    "hash": "0x0fbcedf2ae1138e7feee27714c8f3f6191ff8e968fd23d2a576139931ba86fb2",
    "miner": "0x5110f0b199bcc67534085c83a30d976a3030fadb",
    "number": "0x640bbf",
    "parentHash": "0x53d4463651fd9d667f457c1a1500c153d6a1a97c1c5cc4782fe92bfd16e73f8b",
    "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
    "sha3Uncles": "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
    "size": "0x26b",
    "stateRoot": "0x76a9070fbe298198763ee0a6db2ea7960b9b8bc6d9f7133f0a7c2811fc891ebc",
    "timestamp": "0x6a43ed47",
    "transactions": [],
    "uncles": [],
    "withdrawals": []
  }
}

{
  "jsonrpc": "2.0",
  "id": 1,
  "error": {
    "code": -32602,
    "message": "invalid argument 0: invalid parameter for eth_getBlockByHash"
  }
}

{
  "code": 400,
  "message": "Bad Request"
}

Unknown API_key

Method Not Allowed

Missing API_key

{
  "code": 500,
  "message": "Internal Server Error"
}

eth_getBlockByNumber

eth_getBlockByNumber operations.

Get Block by Number

POST

https://xrp.nownodes.io/

Returns the block information for the specified block number. The second parameter indicates whether to return full transaction objects or just transaction hashes.

Body

application/json

Returns the block information for the specified block number. The second parameter indicates whether to return full transaction objects or just transaction hashes.

JSON-RPC request payload.

jsonrpcstringrequired

JSON-RPC version

methodstringeth_getBlockByNumberrequired

JSON-RPC method name

paramsArray<string>required

Array of parameters:

Block number (hex string, e.g., "0x1b4") or special tags ("latest", "earliest", "pending")
Boolean flag — if true, return full transactions; if false, only hashes.

idintegerrequired

Request ID

Response

200OK

HTTP 200 response for eth_getBlockByNumber. The body contains either a successful result or a method-level JSON-RPC error.

400Bad Request

Bad Request. The request body is malformed or contains invalid JSON-RPC parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or node failed while processing the request.

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

Get Block by Number

curl -X POST 'https://xrp.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_getBlockByNumber",
    "params": [
      "0x1b4",
      false
    ],
    "id": 1
  }'

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

const data = await response.json();

import requests

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

response = requests.post('https://xrp.nownodes.io/', json=payload)
data = response.json()

Request Body

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

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "baseFeePerGas": "0x2208c4c0",
    "difficulty": "0x0",
    "extraData": "0x",
    "gasLimit": "0x1406f40",
    "gasUsed": "0x0",
    "hash": "0x0fbcedf2ae1138e7feee27714c8f3f6191ff8e968fd23d2a576139931ba86fb2",
    "miner": "0x5110f0b199bcc67534085c83a30d976a3030fadb",
    "number": "0x640bbf",
    "parentHash": "0x53d4463651fd9d667f457c1a1500c153d6a1a97c1c5cc4782fe92bfd16e73f8b",
    "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
    "sha3Uncles": "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
    "size": "0x26b",
    "stateRoot": "0x76a9070fbe298198763ee0a6db2ea7960b9b8bc6d9f7133f0a7c2811fc891ebc",
    "timestamp": "0x6a43ed47",
    "transactions": [],
    "uncles": [],
    "withdrawals": []
  }
}

{
  "jsonrpc": "2.0",
  "id": 1,
  "error": {
    "code": -32602,
    "message": "invalid argument 0: invalid parameter for eth_getBlockByNumber"
  }
}

{
  "code": 400,
  "message": "Bad Request"
}

Unknown API_key

Method Not Allowed

Missing API_key

{
  "code": 500,
  "message": "Internal Server Error"
}

eth_getBlockTransactionCountByHash

eth_getBlockTransactionCountByHash operations.

Get Transaction Count by Block Hash

POST

https://xrp.nownodes.io/

Returns the number of transactions contained in the block with the given hash.

Body

application/json

Returns the number of transactions contained in the block with the given hash.

JSON-RPC request payload.

jsonrpcstringrequired

JSON-RPC version

methodstringeth_getBlockTransactionCountByHashrequired

JSON-RPC method name

paramsArray<string>required

Array containing a single parameter:

Block hash as a hex string (32 bytes with 0x prefix)

idintegerrequired

Request ID

Response

200OK

HTTP 200 response for eth_getBlockTransactionCountByHash. The body contains either a successful result or a method-level JSON-RPC error.

400Bad Request

Bad Request. The request body is malformed or contains invalid JSON-RPC parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or node failed while processing the request.

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

Get Transaction Count by Block Hash

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

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

const data = await response.json();

import requests

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

response = requests.post('https://xrp.nownodes.io/', json=payload)
data = response.json()

Request Body

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

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

{
  "jsonrpc": "2.0",
  "id": 1,
  "error": {
    "code": -32602,
    "message": "invalid argument 0: invalid parameter for eth_getBlockTransactionCountByHash"
  }
}

{
  "code": 400,
  "message": "Bad Request"
}

Unknown API_key

Method Not Allowed

Missing API_key

{
  "code": 500,
  "message": "Internal Server Error"
}

eth_getBlockTransactionCountByNumber

eth_getBlockTransactionCountByNumber operations.

Get Transaction Count by Block Number

POST

https://xrp.nownodes.io/

Returns the number of transactions contained in the block with the given block number.

Body

application/json

Returns the number of transactions contained in the block with the given block number.

JSON-RPC request payload.

jsonrpcstringrequired

JSON-RPC version

methodstringeth_getBlockTransactionCountByNumberrequired

JSON-RPC method name

paramsArray<string>required

Array containing a single parameter:

Block number as a hex string (e.g. "0x10d4f" for block 69007) or
predefined block tags such as "latest", "earliest", or "pending"

idintegerrequired

Request ID

Response

200OK

HTTP 200 response for eth_getBlockTransactionCountByNumber. The body contains either a successful result or a method-level JSON-RPC error.

400Bad Request

Bad Request. The request body is malformed or contains invalid JSON-RPC parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or node failed while processing the request.

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

Get Transaction Count by Block Number

curl -X POST 'https://xrp.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_getBlockTransactionCountByNumber",
    "params": [
      "0x10d4f"
    ],
    "id": 1
  }'

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

const data = await response.json();

import requests

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

response = requests.post('https://xrp.nownodes.io/', json=payload)
data = response.json()

Request Body

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

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

{
  "jsonrpc": "2.0",
  "id": 1,
  "error": {
    "code": -32602,
    "message": "invalid argument 0: invalid parameter for eth_getBlockTransactionCountByNumber"
  }
}

{
  "code": 400,
  "message": "Bad Request"
}

Unknown API_key

Method Not Allowed

Missing API_key

{
  "code": 500,
  "message": "Internal Server Error"
}

eth_getCode

eth_getCode operations.

Get Contract Bytecode at Address

POST

https://xrp.nownodes.io/

Returns the contract code stored at a given address. If the address is an externally owned account (EOA), it returns "0x".

Body

application/json

Returns the contract code stored at a given address. If the address is an externally owned account (EOA), it returns "0x".

JSON-RPC request payload.

jsonrpcstringrequired

JSON-RPC version.

methodstringeth_getCoderequired

JSON-RPC method name.

paramsArray<string>required

Parameters array with two elements:

The address to get the code for (hex string, 0x-prefixed).
The block number or block tag (e.g., "latest", "earliest", "pending").

idintegerrequired

Request identifier.

Response

200OK

HTTP 200 response for eth_getCode. The body contains either a successful result or a method-level JSON-RPC error.

400Bad Request

Bad Request. The request body is malformed or contains invalid JSON-RPC parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or node failed while processing the request.

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

Get Contract Bytecode at Address

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

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

const data = await response.json();

import requests

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

response = requests.post('https://xrp.nownodes.io/', json=payload)
data = response.json()

Request Body

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

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

{
  "jsonrpc": "2.0",
  "id": 1,
  "error": {
    "code": -32602,
    "message": "invalid argument 0: invalid parameter for eth_getCode"
  }
}

{
  "code": 400,
  "message": "Bad Request"
}

Unknown API_key

Method Not Allowed

Missing API_key

{
  "code": 500,
  "message": "Internal Server Error"
}

eth_getFilterChanges

eth_getFilterChanges operations.

Get Filter Changes

POST

https://xrp.nownodes.io/

Returns an array of logs that occurred since the last poll for the specified filter ID. The filter must have been previously created with eth_newFilter or eth_newBlockFilter or eth_newPendingTransactionFilter.

Body

application/json

JSON-RPC request payload.

jsonrpcstringrequired

JSON-RPC version.

methodstringeth_getFilterChangesrequired

JSON-RPC method name.

paramsArray<string>required

Parameters array with a single element:

The filter ID (hex string).

idintegerrequired

Request identifier.

Response

200OK

HTTP 200 response for eth_getFilterChanges. The body contains either a successful result or a method-level JSON-RPC error.

400Bad Request

Bad Request. The request body is malformed or contains invalid JSON-RPC parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or node failed while processing the request.

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

Get Filter Changes

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

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

const data = await response.json();

import requests

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

response = requests.post('https://xrp.nownodes.io/', json=payload)
data = response.json()

Request Body

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

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

{
  "jsonrpc": "2.0",
  "id": 1,
  "error": {
    "code": -32602,
    "message": "invalid argument 0: invalid parameter for eth_getFilterChanges"
  }
}

{
  "code": 400,
  "message": "Bad Request"
}

Unknown API_key

Method Not Allowed

Missing API_key

{
  "code": 500,
  "message": "Internal Server Error"
}

eth_getFilterLogs

eth_getFilterLogs operations.

Get Filter Logs

POST

https://xrp.nownodes.io/

Returns all logs matching a filter with the specified filter ID. The filter must have been previously created with eth_newFilter.

Body

application/json

Returns all logs matching a filter with the specified filter ID. The filter must have been previously created with eth_newFilter.

JSON-RPC request payload.

jsonrpcstringrequired

JSON-RPC version.

methodstringeth_getFilterLogsrequired

JSON-RPC method name.

paramsArray<string>required

Parameters array with one element:

The filter ID (hex string).

idintegerrequired

Request identifier.

Response

200OK

HTTP 200 response for eth_getFilterLogs. The body contains either a successful result or a method-level JSON-RPC error.

400Bad Request

Bad Request. The request body is malformed or contains invalid JSON-RPC parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or node failed while processing the request.

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

Get Filter Logs

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

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

const data = await response.json();

import requests

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

response = requests.post('https://xrp.nownodes.io/', json=payload)
data = response.json()

Request Body

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

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

{
  "jsonrpc": "2.0",
  "id": 1,
  "error": {
    "code": -32602,
    "message": "invalid argument 0: invalid parameter for eth_getFilterLogs"
  }
}

{
  "code": 400,
  "message": "Bad Request"
}

Unknown API_key

Method Not Allowed

Missing API_key

{
  "code": 500,
  "message": "Internal Server Error"
}

eth_getLogs

eth_getLogs operations.

Get Logs

POST

https://xrp.nownodes.io/

Returns an array of logs that match the filter criteria specified in the params. The filter object supports filtering by block range, addresses, and topics.

Body

application/json

Returns an array of logs that match the filter criteria specified in the params. The filter object supports filtering by block range, addresses, and topics.

JSON-RPC request payload.

jsonrpcstringrequired

JSON-RPC version.

methodstringeth_getLogsrequired

JSON-RPC method name.

paramsArray<object>required

Parameters array with one element: the filter object.

Show child attributes

fromBlockstring

Starting block number (hex string) or "earliest", "latest", "pending".

toBlockstring

Ending block number (hex string) or "earliest", "latest", "pending".

addressstring | Array<string>

Contract address or list of addresses from which logs should originate.

topicsarray

Array of topic filters. Each topic can be a string, null, or an array of strings for OR filtering.

idintegerrequired

Request identifier.

Response

200OK

HTTP 200 response for eth_getLogs. The body contains either a successful result or a method-level JSON-RPC error.

400Bad Request

Bad Request. The request body is malformed or contains invalid JSON-RPC parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or node failed while processing the request.

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

Get Logs

curl -X POST 'https://xrp.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_getLogs",
    "params": [
      {
        "fromBlock": "0x1b4",
        "toBlock": "0x1f4",
        "address": "0x1234567890abcdef1234567890abcdef12345678",
        "topics": [
          "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
          null,
          [
            "0x000000000000000000000000a7d9ddbe1f17865597fbd27ec712455208b6b76d",
            "0x000000000000000000000000bb9bc244d798123fde783fcc1c72d3bb8c189413"
          ]
        ]
      }
    ],
    "id": 1
  }'

const response = await fetch('https://xrp.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_getLogs",
      "params": [
        {
          "fromBlock": "0x1b4",
          "toBlock": "0x1f4",
          "address": "0x1234567890abcdef1234567890abcdef12345678",
          "topics": [
            "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
            null,
            [
              "0x000000000000000000000000a7d9ddbe1f17865597fbd27ec712455208b6b76d",
              "0x000000000000000000000000bb9bc244d798123fde783fcc1c72d3bb8c189413"
            ]
          ]
        }
      ],
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_getLogs",
  "params": [
    {
      "fromBlock": "0x1b4",
      "toBlock": "0x1f4",
      "address": "0x1234567890abcdef1234567890abcdef12345678",
      "topics": [
        "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
        null,
        [
          "0x000000000000000000000000a7d9ddbe1f17865597fbd27ec712455208b6b76d",
          "0x000000000000000000000000bb9bc244d798123fde783fcc1c72d3bb8c189413"
        ]
      ]
    }
  ],
  "id": 1
}

response = requests.post('https://xrp.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_getLogs",
  "params": [
    {
      "fromBlock": "0x1b4",
      "toBlock": "0x1f4",
      "address": "0x1234567890abcdef1234567890abcdef12345678",
      "topics": [
        "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
        null,
        [
          "0x000000000000000000000000a7d9ddbe1f17865597fbd27ec712455208b6b76d",
          "0x000000000000000000000000bb9bc244d798123fde783fcc1c72d3bb8c189413"
        ]
      ]
    }
  ],
  "id": 1
}

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

{
  "jsonrpc": "2.0",
  "id": 1,
  "error": {
    "code": -32602,
    "message": "invalid argument 0: invalid parameter for eth_getLogs"
  }
}

{
  "code": 400,
  "message": "Bad Request"
}

Unknown API_key

Method Not Allowed

Missing API_key

{
  "code": 500,
  "message": "Internal Server Error"
}

eth_getStorageAt

eth_getStorageAt operations.

Get Storage At

POST

https://xrp.nownodes.io/

Returns the value stored at position in the storage of the contract at address at the given blockNumber.

Body

application/json

Returns the value stored at position in the storage of the contract at address at the given blockNumber.

JSON-RPC request payload.

jsonrpcstringrequired

JSON-RPC version.

methodstringeth_getStorageAtrequired

JSON-RPC method name.

paramsArray<string>required

Parameters array:

address: string - Contract address to query storage from.
position: string - Storage slot position (hex string).
block number: string - Block number or keywords ("latest", "earliest", "pending").

idintegerrequired

Request identifier.

Response

200OK

HTTP 200 response for eth_getStorageAt. The body contains either a successful result or a method-level JSON-RPC error.

400Bad Request

Bad Request. The request body is malformed or contains invalid JSON-RPC parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or node failed while processing the request.

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

Get Storage At

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

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

const data = await response.json();

import requests

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

response = requests.post('https://xrp.nownodes.io/', json=payload)
data = response.json()

Request Body

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

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

{
  "jsonrpc": "2.0",
  "id": 1,
  "error": {
    "code": -32602,
    "message": "invalid argument 0: invalid parameter for eth_getStorageAt"
  }
}

{
  "code": 400,
  "message": "Bad Request"
}

Unknown API_key

Method Not Allowed

Missing API_key

{
  "code": 500,
  "message": "Internal Server Error"
}

eth_getTransactionByBlockHashAndIndex

eth_getTransactionByBlockHashAndIndex operations.

Get Transaction by Block Hash and Index

POST

https://xrp.nownodes.io/

Retrieves the transaction from a block using the block's hash and the transaction's index position within the block.

Body

application/json

Retrieves the transaction from a block using the block's hash and the transaction's index position within the block.

JSON-RPC request payload.

jsonrpcstringrequired

JSON-RPC protocol version.

methodstringeth_getTransactionByBlockHashAndIndexrequired

JSON-RPC method name.

paramsArray<string>required

Parameters:

blockHash (string): The 32-byte hash of the block.
transactionIndex (string): The transaction index (hex).

idintegerrequired

Client request identifier echoed by the server.

Response

200OK

HTTP 200 response for eth_getTransactionByBlockHashAndIndex. The body contains either a successful result or a method-level JSON-RPC error.

400Bad Request

Bad Request. The request body is malformed or contains invalid JSON-RPC parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or node failed while processing the request.

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

Get Transaction by Block Hash and Index

curl -X POST 'https://xrp.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_getTransactionByBlockHashAndIndex",
    "params": [
      "item_example"
    ],
    "id": 1
  }'

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

const data = await response.json();

import requests

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

response = requests.post('https://xrp.nownodes.io/', json=payload)
data = response.json()

Request Body

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

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "blockHash": "0x0fbcedf2ae1138e7feee27714c8f3f6191ff8e968fd23d2a576139931ba86fb2",
    "blockNumber": "0x640bbf",
    "from": "0x5110f0b199bcc67534085c83a30d976a3030fadb",
    "gas": "0x5208",
    "gasPrice": "0x2208c4c0",
    "hash": "0x7c2a0a6bc1f8c4d8960ab3c21ef8aa7e18ce65a8f8d7b3ddf390ad07b2e6a83d",
    "input": "0x",
    "nonce": "0x0",
    "to": "0x0000000000000000000000000000000000000000",
    "transactionIndex": "0x0",
    "value": "0x0",
    "type": "0x2",
    "v": "0x0",
    "r": "0x1",
    "s": "0x1"
  }
}

{
  "jsonrpc": "2.0",
  "id": 1,
  "error": {
    "code": -32602,
    "message": "invalid argument 0: invalid parameter for eth_getTransactionByBlockHashAndIndex"
  }
}

{
  "code": 400,
  "message": "Bad Request"
}

Unknown API_key

Method Not Allowed

Missing API_key

{
  "code": 500,
  "message": "Internal Server Error"
}

eth_getTransactionByBlockNumberAndIndex

eth_getTransactionByBlockNumberAndIndex operations.

Get Transaction by Block Number and Index

POST

https://xrp.nownodes.io/

Returns the information about a transaction using the block number and the transaction index within the block.

Body

application/json

Returns the information about a transaction using the block number and the transaction index within the block.

JSON-RPC request payload.

jsonrpcstringrequired

JSON-RPC protocol version.

methodstringeth_getTransactionByBlockNumberAndIndexrequired

JSON-RPC method name.

paramsArray<string>required

Parameters:

Block number in hex format (e.g., "0x5daf3b")
Transaction index in the block (e.g., "0x0")

idintegerrequired

Client request identifier echoed by the server.

Response

200OK

HTTP 200 response for eth_getTransactionByBlockNumberAndIndex. The body contains either a successful result or a method-level JSON-RPC error.

400Bad Request

Bad Request. The request body is malformed or contains invalid JSON-RPC parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or node failed while processing the request.

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

Get Transaction by Block Number and Index

curl -X POST 'https://xrp.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_getTransactionByBlockNumberAndIndex",
    "params": [
      "item_example"
    ],
    "id": 1
  }'

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

const data = await response.json();

import requests

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

response = requests.post('https://xrp.nownodes.io/', json=payload)
data = response.json()

Request Body

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

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "blockHash": "0x0fbcedf2ae1138e7feee27714c8f3f6191ff8e968fd23d2a576139931ba86fb2",
    "blockNumber": "0x640bbf",
    "from": "0x5110f0b199bcc67534085c83a30d976a3030fadb",
    "gas": "0x5208",
    "gasPrice": "0x2208c4c0",
    "hash": "0x7c2a0a6bc1f8c4d8960ab3c21ef8aa7e18ce65a8f8d7b3ddf390ad07b2e6a83d",
    "input": "0x",
    "nonce": "0x0",
    "to": "0x0000000000000000000000000000000000000000",
    "transactionIndex": "0x0",
    "value": "0x0",
    "type": "0x2",
    "v": "0x0",
    "r": "0x1",
    "s": "0x1"
  }
}

{
  "jsonrpc": "2.0",
  "id": 1,
  "error": {
    "code": -32602,
    "message": "invalid argument 0: invalid parameter for eth_getTransactionByBlockNumberAndIndex"
  }
}

{
  "code": 400,
  "message": "Bad Request"
}

Unknown API_key

Method Not Allowed

Missing API_key

{
  "code": 500,
  "message": "Internal Server Error"
}

eth_getTransactionByHash

eth_getTransactionByHash operations.

Get transaction by hash

POST

https://xrp.nownodes.io/

Calls the eth_getTransactionByHash JSON-RPC method.

Body

application/json

Calls the eth_getTransactionByHash JSON-RPC method.

JSON-RPC request payload.

jsonrpcstringrequired

JSON-RPC protocol version.

methodstringeth_getTransactionByHashrequired

JSON-RPC method name.

paramsArray<string>required

Array containing a single transaction hash

idintegerrequired

Client request identifier echoed by the server.

Response

200OK

HTTP 200 response for eth_getTransactionByHash. The body contains either a successful result or a method-level JSON-RPC error.

400Bad Request

Bad Request. The request body is malformed or contains invalid JSON-RPC parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or node failed while processing the request.

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

Get transaction by hash

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

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

const data = await response.json();

import requests

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

response = requests.post('https://xrp.nownodes.io/', json=payload)
data = response.json()

Request Body

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

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "blockHash": "0x0fbcedf2ae1138e7feee27714c8f3f6191ff8e968fd23d2a576139931ba86fb2",
    "blockNumber": "0x640bbf",
    "from": "0x5110f0b199bcc67534085c83a30d976a3030fadb",
    "gas": "0x5208",
    "gasPrice": "0x2208c4c0",
    "hash": "0x7c2a0a6bc1f8c4d8960ab3c21ef8aa7e18ce65a8f8d7b3ddf390ad07b2e6a83d",
    "input": "0x",
    "nonce": "0x0",
    "to": "0x0000000000000000000000000000000000000000",
    "transactionIndex": "0x0",
    "value": "0x0",
    "type": "0x2",
    "v": "0x0",
    "r": "0x1",
    "s": "0x1"
  }
}

{
  "jsonrpc": "2.0",
  "id": 1,
  "error": {
    "code": -32602,
    "message": "invalid argument 0: invalid parameter for eth_getTransactionByHash"
  }
}

{
  "code": 400,
  "message": "Bad Request"
}

Unknown API_key

Method Not Allowed

Missing API_key

{
  "code": 500,
  "message": "Internal Server Error"
}

eth_getTransactionCount

eth_getTransactionCount operations.

Get transaction count (nonce) for address

POST

https://xrp.nownodes.io/

Calls the eth_getTransactionCount JSON-RPC method.

Body

application/json

Calls the eth_getTransactionCount JSON-RPC method.

JSON-RPC request payload.

jsonrpcstringrequired

JSON-RPC protocol version.

methodstringeth_getTransactionCountrequired

JSON-RPC method name.

paramsArray<string>required

address: The address to check for transaction count.
block: The block parameter (e.g., "latest", "earliest", "pending").

idintegerrequired

Client request identifier echoed by the server.

Response

200OK

HTTP 200 response for eth_getTransactionCount. The body contains either a successful result or a method-level JSON-RPC error.

400Bad Request

Bad Request. The request body is malformed or contains invalid JSON-RPC parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or node failed while processing the request.

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

Get transaction count (nonce) for address

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

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

const data = await response.json();

import requests

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

response = requests.post('https://xrp.nownodes.io/', json=payload)
data = response.json()

Request Body

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

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

{
  "jsonrpc": "2.0",
  "id": 1,
  "error": {
    "code": -32602,
    "message": "invalid argument 0: invalid parameter for eth_getTransactionCount"
  }
}

{
  "code": 400,
  "message": "Bad Request"
}

Unknown API_key

Method Not Allowed

Missing API_key

{
  "code": 500,
  "message": "Internal Server Error"
}

eth_getTransactionReceipt

eth_getTransactionReceipt operations.

Get transaction receipt by hash

POST

https://xrp.nownodes.io/

Calls the eth_getTransactionReceipt JSON-RPC method.

Body

application/json

Calls the eth_getTransactionReceipt JSON-RPC method.

JSON-RPC request payload.

jsonrpcstringrequired

JSON-RPC protocol version.

methodstringeth_getTransactionReceiptrequired

JSON-RPC method name.

paramsArray<string>required

Ordered JSON-RPC method parameters.

idintegerrequired

Client request identifier echoed by the server.

Response

200OK

HTTP 200 response for eth_getTransactionReceipt. The body contains either a successful result or a method-level JSON-RPC error.

400Bad Request

Bad Request. The request body is malformed or contains invalid JSON-RPC parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or node failed while processing the request.

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

Get transaction receipt by hash

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

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

const data = await response.json();

import requests

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

response = requests.post('https://xrp.nownodes.io/', json=payload)
data = response.json()

Request Body

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

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "blockHash": "0x0fbcedf2ae1138e7feee27714c8f3f6191ff8e968fd23d2a576139931ba86fb2",
    "blockNumber": "0x640bbf",
    "contractAddress": null,
    "cumulativeGasUsed": "0x5208",
    "effectiveGasPrice": "0x2208c4c0",
    "from": "0x5110f0b199bcc67534085c83a30d976a3030fadb",
    "gasUsed": "0x5208",
    "logs": [],
    "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
    "status": "0x1",
    "to": "0x0000000000000000000000000000000000000000",
    "transactionHash": "0x7c2a0a6bc1f8c4d8960ab3c21ef8aa7e18ce65a8f8d7b3ddf390ad07b2e6a83d",
    "transactionIndex": "0x0",
    "type": "0x2"
  }
}

{
  "jsonrpc": "2.0",
  "id": 1,
  "error": {
    "code": -32602,
    "message": "invalid argument 0: invalid parameter for eth_getTransactionReceipt"
  }
}

{
  "code": 400,
  "message": "Bad Request"
}

Unknown API_key

Method Not Allowed

Missing API_key

{
  "code": 500,
  "message": "Internal Server Error"
}

eth_getUncleByBlockHashAndIndex

eth_getUncleByBlockHashAndIndex operations.

Get uncle block by block hash and index

POST

https://xrp.nownodes.io/

Calls the eth_getUncleByBlockHashAndIndex JSON-RPC method.

Body

application/json

Calls the eth_getUncleByBlockHashAndIndex JSON-RPC method.

JSON-RPC request payload.

jsonrpcstringrequired

JSON-RPC protocol version.

methodstringeth_getUncleByBlockHashAndIndexrequired

JSON-RPC method name.

paramsArray<string>required

blockHash: 32-byte block hash
index: the uncle index as hex (e.g., "0x0" for the first uncle)

idintegerrequired

Client request identifier echoed by the server.

Response

200OK

HTTP 200 response for eth_getUncleByBlockHashAndIndex. The body contains either a successful result or a method-level JSON-RPC error.

400Bad Request

Bad Request. The request body is malformed or contains invalid JSON-RPC parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or node failed while processing the request.

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

Get uncle block by block hash and index

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

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

const data = await response.json();

import requests

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

response = requests.post('https://xrp.nownodes.io/', json=payload)
data = response.json()

Request Body

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

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

{
  "jsonrpc": "2.0",
  "id": 1,
  "error": {
    "code": -32602,
    "message": "invalid argument 0: invalid parameter for eth_getUncleByBlockHashAndIndex"
  }
}

{
  "code": 400,
  "message": "Bad Request"
}

Unknown API_key

Method Not Allowed

Missing API_key

{
  "code": 500,
  "message": "Internal Server Error"
}

eth_getUncleByBlockNumberAndIndex

eth_getUncleByBlockNumberAndIndex operations.

Get uncle block by block number and index

POST

https://xrp.nownodes.io/

Calls the eth_getUncleByBlockNumberAndIndex JSON-RPC method.

Body

application/json

Calls the eth_getUncleByBlockNumberAndIndex JSON-RPC method.

JSON-RPC request payload.

jsonrpcstringrequired

JSON-RPC protocol version.

methodstringeth_getUncleByBlockNumberAndIndexrequired

JSON-RPC method name.

paramsArray<string>required

blockNumber: The block number as hex string (e.g., "0x10fb78"), or "latest", "earliest", "pending".
index: The uncle index as hex (e.g., "0x0" for the first uncle).

idintegerrequired

Client request identifier echoed by the server.

Response

200OK

HTTP 200 response for eth_getUncleByBlockNumberAndIndex. The body contains either a successful result or a method-level JSON-RPC error.

400Bad Request

Bad Request. The request body is malformed or contains invalid JSON-RPC parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or node failed while processing the request.

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

Get uncle block by block number and index

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

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

const data = await response.json();

import requests

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

response = requests.post('https://xrp.nownodes.io/', json=payload)
data = response.json()

Request Body

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

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

{
  "jsonrpc": "2.0",
  "id": 1,
  "error": {
    "code": -32602,
    "message": "invalid argument 0: invalid parameter for eth_getUncleByBlockNumberAndIndex"
  }
}

{
  "code": 400,
  "message": "Bad Request"
}

Unknown API_key

Method Not Allowed

Missing API_key

{
  "code": 500,
  "message": "Internal Server Error"
}

eth_getUncleCountByBlockHash

eth_getUncleCountByBlockHash operations.

Get the number of uncle blocks by block hash

POST

https://xrp.nownodes.io/

Calls the eth_getUncleCountByBlockHash JSON-RPC method.

Body

application/json

Calls the eth_getUncleCountByBlockHash JSON-RPC method.

JSON-RPC request payload.

jsonrpcstringrequired

JSON-RPC protocol version.

methodstringeth_getUncleCountByBlockHashrequired

JSON-RPC method name.

paramsArray<string>required

An array containing the block hash.

idintegerrequired

Client request identifier echoed by the server.

Response

200OK

HTTP 200 response for eth_getUncleCountByBlockHash. The body contains either a successful result or a method-level JSON-RPC error.

400Bad Request

Bad Request. The request body is malformed or contains invalid JSON-RPC parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or node failed while processing the request.

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

Get the number of uncle blocks by block hash

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

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

const data = await response.json();

import requests

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

response = requests.post('https://xrp.nownodes.io/', json=payload)
data = response.json()

Request Body

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

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

{
  "jsonrpc": "2.0",
  "id": 1,
  "error": {
    "code": -32602,
    "message": "invalid argument 0: invalid parameter for eth_getUncleCountByBlockHash"
  }
}

{
  "code": 400,
  "message": "Bad Request"
}

Unknown API_key

Method Not Allowed

Missing API_key

{
  "code": 500,
  "message": "Internal Server Error"
}

eth_getUncleCountByBlockNumber

eth_getUncleCountByBlockNumber operations.

Get the number of uncle blocks by block number

POST

https://xrp.nownodes.io/

Calls the eth_getUncleCountByBlockNumber JSON-RPC method.

Body

application/json

Calls the eth_getUncleCountByBlockNumber JSON-RPC method.

JSON-RPC request payload.

jsonrpcstringrequired

JSON-RPC protocol version.

methodstringeth_getUncleCountByBlockNumberrequired

JSON-RPC method name.

paramsArray<string>required

An array containing the block number as a hex string.

idintegerrequired

Client request identifier echoed by the server.

Response

200OK

HTTP 200 response for eth_getUncleCountByBlockNumber. The body contains either a successful result or a method-level JSON-RPC error.

400Bad Request

Bad Request. The request body is malformed or contains invalid JSON-RPC parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or node failed while processing the request.

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

Get the number of uncle blocks by block number

curl -X POST 'https://xrp.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_getUncleCountByBlockNumber",
    "params": [
      "0x10d4f"
    ],
    "id": 1
  }'

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

const data = await response.json();

import requests

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

response = requests.post('https://xrp.nownodes.io/', json=payload)
data = response.json()

Request Body

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

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

{
  "jsonrpc": "2.0",
  "id": 1,
  "error": {
    "code": -32602,
    "message": "invalid argument 0: invalid parameter for eth_getUncleCountByBlockNumber"
  }
}

{
  "code": 400,
  "message": "Bad Request"
}

Unknown API_key

Method Not Allowed

Missing API_key

{
  "code": 500,
  "message": "Internal Server Error"
}

eth_maxPriorityFeePerGas

eth_maxPriorityFeePerGas operations.

Get recommended maxPriorityFeePerGas value

POST

https://xrp.nownodes.io/

Calls the eth_maxPriorityFeePerGas JSON-RPC method.

Body

application/json

Calls the eth_maxPriorityFeePerGas JSON-RPC method.

JSON-RPC request payload.

jsonrpcstringrequired

JSON-RPC protocol version.

methodstringeth_maxPriorityFeePerGasrequired

JSON-RPC method name.

paramsarrayrequired

No parameters are required.

idintegerrequired

Client request identifier echoed by the server.

Response

200OK

HTTP 200 response for eth_maxPriorityFeePerGas. The body contains either a successful result or a method-level JSON-RPC error.

400Bad Request

Bad Request. The request body is malformed or contains invalid JSON-RPC parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or node failed while processing the request.

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

Get recommended maxPriorityFeePerGas value

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

const response = await fetch('https://xrp.nownodes.io/', {
  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://xrp.nownodes.io/', json=payload)
data = response.json()

Request Body

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

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

{
  "jsonrpc": "2.0",
  "id": 1,
  "error": {
    "code": -32602,
    "message": "invalid argument 0: invalid parameter for eth_maxPriorityFeePerGas"
  }
}

{
  "code": 400,
  "message": "Bad Request"
}

Unknown API_key

Method Not Allowed

Missing API_key

{
  "code": 500,
  "message": "Internal Server Error"
}

eth_newBlockFilter

eth_newBlockFilter operations.

Create a new block filter

POST

https://xrp.nownodes.io/

Calls the eth_newBlockFilter JSON-RPC method.

Body

application/json

Calls the eth_newBlockFilter JSON-RPC method.

JSON-RPC request payload.

jsonrpcstringrequired

JSON-RPC protocol version.

methodstringeth_newBlockFilterrequired

JSON-RPC method name.

paramsArray<any>required

This method does not require any parameters.

idintegerrequired

Client request identifier echoed by the server.

Response

200OK

HTTP 200 response for eth_newBlockFilter. The body contains either a successful result or a method-level JSON-RPC error.

400Bad Request

Bad Request. The request body is malformed or contains invalid JSON-RPC parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or node failed while processing the request.

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

Create a new block filter

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

const response = await fetch('https://xrp.nownodes.io/', {
  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://xrp.nownodes.io/', json=payload)
data = response.json()

Request Body

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

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

{
  "jsonrpc": "2.0",
  "id": 1,
  "error": {
    "code": -32602,
    "message": "invalid argument 0: invalid parameter for eth_newBlockFilter"
  }
}

{
  "code": 400,
  "message": "Bad Request"
}

Unknown API_key

Method Not Allowed

Missing API_key

{
  "code": 500,
  "message": "Internal Server Error"
}

eth_newFilter

eth_newFilter operations.

Create a new log filter

POST

https://xrp.nownodes.io/

Calls the eth_newFilter JSON-RPC method.

Body

application/json

Calls the eth_newFilter JSON-RPC method.

JSON-RPC request payload.

jsonrpcstringrequired

JSON-RPC protocol version.

methodstringeth_newFilterrequired

JSON-RPC method name.

paramsArray<object>required

Array with one object describing the filter options.

Show child attributes

fromBlockstring

Starting block number or tag ("latest", "earliest", "pending").

toBlockstring

Ending block number or tag.

addressstring | Array<string> | null

Address value.

topicsArray<string | Array<string>> | null

Array of topic filters. Topics are 32-byte hashes identifying events.

Show child attributes

Single positional parameter entry.

One of

One Of[0] value.

string

Array<string>

idintegerrequired

Client request identifier echoed by the server.

Response

200OK

HTTP 200 response for eth_newFilter. The body contains either a successful result or a method-level JSON-RPC error.

400Bad Request

Bad Request. The request body is malformed or contains invalid JSON-RPC parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or node failed while processing the request.

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

Create a new log filter

curl -X POST 'https://xrp.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_newFilter",
    "params": [
      {
        "fromBlock": "latest",
        "toBlock": "latest",
        "address": "0x1234567890abcdef1234567890abcdef12345678",
        "topics": [
          "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef"
        ]
      }
    ],
    "id": 1
  }'

const response = await fetch('https://xrp.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_newFilter",
      "params": [
        {
          "fromBlock": "latest",
          "toBlock": "latest",
          "address": "0x1234567890abcdef1234567890abcdef12345678",
          "topics": [
            "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef"
          ]
        }
      ],
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_newFilter",
  "params": [
    {
      "fromBlock": "latest",
      "toBlock": "latest",
      "address": "0x1234567890abcdef1234567890abcdef12345678",
      "topics": [
        "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef"
      ]
    }
  ],
  "id": 1
}

response = requests.post('https://xrp.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_newFilter",
  "params": [
    {
      "fromBlock": "latest",
      "toBlock": "latest",
      "address": "0x1234567890abcdef1234567890abcdef12345678",
      "topics": [
        "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef"
      ]
    }
  ],
  "id": 1
}

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

{
  "jsonrpc": "2.0",
  "id": 1,
  "error": {
    "code": -32602,
    "message": "invalid argument 0: invalid parameter for eth_newFilter"
  }
}

{
  "code": 400,
  "message": "Bad Request"
}

Unknown API_key

Method Not Allowed

Missing API_key

{
  "code": 500,
  "message": "Internal Server Error"
}

eth_newPendingTransactionFilter

eth_newPendingTransactionFilter operations.

Create a filter for pending transactions

POST

https://xrp.nownodes.io/

Calls the eth_newPendingTransactionFilter JSON-RPC method.

Body

application/json

Calls the eth_newPendingTransactionFilter JSON-RPC method.

JSON-RPC request payload.

jsonrpcstringrequired

JSON-RPC version

methodstringeth_newPendingTransactionFilterrequired

JSON-RPC method name

paramsArray<any>required

No parameters required for this method

idintegerrequired

Request identifier

Response

200OK

HTTP 200 response for eth_newPendingTransactionFilter. The body contains either a successful result or a method-level JSON-RPC error.

400Bad Request

Bad Request. The request body is malformed or contains invalid JSON-RPC parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or node failed while processing the request.

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

Create a filter for pending transactions

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

const response = await fetch('https://xrp.nownodes.io/', {
  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://xrp.nownodes.io/', json=payload)
data = response.json()

Request Body

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

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "blockHash": "0x0fbcedf2ae1138e7feee27714c8f3f6191ff8e968fd23d2a576139931ba86fb2",
    "blockNumber": "0x640bbf",
    "from": "0x5110f0b199bcc67534085c83a30d976a3030fadb",
    "gas": "0x5208",
    "gasPrice": "0x2208c4c0",
    "hash": "0x7c2a0a6bc1f8c4d8960ab3c21ef8aa7e18ce65a8f8d7b3ddf390ad07b2e6a83d",
    "input": "0x",
    "nonce": "0x0",
    "to": "0x0000000000000000000000000000000000000000",
    "transactionIndex": "0x0",
    "value": "0x0",
    "type": "0x2",
    "v": "0x0",
    "r": "0x1",
    "s": "0x1"
  }
}

{
  "jsonrpc": "2.0",
  "id": 1,
  "error": {
    "code": -32602,
    "message": "invalid argument 0: invalid parameter for eth_newPendingTransactionFilter"
  }
}

{
  "code": 400,
  "message": "Bad Request"
}

Unknown API_key

Method Not Allowed

Missing API_key

{
  "code": 500,
  "message": "Internal Server Error"
}

eth_sendRawTransaction

eth_sendRawTransaction operations.

Send a raw signed transaction

POST

https://xrp.nownodes.io/

Calls the eth_sendRawTransaction JSON-RPC method.

Body

application/json

Calls the eth_sendRawTransaction JSON-RPC method.

JSON-RPC request payload.

jsonrpcstringrequired

JSON-RPC version

methodstringeth_sendRawTransactionrequired

Method name

paramsArray<string>required

Array containing a single signed transaction data (hex string)

idintegerrequired

Request ID

Response

200OK

HTTP 200 response for eth_sendRawTransaction. The body contains either a successful result or a method-level JSON-RPC error.

400Bad Request

Bad Request. The request body is malformed or contains invalid JSON-RPC parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or node failed while processing the request.

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

Send a raw signed transaction

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

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

const data = await response.json();

import requests

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

response = requests.post('https://xrp.nownodes.io/', json=payload)
data = response.json()

Request Body

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

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "blockHash": "0x0fbcedf2ae1138e7feee27714c8f3f6191ff8e968fd23d2a576139931ba86fb2",
    "blockNumber": "0x640bbf",
    "from": "0x5110f0b199bcc67534085c83a30d976a3030fadb",
    "gas": "0x5208",
    "gasPrice": "0x2208c4c0",
    "hash": "0x7c2a0a6bc1f8c4d8960ab3c21ef8aa7e18ce65a8f8d7b3ddf390ad07b2e6a83d",
    "input": "0x",
    "nonce": "0x0",
    "to": "0x0000000000000000000000000000000000000000",
    "transactionIndex": "0x0",
    "value": "0x0",
    "type": "0x2",
    "v": "0x0",
    "r": "0x1",
    "s": "0x1"
  }
}

{
  "jsonrpc": "2.0",
  "id": 1,
  "error": {
    "code": -32602,
    "message": "invalid argument 0: invalid parameter for eth_sendRawTransaction"
  }
}

{
  "code": 400,
  "message": "Bad Request"
}

Unknown API_key

Method Not Allowed

Missing API_key

{
  "code": 500,
  "message": "Internal Server Error"
}

eth_sendTransaction

eth_sendTransaction operations.

Send a transaction using node-managed account

POST

https://xrp.nownodes.io/

Calls the eth_sendTransaction JSON-RPC method.

Body

application/json

Calls the eth_sendTransaction JSON-RPC method.

JSON-RPC request payload.

jsonrpcstringrequired

JSON-RPC protocol version.

methodstringeth_sendTransactionrequired

JSON-RPC method name.

paramsArray<object>required

Transaction object

Show child attributes

fromstring

Address the transaction is sent from

tostring

Address the transaction is directed to

gasstring

Gas provided for the transaction (hex)

gasPricestring

Gas price in wei (hex)

valuestring

Value sent with the transaction in wei (hex)

datastring

(Optional) Data for contract interaction

idintegerrequired

Client request identifier echoed by the server.

Response

200OK

HTTP 200 response for eth_sendTransaction. The body contains either a successful result or a method-level JSON-RPC error.

400Bad Request

Bad Request. The request body is malformed or contains invalid JSON-RPC parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or node failed while processing the request.

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

Send a transaction using node-managed account

curl -X POST 'https://xrp.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_sendTransaction",
    "params": [
      {
        "from": "0x6A0bF1017C6e6Dd9D2BA447E2AAd951F13F7F7C3",
        "to": "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
        "gas": "0x5208",
        "gasPrice": "0x3b9aca00",
        "value": "0x16345785d8a0000",
        "data": "0x"
      }
    ],
    "id": 1
  }'

const response = await fetch('https://xrp.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_sendTransaction",
      "params": [
        {
          "from": "0x6A0bF1017C6e6Dd9D2BA447E2AAd951F13F7F7C3",
          "to": "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
          "gas": "0x5208",
          "gasPrice": "0x3b9aca00",
          "value": "0x16345785d8a0000",
          "data": "0x"
        }
      ],
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_sendTransaction",
  "params": [
    {
      "from": "0x6A0bF1017C6e6Dd9D2BA447E2AAd951F13F7F7C3",
      "to": "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
      "gas": "0x5208",
      "gasPrice": "0x3b9aca00",
      "value": "0x16345785d8a0000",
      "data": "0x"
    }
  ],
  "id": 1
}

response = requests.post('https://xrp.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_sendTransaction",
  "params": [
    {
      "from": "0x6A0bF1017C6e6Dd9D2BA447E2AAd951F13F7F7C3",
      "to": "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
      "gas": "0x5208",
      "gasPrice": "0x3b9aca00",
      "value": "0x16345785d8a0000",
      "data": "0x"
    }
  ],
  "id": 1
}

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "blockHash": "0x0fbcedf2ae1138e7feee27714c8f3f6191ff8e968fd23d2a576139931ba86fb2",
    "blockNumber": "0x640bbf",
    "from": "0x5110f0b199bcc67534085c83a30d976a3030fadb",
    "gas": "0x5208",
    "gasPrice": "0x2208c4c0",
    "hash": "0x7c2a0a6bc1f8c4d8960ab3c21ef8aa7e18ce65a8f8d7b3ddf390ad07b2e6a83d",
    "input": "0x",
    "nonce": "0x0",
    "to": "0x0000000000000000000000000000000000000000",
    "transactionIndex": "0x0",
    "value": "0x0",
    "type": "0x2",
    "v": "0x0",
    "r": "0x1",
    "s": "0x1"
  }
}

{
  "jsonrpc": "2.0",
  "id": 1,
  "error": {
    "code": -32602,
    "message": "invalid argument 0: invalid parameter for eth_sendTransaction"
  }
}

{
  "code": 400,
  "message": "Bad Request"
}

Unknown API_key

Method Not Allowed

Missing API_key

{
  "code": 500,
  "message": "Internal Server Error"
}

eth_sign

eth_sign operations.

Sign arbitrary data using eth_sign

POST

https://xrp.nownodes.io/

Calls the eth_sign JSON-RPC method.

Body

application/json

Calls the eth_sign JSON-RPC method.

JSON-RPC request payload.

jsonrpcstringrequired

JSON-RPC protocol version.

methodstringeth_signrequired

JSON-RPC method name.

paramsArray<string>required

[address, data]

address: The account that will sign the data
data: The data to be signed (must be a hex string)

idintegerrequired

Client request identifier echoed by the server.

Response

200OK

HTTP 200 response for eth_sign. The body contains either a successful result or a method-level JSON-RPC error.

400Bad Request

Bad Request. The request body is malformed or contains invalid JSON-RPC parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or node failed while processing the request.

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

Sign arbitrary data using eth_sign

curl -X POST 'https://xrp.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_sign",
    "params": [
      "item_example"
    ],
    "id": 1
  }'

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

const data = await response.json();

import requests

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

response = requests.post('https://xrp.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_sign",
  "params": [
    "0x6A0bF1017C6e6Dd9D2BA447E2AAd951F13F7F7C3",
    "0x68656c6c6f20776f726c64"
  ],
  "id": 1
}

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

{
  "jsonrpc": "2.0",
  "id": 1,
  "error": {
    "code": -32602,
    "message": "invalid argument 0: invalid parameter for eth_sign"
  }
}

{
  "code": 400,
  "message": "Bad Request"
}

Unknown API_key

Method Not Allowed

Missing API_key

{
  "code": 500,
  "message": "Internal Server Error"
}

eth_signTransaction

eth_signTransaction operations.

eth_signTransaction

POST

https://xrp.nownodes.io/

Signs a transaction locally with the private key of the specified account.

Body

application/json

Signs a transaction locally with the private key of the specified account.

JSON-RPC request payload.

jsonrpcstringrequired

JSON-RPC protocol version.

methodstringeth_signTransactionrequired

JSON-RPC method name.

paramsArray<object>required

Array with a single object representing the transaction to sign.

Show child attributes

fromstringrequired

The address of the account that will sign the transaction.

tostring

The destination address of the transaction.

gasstring

Gas limit for the transaction, as a hex string.

gasPricestring

Gas price in wei, as a hex string.

valuestring

Amount of wei to send, as a hex string.

datastring

Data payload of the transaction, hex encoded.

noncestring

Nonce of the transaction, as a hex string.

chainIdinteger

The chain ID to protect against replay attacks.

idintegerrequired

Client request identifier echoed by the server.

Response

200OK

HTTP 200 response for eth_signTransaction. The body contains either a successful result or a method-level JSON-RPC error.

400Bad Request

Bad Request. The request body is malformed or contains invalid JSON-RPC parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or node failed while processing the request.

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

eth_signTransaction

curl -X POST 'https://xrp.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_signTransaction",
    "params": [
      {
        "from": "0x407d73d8a49eeb85d32cf465507dd71d507100c1",
        "to": "0x85a3d76e3a6a4b16b5b442c1b11a03bdcc0a9f30",
        "gas": "0x5208",
        "gasPrice": "0x4a817c800",
        "value": "0xde0b6b3a7640000",
        "data": "0x",
        "nonce": "0x1",
        "chainId": 1
      }
    ],
    "id": 1
  }'

const response = await fetch('https://xrp.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "eth_signTransaction",
      "params": [
        {
          "from": "0x407d73d8a49eeb85d32cf465507dd71d507100c1",
          "to": "0x85a3d76e3a6a4b16b5b442c1b11a03bdcc0a9f30",
          "gas": "0x5208",
          "gasPrice": "0x4a817c800",
          "value": "0xde0b6b3a7640000",
          "data": "0x",
          "nonce": "0x1",
          "chainId": 1
        }
      ],
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "eth_signTransaction",
  "params": [
    {
      "from": "0x407d73d8a49eeb85d32cf465507dd71d507100c1",
      "to": "0x85a3d76e3a6a4b16b5b442c1b11a03bdcc0a9f30",
      "gas": "0x5208",
      "gasPrice": "0x4a817c800",
      "value": "0xde0b6b3a7640000",
      "data": "0x",
      "nonce": "0x1",
      "chainId": 1
    }
  ],
  "id": 1
}

response = requests.post('https://xrp.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "2.0",
  "method": "eth_signTransaction",
  "params": [
    {
      "from": "0x407d73d8a49eeb85d32cf465507dd71d507100c1",
      "to": "0x85a3d76e3a6a4b16b5b442c1b11a03bdcc0a9f30",
      "gas": "0x5208",
      "gasPrice": "0x4a817c800",
      "value": "0xde0b6b3a7640000",
      "data": "0x",
      "nonce": "0x1",
      "chainId": 1
    }
  ],
  "id": 1
}

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "blockHash": "0x0fbcedf2ae1138e7feee27714c8f3f6191ff8e968fd23d2a576139931ba86fb2",
    "blockNumber": "0x640bbf",
    "from": "0x5110f0b199bcc67534085c83a30d976a3030fadb",
    "gas": "0x5208",
    "gasPrice": "0x2208c4c0",
    "hash": "0x7c2a0a6bc1f8c4d8960ab3c21ef8aa7e18ce65a8f8d7b3ddf390ad07b2e6a83d",
    "input": "0x",
    "nonce": "0x0",
    "to": "0x0000000000000000000000000000000000000000",
    "transactionIndex": "0x0",
    "value": "0x0",
    "type": "0x2",
    "v": "0x0",
    "r": "0x1",
    "s": "0x1"
  }
}

{
  "jsonrpc": "2.0",
  "id": 1,
  "error": {
    "code": -32602,
    "message": "invalid argument 0: invalid parameter for eth_signTransaction"
  }
}

{
  "code": 400,
  "message": "Bad Request"
}

Unknown API_key

Method Not Allowed

Missing API_key

{
  "code": 500,
  "message": "Internal Server Error"
}

eth_syncing

eth_syncing operations.

Check if node is syncing

POST

https://xrp.nownodes.io/

Calls the eth_syncing JSON-RPC method.

Body

application/json

Calls the eth_syncing JSON-RPC method.

JSON-RPC request payload.

jsonrpcstringrequired

JSON-RPC protocol version.

methodstringeth_syncingrequired

JSON-RPC method name.

paramsarrayrequired

Must be an empty array.

idintegerrequired

Client request identifier echoed by the server.

Response

200OK

HTTP 200 response for eth_syncing. The body contains either a successful result or a method-level JSON-RPC error.

400Bad Request

Bad Request. The request body is malformed or contains invalid JSON-RPC parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or node failed while processing the request.

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

Check if node is syncing

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

const response = await fetch('https://xrp.nownodes.io/', {
  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://xrp.nownodes.io/', json=payload)
data = response.json()

Request Body

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

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

{
  "jsonrpc": "2.0",
  "id": 1,
  "error": {
    "code": -32602,
    "message": "invalid argument 0: invalid parameter for eth_syncing"
  }
}

{
  "code": 400,
  "message": "Bad Request"
}

Unknown API_key

Method Not Allowed

Missing API_key

{
  "code": 500,
  "message": "Internal Server Error"
}

eth_uninstallFilter

eth_uninstallFilter operations.

Uninstall an existing filter

POST

https://xrp.nownodes.io/

Calls the eth_uninstallFilter JSON-RPC method.

Body

application/json

Calls the eth_uninstallFilter JSON-RPC method.

JSON-RPC request payload.

jsonrpcstringrequired

JSON-RPC protocol version.

methodstringeth_uninstallFilterrequired

JSON-RPC method name.

paramsArray<string>required

Ordered JSON-RPC method parameters.

idintegerrequired

Client request identifier echoed by the server.

Response

200OK

HTTP 200 response for eth_uninstallFilter. The body contains either a successful result or a method-level JSON-RPC error.

400Bad Request

Bad Request. The request body is malformed or contains invalid JSON-RPC parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or node failed while processing the request.

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

Uninstall an existing filter

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

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

const data = await response.json();

import requests

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

response = requests.post('https://xrp.nownodes.io/', json=payload)
data = response.json()

Request Body

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

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

{
  "jsonrpc": "2.0",
  "id": 1,
  "error": {
    "code": -32602,
    "message": "invalid argument 0: invalid parameter for eth_uninstallFilter"
  }
}

{
  "code": 400,
  "message": "Bad Request"
}

Unknown API_key

Method Not Allowed

Missing API_key

{
  "code": 500,
  "message": "Internal Server Error"
}

net_listening

net_listening operations.

net_listening

POST

https://xrp.nownodes.io/

Checks if the client is listening for network connections.

Body

application/json

Checks if the client is listening for network connections.

JSON-RPC request payload.

jsonrpcstringrequired

JSON-RPC protocol version.

methodstringnet_listeningrequired

JSON-RPC method name.

paramsarrayrequired

This method takes no parameters.

idintegerrequired

Client request identifier echoed by the server.

Response

200OK

HTTP 200 response for net_listening. The body contains either a successful result or a method-level JSON-RPC error.

400Bad Request

Bad Request. The request body is malformed or contains invalid JSON-RPC parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or node failed while processing the request.

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

net_listening

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

const response = await fetch('https://xrp.nownodes.io/', {
  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://xrp.nownodes.io/', json=payload)
data = response.json()

Request Body

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

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

{
  "jsonrpc": "2.0",
  "id": 1,
  "error": {
    "code": -32602,
    "message": "invalid argument 0: invalid parameter for net_listening"
  }
}

{
  "code": 400,
  "message": "Bad Request"
}

Unknown API_key

Method Not Allowed

Missing API_key

{
  "code": 500,
  "message": "Internal Server Error"
}

net_peerCount

net_peerCount operations.

net_peerCount

POST

https://xrp.nownodes.io/

Returns the number of peers currently connected to the client.

Body

application/json

Returns the number of peers currently connected to the client.

JSON-RPC request payload.

jsonrpcstringrequired

JSON-RPC protocol version.

methodstringnet_peerCountrequired

JSON-RPC method name.

paramsarrayrequired

This method takes no parameters.

idintegerrequired

Client request identifier echoed by the server.

Response

200OK

HTTP 200 response for net_peerCount. The body contains either a successful result or a method-level JSON-RPC error.

400Bad Request

Bad Request. The request body is malformed or contains invalid JSON-RPC parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or node failed while processing the request.

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

net_peerCount

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

const response = await fetch('https://xrp.nownodes.io/', {
  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://xrp.nownodes.io/', json=payload)
data = response.json()

Request Body

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

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

{
  "jsonrpc": "2.0",
  "id": 1,
  "error": {
    "code": -32602,
    "message": "invalid argument 0: invalid parameter for net_peerCount"
  }
}

{
  "code": 400,
  "message": "Bad Request"
}

Unknown API_key

Method Not Allowed

Missing API_key

{
  "code": 500,
  "message": "Internal Server Error"
}

net_version

net_version operations.

net_version

POST

https://xrp.nownodes.io/

Returns the current network ID of the Ethereum client.

Body

application/json

Returns the current network ID of the Ethereum client.

JSON-RPC request payload.

jsonrpcstringrequired

JSON-RPC protocol version.

methodstringnet_versionrequired

JSON-RPC method name.

paramsarrayrequired

This method takes no parameters.

idintegerrequired

Client request identifier echoed by the server.

Response

200OK

HTTP 200 response for net_version. The body contains either a successful result or a method-level JSON-RPC error.

400Bad Request

Bad Request. The request body is malformed or contains invalid JSON-RPC parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or node failed while processing the request.

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

net_version

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

const response = await fetch('https://xrp.nownodes.io/', {
  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://xrp.nownodes.io/', json=payload)
data = response.json()

Request Body

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

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

{
  "jsonrpc": "2.0",
  "id": 1,
  "error": {
    "code": -32602,
    "message": "invalid argument 0: invalid parameter for net_version"
  }
}

{
  "code": 400,
  "message": "Bad Request"
}

Unknown API_key

Method Not Allowed

Missing API_key

{
  "code": 500,
  "message": "Internal Server Error"
}

web3_clientVersion

web3_clientVersion operations.

web3_clientVersion

POST

https://xrp.nownodes.io/

Returns the current Ethereum client version.

Body

application/json

Returns the current Ethereum client version.

JSON-RPC request payload.

jsonrpcstringrequired

JSON-RPC protocol version.

methodstringweb3_clientVersionrequired

JSON-RPC method name.

paramsarrayrequired

This method takes no parameters.

idintegerrequired

Client request identifier echoed by the server.

Response

200OK

HTTP 200 response for web3_clientVersion. The body contains either a successful result or a method-level JSON-RPC error.

400Bad Request

Bad Request. The request body is malformed or contains invalid JSON-RPC parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or node failed while processing the request.

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

web3_clientVersion

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

const response = await fetch('https://xrp.nownodes.io/', {
  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://xrp.nownodes.io/', json=payload)
data = response.json()

Request Body

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

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "Geth/v1.13.15-stable/linux-amd64/go1.22"
}

{
  "jsonrpc": "2.0",
  "id": 1,
  "error": {
    "code": -32602,
    "message": "invalid argument 0: invalid parameter for web3_clientVersion"
  }
}

{
  "code": 400,
  "message": "Bad Request"
}

Unknown API_key

Method Not Allowed

Missing API_key

{
  "code": 500,
  "message": "Internal Server Error"
}

web3_sha3

web3_sha3 operations.

web3_sha3

POST

https://xrp.nownodes.io/

Computes the Keccak-256 (SHA-3) hash of the given hex-encoded data.

Body

application/json

Computes the Keccak-256 (SHA-3) hash of the given hex-encoded data.

JSON-RPC request payload.

jsonrpcstringrequired

JSON-RPC protocol version.

methodstringweb3_sha3required

JSON-RPC method name.

paramsArray<string>required

Array containing a single hex-encoded data string to hash.

idintegerrequired

Client request identifier echoed by the server.

Response

200OK

HTTP 200 response for web3_sha3. The body contains either a successful result or a method-level JSON-RPC error.

400Bad Request

Bad Request. The request body is malformed or contains invalid JSON-RPC parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or node failed while processing the request.

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

web3_sha3

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

const response = await fetch('https://xrp.nownodes.io/', {
  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://xrp.nownodes.io/', json=payload)
data = response.json()

Request Body

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

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

{
  "jsonrpc": "2.0",
  "id": 1,
  "error": {
    "code": -32602,
    "message": "invalid argument 0: invalid parameter for web3_sha3"
  }
}

{
  "code": 400,
  "message": "Bad Request"
}

Unknown API_key

Method Not Allowed

Missing API_key

{
  "code": 500,
  "message": "Internal Server Error"
}

Node

General

General operations.

Generic JSON-RPC endpoint

POST

https://xrp.nownodes.io/

All XRP Ledger API methods are called through this endpoint using JSON-RPC

Body

application/json

All XRP Ledger API methods are called through this endpoint using JSON-RPC

JSON-RPC request payload.

One of

methodstringaccount_inforequired

Method name

paramsArray<object>required

JSON-RPC method parameters.

Show child attributes

accountstring

A unique identifier for the account, most commonly the account's address

strictboolean

If true, only accept a public key or XRP Ledger address

ledger_hashstring

A 20-byte hex string for the ledger version to use

ledger_indexstringvalidatedclosedcurrent

The ledger index of the ledger to use, or a shortcut string

queueboolean

If true, and the request is for the current ledger, also returns queue status

signer_listsboolean

If true, and the request is for the current ledger, also returns any signer lists

methodstringaccount_linesrequired

Method name

paramsArray<object>required

JSON-RPC method parameters.

Show child attributes

accountstring

A unique identifier for the account, most commonly the account's address

ledger_hashstring

A 20-byte hex string for the ledger version to use

ledger_indexstringvalidatedclosedcurrent

The ledger index of the ledger to use, or a shortcut string

peerstring

The account of the counterparty to limit results to

limitinteger

Limit the number of trust lines to retrieve

markerstring

Value from a previous paginated response. Resume retrieving data where that response left off

methodstringaccount_objectsrequired

Method name

paramsArray<object>required

JSON-RPC method parameters.

Show child attributes

accountstring

A unique identifier for the account, most commonly the account's address

ledger_hashstring

A 20-byte hex string for the ledger version to use

ledger_indexstringvalidatedclosedcurrent

The ledger index of the ledger to use, or a shortcut string

typestringcheckdeposit_preauthescrowofferpayment_channelsigner_liststate

Filter results to a single type of ledger object

deletion_blockers_onlyboolean

If true, limit results to objects that can block account deletion

limitinteger

Limit the number of objects to retrieve

markerstring

Value from a previous paginated response. Resume retrieving data where that response left off

methodstringaccount_offersrequired

Method name

paramsArray<object>required

JSON-RPC method parameters.

Show child attributes

accountstring

A unique identifier for the account, most commonly the account's address

ledger_hashstring

A 20-byte hex string for the ledger version to use

ledger_indexstringvalidatedclosedcurrent

The ledger index of the ledger to use, or a shortcut string

limitinteger

Limit the number of offers to retrieve

markerstring

Value from a previous paginated response. Resume retrieving data where that response left off

methodstringaccount_txrequired

Method name

paramsArray<object>required

JSON-RPC method parameters.

Show child attributes

accountstring

A unique identifier for the account, most commonly the account's address

ledger_index_mininteger

Use -1 to start at the earliest validated ledger available

ledger_index_maxinteger

Use -1 to start at the most recent validated ledger available

ledger_hashstring

A 20-byte hex string for the ledger version to use

ledger_indexstringvalidatedclosedcurrent

The ledger index of the ledger to use, or a shortcut string

binaryboolean

If true, return transactions as hex strings instead of JSON

forwardboolean

If true, return results in ascending ledger order

limitinteger

Limit the number of transactions to retrieve

markerobject

Value from a previous paginated response. Resume retrieving data where that response left off

methodstringgateway_balancesrequired

Method name

paramsArray<object>required

JSON-RPC method parameters.

Show child attributes

accountstring

The account to get gateway balances for

ledger_hashstring

A 20-byte hex string for the ledger version to use

ledger_indexstringvalidatedclosedcurrent

The ledger index of the ledger to use, or a shortcut string

hotwalletArray<string>

Array of hot wallet addresses to exclude from the balances

strictboolean

If true, only accept a public key or XRP Ledger address

methodstringledgerrequired

Method name

paramsArray<object>required

JSON-RPC method parameters.

Show child attributes

ledger_hashstring

A 20-byte hex string for the ledger version to use

ledger_indexstringvalidatedclosedcurrent

The ledger index of the ledger to use, or a shortcut string

fullboolean

If true, return full information on the entire ledger

accountsboolean

If true, return information on accounts in the ledger

transactionsboolean

If true, return information on transactions in the ledger

expandboolean

If true, return full transaction, metadata, etc.

owner_fundsboolean

If true, include owner_funds field in offer objects

binaryboolean

If true, return ledger data as hex strings instead of JSON

queueboolean

If true, include information on the transaction queue

methodstringledger_datarequired

Method name

paramsArray<object>required

JSON-RPC method parameters.

Show child attributes

ledger_hashstring

A 20-byte hex string for the ledger version to use

ledger_indexstringvalidatedclosedcurrent

The ledger index of the ledger to use, or a shortcut string

binaryboolean

If true, return ledger objects as hex strings instead of JSON

limitinteger

Limit the number of ledger objects to retrieve

markerstring

Value from a previous paginated response. Resume retrieving data where that response left off

methodstringsubmitrequired

Method name

paramsArray<object>required

JSON-RPC method parameters.

Show child attributes

tx_blobstring

Hex representation of the signed transaction to submit

fail_hardboolean

If true, and the transaction fails locally, do not retry or relay the transaction

methodstringtransaction_entryrequired

Method name

paramsArray<object>required

JSON-RPC method parameters.

Show child attributes

tx_hashstring

Hash of the transaction to look up

ledger_hashstring

A 20-byte hex string for the ledger version to use

ledger_indexinteger

The ledger index of the ledger to use

methodstringtxrequired

Method name

paramsArray<object>required

JSON-RPC method parameters.

Show child attributes

transactionstring

Hash of the transaction to look up

binaryboolean

If true, return transaction data as hex strings instead of JSON

methodstringserver_inforequired

Method name

paramsArray<object>required

JSON-RPC method parameters.

methodstringserver_staterequired

Method name

paramsArray<object>required

JSON-RPC method parameters.

methodstringfeerequired

Method name

paramsArray<object>required

JSON-RPC method parameters.

methodstringmanifestrequired

Method name

paramsArray<object>required

JSON-RPC method parameters.

Show child attributes

public_keystring

Base58-encoded public key of the validator

methodstringrandomrequired

Method name

paramsArray<object>required

JSON-RPC method parameters.

methodstringpingrequired

Method name

paramsArray<object>required

JSON-RPC method parameters.

Response

200OK

HTTP 200 response for jsonRpcCall. The body contains either a successful result or a method-level JSON-RPC error.

400Bad Request

Bad Request. The request body is malformed or contains invalid JSON-RPC parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or node failed while processing the request.

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

Generic JSON-RPC endpoint

curl -X POST 'https://xrp.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "method": "account_info",
    "params": [
      {
        "account": "rG1QQv2nh2gr7RCZ1P8YYcBUKCCN633jCn",
        "strict": true,
        "ledger_hash": "ABC123",
        "ledger_index": "current",
        "queue": true,
        "signer_lists": false
      }
    ]
  }'

const response = await fetch('https://xrp.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "method": "account_info",
      "params": [
        {
          "account": "rG1QQv2nh2gr7RCZ1P8YYcBUKCCN633jCn",
          "strict": true,
          "ledger_hash": "ABC123",
          "ledger_index": "current",
          "queue": true,
          "signer_lists": false
        }
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "method": "account_info",
  "params": [
    {
      "account": "rG1QQv2nh2gr7RCZ1P8YYcBUKCCN633jCn",
      "strict": True,
      "ledger_hash": "ABC123",
      "ledger_index": "current",
      "queue": True,
      "signer_lists": False
    }
  ]
}

response = requests.post('https://xrp.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "method": "account_info",
  "params": [
    {
      "account": "rG1QQv2nh2gr7RCZ1P8YYcBUKCCN633jCn",
      "strict": true,
      "ledger_index": "current",
      "queue": true
    }
  ]
}

{
  "method": "ledger",
  "params": [
    {
      "ledger_index": "validated",
      "accounts": false,
      "full": false,
      "transactions": false,
      "expand": false,
      "owner_funds": false
    }
  ]
}

{
  "result": {
    "ledger_index": 105281656,
    "status": "success",
    "validated": true
  }
}

{
  "result": {
    "error": "invalidParams",
    "error_code": 31,
    "error_message": "Invalid parameters.",
    "request": {
      "method": "jsonRpcCall",
      "params": [
        {}
      ]
    },
    "status": "error"
  }
}

{
  "code": 400,
  "message": "Bad Request"
}

Unknown API_key

Method Not Allowed

Missing API_key

{
  "code": 500,
  "message": "Internal Server Error"
}

Path and Order

amm_info

amm_info operations.

amm_info

POST

https://xrp.nownodes.io/

Retrieve information about an Automated Market Maker (AMM) instance for a given pair of assets. This method returns the current state of the AMM including liquidity, fees, auction details, and voting information.

Body

application/json

JSON-RPC request payload.

methodstringamm_inforequired

The JSON-RPC method name

paramsArray<object>required

Ordered JSON-RPC method parameters.

Show child attributes

assetobjectrequired

First asset in the trading pair

Show child attributes

currencystring

Currency code - "XRP" for native XRP, or 3-character code for issued currencies. For XRP, no issuer field is required.

issuerstring

Issuer account address - only required for issued currencies, not for XRP.

asset2objectrequired

Second asset in the trading pair

Show child attributes

currencystring

Currency code for the second asset

issuerstring

Issuer account address for the second asset

Response

200OK

HTTP 200 response for amm_info. The body contains either a successful result or a method-level JSON-RPC error.

400Bad Request

Bad Request. The request body is malformed or contains invalid JSON-RPC parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or node failed while processing the request.

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

amm_info

curl -X POST 'https://xrp.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "method": "amm_info",
    "params": [
      {
        "asset": {
          "currency": "XRP"
        },
        "asset2": {
          "currency": "TST",
          "issuer": "rP9jPyP5kyvFRb6ZiRghAGw5u8SGAmU4bd"
        }
      }
    ]
  }'

const response = await fetch('https://xrp.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "method": "amm_info",
      "params": [
        {
          "asset": {
            "currency": "XRP"
          },
          "asset2": {
            "currency": "TST",
            "issuer": "rP9jPyP5kyvFRb6ZiRghAGw5u8SGAmU4bd"
          }
        }
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "method": "amm_info",
  "params": [
    {
      "asset": {
        "currency": "XRP"
      },
      "asset2": {
        "currency": "TST",
        "issuer": "rP9jPyP5kyvFRb6ZiRghAGw5u8SGAmU4bd"
      }
    }
  ]
}

response = requests.post('https://xrp.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "method": "amm_info",
  "params": [
    {
      "asset": {
        "currency": "XRP"
      },
      "asset2": {
        "currency": "TST",
        "issuer": "rP9jPyP5kyvFRb6ZiRghAGw5u8SGAmU4bd"
      }
    }
  ]
}

{
  "result": {
    "ledger_index": 105281656,
    "status": "success",
    "validated": true
  }
}

{
  "result": {
    "error": "invalidParams",
    "error_code": 31,
    "error_message": "Invalid parameters.",
    "request": {
      "method": "amm_info",
      "params": [
        {}
      ]
    },
    "status": "error"
  }
}

{
  "code": 400,
  "message": "Bad Request"
}

Unknown API_key

Method Not Allowed

Missing API_key

{
  "code": 500,
  "message": "Internal Server Error"
}

book_changes

book_changes operations.

book_changes

POST

https://xrp.nownodes.io/

Retrieve order book changes for a specific ledger. This method returns changes in trading pairs including price movements and volume data.

Body

application/json

Retrieve order book changes for a specific ledger. This method returns changes in trading pairs including price movements and volume data.

JSON-RPC request payload.

methodstringbook_changesrequired

The JSON-RPC method name

paramsArray<object>required

Ordered JSON-RPC method parameters.

Show child attributes

ledger_indexintegerrequired

The ledger index for which to retrieve book changes. Must be a validated ledger index.

Response

200OK

HTTP 200 response for book_changes. The body contains either a successful result or a method-level JSON-RPC error.

400Bad Request

Bad Request. The request body is malformed or contains invalid JSON-RPC parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or node failed while processing the request.

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

book_changes

curl -X POST 'https://xrp.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "method": "book_changes",
    "params": [
      {
        "ledger_index": 88530953
      }
    ]
  }'

const response = await fetch('https://xrp.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "method": "book_changes",
      "params": [
        {
          "ledger_index": 88530953
        }
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "method": "book_changes",
  "params": [
    {
      "ledger_index": 88530953
    }
  ]
}

response = requests.post('https://xrp.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "method": "book_changes",
  "params": [
    {
      "ledger_index": 88530953
    }
  ]
}

{
  "result": {
    "ledger_index": 105281656,
    "status": "success",
    "validated": true
  }
}

{
  "result": {
    "error": "invalidParams",
    "error_code": 31,
    "error_message": "Invalid parameters.",
    "request": {
      "method": "book_changes",
      "params": [
        {}
      ]
    },
    "status": "error"
  }
}

{
  "code": 400,
  "message": "Bad Request"
}

Unknown API_key

Method Not Allowed

Missing API_key

{
  "code": 500,
  "message": "Internal Server Error"
}

book_offers

book_offers operations.

book_offers

POST

https://xrp.nownodes.io/

Retrieve the order book for a specific currency pair. This method returns current offers (orders) in the decentralized exchange.

Body

application/json

Retrieve the order book for a specific currency pair. This method returns current offers (orders) in the decentralized exchange.

JSON-RPC request payload.

methodstringbook_offersrequired

The JSON-RPC method name

paramsArray<object>required

Ordered JSON-RPC method parameters.

Show child attributes

takerstring

The address of the account that would take the offers. This affects which offers are returned based on the account's trust lines.

taker_getsobjectrequired

The currency the taker would receive in the exchange.

Show child attributes

currencystring

Currency code - "XRP" for native XRP, or 3-character code for issued currencies.

issuerstring

Issuer account address - only required for issued currencies, not for XRP.

taker_paysobjectrequired

The currency the taker would pay in the exchange.

Show child attributes

currencystring

Currency code for the payment currency

issuerstring

Issuer account address for the payment currency

limitinteger

Maximum number of offers to return. Higher limits may take longer to process.

Response

200OK

HTTP 200 response for book_offers. The body contains either a successful result or a method-level JSON-RPC error.

400Bad Request

Bad Request. The request body is malformed or contains invalid JSON-RPC parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or node failed while processing the request.

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

book_offers

curl -X POST 'https://xrp.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "method": "book_offers",
    "params": [
      {
        "taker": "r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59",
        "taker_gets": {
          "currency": "XRP"
        },
        "taker_pays": {
          "currency": "USD",
          "issuer": "rvYAfWj5gh67oV6fW32ZzP3Aw4Eubs59B"
        },
        "limit": 10
      }
    ]
  }'

const response = await fetch('https://xrp.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "method": "book_offers",
      "params": [
        {
          "taker": "r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59",
          "taker_gets": {
            "currency": "XRP"
          },
          "taker_pays": {
            "currency": "USD",
            "issuer": "rvYAfWj5gh67oV6fW32ZzP3Aw4Eubs59B"
          },
          "limit": 10
        }
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "method": "book_offers",
  "params": [
    {
      "taker": "r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59",
      "taker_gets": {
        "currency": "XRP"
      },
      "taker_pays": {
        "currency": "USD",
        "issuer": "rvYAfWj5gh67oV6fW32ZzP3Aw4Eubs59B"
      },
      "limit": 10
    }
  ]
}

response = requests.post('https://xrp.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "method": "book_offers",
  "params": [
    {
      "taker": "r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59",
      "taker_gets": {
        "currency": "XRP"
      },
      "taker_pays": {
        "currency": "USD",
        "issuer": "rvYAfWj5gh67oV6fW32ZzP3Aw4Eubs59B"
      },
      "limit": 10
    }
  ]
}

{
  "result": {
    "ledger_current_index": 105281656,
    "offers": [
      {
        "Account": "rJ8hb4jMHgRNhEQ7BTGz6vt14kWn2z6H78",
        "BookDirectory": "4627DFFC...",
        "BookNode": "0",
        "Flags": 0,
        "OwnerNode": "0",
        "Sequence": 92896974,
        "TakerGets": "1000000",
        "TakerPays": {
          "currency": "USD",
          "issuer": "rJ8hb4jMHgRNhEQ7BTGz6vt14kWn2z6H78",
          "value": "1.00"
        }
      }
    ],
    "status": "success",
    "validated": false
  }
}

{
  "result": {
    "error": "invalidParams",
    "error_code": 31,
    "error_message": "Invalid parameters.",
    "request": {
      "method": "book_offers",
      "params": [
        {}
      ]
    },
    "status": "error"
  }
}

{
  "code": 400,
  "message": "Bad Request"
}

Unknown API_key

Method Not Allowed

Missing API_key

{
  "code": 500,
  "message": "Internal Server Error"
}

deposit_authorized

deposit_authorized operations.

deposit_authorized

POST

https://xrp.nownodes.io/

Check if an account is authorized to send payments directly to another account. This method verifies deposit authorization status between two accounts.

Body

application/json

Check if an account is authorized to send payments directly to another account. This method verifies deposit authorization status between two accounts.

JSON-RPC request payload.

methodstringdeposit_authorizedrequired

The JSON-RPC method name

paramsArray<object>required

Ordered JSON-RPC method parameters.

Show child attributes

source_accountstringrequired

The source account address that wants to send a payment.

destination_accountstringrequired

The destination account address that would receive the payment.

credentialsArray<string>

Array of transaction hashes to use as credentials for the request. Used for verifying specific transaction contexts.

ledger_indexstringvalidatedcurrentclosed

The ledger index to use for the request. "validated" uses the most recent validated ledger.

Response

200OK

HTTP 200 response for deposit_authorized. The body contains either a successful result or a method-level JSON-RPC error.

400Bad Request

Bad Request. The request body is malformed or contains invalid JSON-RPC parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or node failed while processing the request.

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

deposit_authorized

curl -X POST 'https://xrp.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "method": "deposit_authorized",
    "params": [
      {
        "source_account": "rEhxGqkqPPSxQ3P25J66ft5TwpzV14k2de",
        "destination_account": "rsUiUMpnrgxQp24dJYZDhmV4bE3aBtQyt8",
        "credentials": [
          "A182EFBD154C9E80195082F86C1C8952FC0760A654B886F61BB0A59803B4387B",
          "383D269D6C7417D0A8716B09F5DB329FB17B45A5EFDBAFB82FF04BC420DCF7D5"
        ],
        "ledger_index": "validated"
      }
    ]
  }'

const response = await fetch('https://xrp.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "method": "deposit_authorized",
      "params": [
        {
          "source_account": "rEhxGqkqPPSxQ3P25J66ft5TwpzV14k2de",
          "destination_account": "rsUiUMpnrgxQp24dJYZDhmV4bE3aBtQyt8",
          "credentials": [
            "A182EFBD154C9E80195082F86C1C8952FC0760A654B886F61BB0A59803B4387B",
            "383D269D6C7417D0A8716B09F5DB329FB17B45A5EFDBAFB82FF04BC420DCF7D5"
          ],
          "ledger_index": "validated"
        }
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "method": "deposit_authorized",
  "params": [
    {
      "source_account": "rEhxGqkqPPSxQ3P25J66ft5TwpzV14k2de",
      "destination_account": "rsUiUMpnrgxQp24dJYZDhmV4bE3aBtQyt8",
      "credentials": [
        "A182EFBD154C9E80195082F86C1C8952FC0760A654B886F61BB0A59803B4387B",
        "383D269D6C7417D0A8716B09F5DB329FB17B45A5EFDBAFB82FF04BC420DCF7D5"
      ],
      "ledger_index": "validated"
    }
  ]
}

response = requests.post('https://xrp.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "method": "deposit_authorized",
  "params": [
    {
      "source_account": "rEhxGqkqPPSxQ3P25J66ft5TwpzV14k2de",
      "destination_account": "rsUiUMpnrgxQp24dJYZDhmV4bE3aBtQyt8",
      "credentials": [
        "A182EFBD154C9E80195082F86C1C8952FC0760A654B886F61BB0A59803B4387B",
        "383D269D6C7417D0A8716B09F5DB329FB17B45A5EFDBAFB82FF04BC420DCF7D5"
      ],
      "ledger_index": "validated"
    }
  ]
}

{
  "result": {
    "ledger_index": 105281656,
    "status": "success",
    "validated": true
  }
}

{
  "result": {
    "error": "invalidParams",
    "error_code": 31,
    "error_message": "Invalid parameters.",
    "request": {
      "method": "deposit_authorized",
      "params": [
        {}
      ]
    },
    "status": "error"
  }
}

{
  "code": 400,
  "message": "Bad Request"
}

Unknown API_key

Method Not Allowed

Missing API_key

{
  "code": 500,
  "message": "Internal Server Error"
}

get_aggregate_price

get_aggregate_price operations.

get_aggregate_price

POST

https://xrp.nownodes.io/

Retrieve aggregated price data from multiple oracles for a specific asset pair. This method calculates statistical measures (mean, median, standard deviation) from price data provided by specified oracles.

Body

application/json

JSON-RPC request payload.

methodstringget_aggregate_pricerequired

The JSON-RPC method name

paramsArray<object>required

Ordered JSON-RPC method parameters.

Show child attributes

ledger_indexstringcurrentvalidatedclosed

The ledger index to use for the request. "current" uses the current in-progress ledger.

base_assetstringrequired

The base asset currency code (e.g., "XRP").

quote_assetstringrequired

The quote asset currency code (e.g., "USD").

triminteger[0, 100]

Percentage of outliers to trim from the data set before calculation. For example, 20 means trim 20% (10% from each end).

oraclesArray<object>required

Array of oracle specifications to include in the aggregation.

Show child attributes

accountstringrequired

The account address of the oracle.

oracle_document_idintegerrequired

The document ID of the oracle price data to use.

Response

200OK

HTTP 200 response for get_aggregate_price. The body contains either a successful result or a method-level JSON-RPC error.

400Bad Request

Bad Request. The request body is malformed or contains invalid JSON-RPC parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or node failed while processing the request.

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

get_aggregate_price

curl -X POST 'https://xrp.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "method": "get_aggregate_price",
    "params": [
      {
        "ledger_index": "current",
        "base_asset": "XRP",
        "quote_asset": "USD",
        "trim": 20,
        "oracles": [
          {
            "account": "rNZ9m6AP9K7z3EVg6GhPMx36V4QmZKeWds",
            "oracle_document_id": 34
          },
          {
            "account": "rMVKq8zrVsJZQFEiTARyC6WfZznhhLMcNi",
            "oracle_document_id": 100
          },
          {
            "account": "r92kJTnUbUUq15t2BBZYGYxY79RnNc7rLQ",
            "oracle_document_id": 2
          }
        ]
      }
    ]
  }'

const response = await fetch('https://xrp.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "method": "get_aggregate_price",
      "params": [
        {
          "ledger_index": "current",
          "base_asset": "XRP",
          "quote_asset": "USD",
          "trim": 20,
          "oracles": [
            {
              "account": "rNZ9m6AP9K7z3EVg6GhPMx36V4QmZKeWds",
              "oracle_document_id": 34
            },
            {
              "account": "rMVKq8zrVsJZQFEiTARyC6WfZznhhLMcNi",
              "oracle_document_id": 100
            },
            {
              "account": "r92kJTnUbUUq15t2BBZYGYxY79RnNc7rLQ",
              "oracle_document_id": 2
            }
          ]
        }
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "method": "get_aggregate_price",
  "params": [
    {
      "ledger_index": "current",
      "base_asset": "XRP",
      "quote_asset": "USD",
      "trim": 20,
      "oracles": [
        {
          "account": "rNZ9m6AP9K7z3EVg6GhPMx36V4QmZKeWds",
          "oracle_document_id": 34
        },
        {
          "account": "rMVKq8zrVsJZQFEiTARyC6WfZznhhLMcNi",
          "oracle_document_id": 100
        },
        {
          "account": "r92kJTnUbUUq15t2BBZYGYxY79RnNc7rLQ",
          "oracle_document_id": 2
        }
      ]
    }
  ]
}

response = requests.post('https://xrp.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "method": "get_aggregate_price",
  "params": [
    {
      "ledger_index": "current",
      "base_asset": "XRP",
      "quote_asset": "USD",
      "trim": 20,
      "oracles": [
        {
          "account": "rNZ9m6AP9K7z3EVg6GhPMx36V4QmZKeWds",
          "oracle_document_id": 34
        },
        {
          "account": "rMVKq8zrVsJZQFEiTARyC6WfZznhhLMcNi",
          "oracle_document_id": 100
        },
        {
          "account": "r92kJTnUbUUq15t2BBZYGYxY79RnNc7rLQ",
          "oracle_document_id": 2
        }
      ]
    }
  ]
}

{
  "result": {
    "ledger_index": 105281656,
    "status": "success",
    "validated": true
  }
}

{
  "result": {
    "error": "invalidParams",
    "error_code": 31,
    "error_message": "Invalid parameters.",
    "request": {
      "method": "get_aggregate_price",
      "params": [
        {}
      ]
    },
    "status": "error"
  }
}

{
  "code": 400,
  "message": "Bad Request"
}

Unknown API_key

Method Not Allowed

Missing API_key

{
  "code": 500,
  "message": "Internal Server Error"
}

nft_buy_offers

nft_buy_offers operations.

nft_buy_offers

POST

https://xrp.nownodes.io/

Retrieve buy offers for a specific NFT (Non-Fungible Token). This method returns all current buy offers for the specified NFT.

Body

application/json

Retrieve buy offers for a specific NFT (Non-Fungible Token). This method returns all current buy offers for the specified NFT.

JSON-RPC request payload.

methodstringnft_buy_offersrequired

The JSON-RPC method name

paramsArray<object>required

Ordered JSON-RPC method parameters.

Show child attributes

nft_idstringrequired

The unique identifier of the NFT. This is the NFTokenID in hexadecimal format.

ledger_indexstringvalidatedcurrentclosed

The ledger index to use for the request. "validated" uses the most recent validated ledger.

Response

200OK

HTTP 200 response for nft_buy_offers. The body contains either a successful result or a method-level JSON-RPC error.

400Bad Request

Bad Request. The request body is malformed or contains invalid JSON-RPC parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or node failed while processing the request.

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

nft_buy_offers

curl -X POST 'https://xrp.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "method": "nft_buy_offers",
    "params": [
      {
        "nft_id": "00090000D0B007439B080E9B05BF62403911301A7B1F0CFAA048C0A200000007",
        "ledger_index": "validated"
      }
    ]
  }'

const response = await fetch('https://xrp.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "method": "nft_buy_offers",
      "params": [
        {
          "nft_id": "00090000D0B007439B080E9B05BF62403911301A7B1F0CFAA048C0A200000007",
          "ledger_index": "validated"
        }
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "method": "nft_buy_offers",
  "params": [
    {
      "nft_id": "00090000D0B007439B080E9B05BF62403911301A7B1F0CFAA048C0A200000007",
      "ledger_index": "validated"
    }
  ]
}

response = requests.post('https://xrp.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "method": "nft_buy_offers",
  "params": [
    {
      "nft_id": "00090000D0B007439B080E9B05BF62403911301A7B1F0CFAA048C0A200000007",
      "ledger_index": "validated"
    }
  ]
}

{
  "result": {
    "ledger_index": 105281656,
    "status": "success",
    "validated": true
  }
}

{
  "result": {
    "error": "invalidParams",
    "error_code": 31,
    "error_message": "Invalid parameters.",
    "request": {
      "method": "nft_buy_offers",
      "params": [
        {}
      ]
    },
    "status": "error"
  }
}

{
  "code": 400,
  "message": "Bad Request"
}

Unknown API_key

Method Not Allowed

Missing API_key

{
  "code": 500,
  "message": "Internal Server Error"
}

nft_sell_offers

nft_sell_offers operations.

nft_sell_offers

POST

https://xrp.nownodes.io/

Retrieve sell offers for a specific NFT (Non-Fungible Token). This method returns all current sell offers for the specified NFT.

Body

application/json

Retrieve sell offers for a specific NFT (Non-Fungible Token). This method returns all current sell offers for the specified NFT.

JSON-RPC request payload.

methodstringnft_sell_offersrequired

The JSON-RPC method name

paramsArray<object>required

Ordered JSON-RPC method parameters.

Show child attributes

nft_idstringrequired

The unique identifier of the NFT. This is the NFTokenID in hexadecimal format.

ledger_indexstringvalidatedcurrentclosed

The ledger index to use for the request. If omitted, uses the default ledger index.

Response

200OK

HTTP 200 response for nft_sell_offers. The body contains either a successful result or a method-level JSON-RPC error.

400Bad Request

Bad Request. The request body is malformed or contains invalid JSON-RPC parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or node failed while processing the request.

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

nft_sell_offers

curl -X POST 'https://xrp.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "method": "nft_sell_offers",
    "params": [
      {
        "nft_id": "00090000D0B007439B080E9B05BF62403911301A7B1F0CFAA048C0A200000007"
      }
    ]
  }'

const response = await fetch('https://xrp.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "method": "nft_sell_offers",
      "params": [
        {
          "nft_id": "00090000D0B007439B080E9B05BF62403911301A7B1F0CFAA048C0A200000007"
        }
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "method": "nft_sell_offers",
  "params": [
    {
      "nft_id": "00090000D0B007439B080E9B05BF62403911301A7B1F0CFAA048C0A200000007"
    }
  ]
}

response = requests.post('https://xrp.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "method": "nft_sell_offers",
  "params": [
    {
      "nft_id": "00090000D0B007439B080E9B05BF62403911301A7B1F0CFAA048C0A200000007"
    }
  ]
}

{
  "result": {
    "ledger_index": 105281656,
    "status": "success",
    "validated": true
  }
}

{
  "result": {
    "error": "invalidParams",
    "error_code": 31,
    "error_message": "Invalid parameters.",
    "request": {
      "method": "nft_sell_offers",
      "params": [
        {}
      ]
    },
    "status": "error"
  }
}

{
  "code": 400,
  "message": "Bad Request"
}

Unknown API_key

Method Not Allowed

Missing API_key

{
  "code": 500,
  "message": "Internal Server Error"
}

ripple_path_find

ripple_path_find operations.

ripple_path_find

POST

https://xrp.nownodes.io/

Find payment paths between two accounts for a specific amount. This method calculates possible paths for cross-currency payments using the XRP Ledger's decentralized exchange.

Body

application/json

Find payment paths between two accounts for a specific amount. This method calculates possible paths for cross-currency payments using the XRP Ledger's decentralized exchange.

JSON-RPC request payload.

methodstringripple_path_findrequired

The JSON-RPC method name

paramsArray<object>required

Ordered JSON-RPC method parameters.

Show child attributes

source_accountstringrequired

The source account address that would send the payment.

destination_accountstringrequired

The destination account address that would receive the payment.

destination_amountobjectrequired

The amount and currency the destination should receive.

Show child attributes

currencystring

Currency code

issuerstring

Issuer account address for the currency

valuestring

Amount as a string to maintain precision

source_currenciesArray<object>

Currencies that the source account might use to send the payment.

Show child attributes

currencystring

Currency code

Response

200OK

HTTP 200 response for ripple_path_find. The body contains either a successful result or a method-level JSON-RPC error.

400Bad Request

Bad Request. The request body is malformed or contains invalid JSON-RPC parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or node failed while processing the request.

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

ripple_path_find

curl -X POST 'https://xrp.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "method": "ripple_path_find",
    "params": [
      {
        "source_account": "r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59",
        "destination_account": "r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59",
        "destination_amount": {
          "currency": "USD",
          "issuer": "rvYAfWj5gh67oV6fW32ZzP3Aw4Eubs59B",
          "value": "0.001"
        },
        "source_currencies": [
          {
            "currency": "XRP"
          },
          {
            "currency": "USD"
          }
        ]
      }
    ]
  }'

const response = await fetch('https://xrp.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "method": "ripple_path_find",
      "params": [
        {
          "source_account": "r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59",
          "destination_account": "r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59",
          "destination_amount": {
            "currency": "USD",
            "issuer": "rvYAfWj5gh67oV6fW32ZzP3Aw4Eubs59B",
            "value": "0.001"
          },
          "source_currencies": [
            {
              "currency": "XRP"
            },
            {
              "currency": "USD"
            }
          ]
        }
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "method": "ripple_path_find",
  "params": [
    {
      "source_account": "r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59",
      "destination_account": "r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59",
      "destination_amount": {
        "currency": "USD",
        "issuer": "rvYAfWj5gh67oV6fW32ZzP3Aw4Eubs59B",
        "value": "0.001"
      },
      "source_currencies": [
        {
          "currency": "XRP"
        },
        {
          "currency": "USD"
        }
      ]
    }
  ]
}

response = requests.post('https://xrp.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "method": "ripple_path_find",
  "params": [
    {
      "source_account": "r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59",
      "destination_account": "r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59",
      "destination_amount": {
        "currency": "USD",
        "issuer": "rvYAfWj5gh67oV6fW32ZzP3Aw4Eubs59B",
        "value": "0.001"
      },
      "source_currencies": [
        {
          "currency": "XRP"
        },
        {
          "currency": "USD"
        }
      ]
    }
  ]
}

{
  "result": {
    "ledger_index": 105281656,
    "status": "success",
    "validated": true
  }
}

{
  "result": {
    "error": "invalidParams",
    "error_code": 31,
    "error_message": "Invalid parameters.",
    "request": {
      "method": "ripple_path_find",
      "params": [
        {}
      ]
    },
    "status": "error"
  }
}

{
  "code": 400,
  "message": "Bad Request"
}

Unknown API_key

Method Not Allowed

Missing API_key

{
  "code": 500,
  "message": "Internal Server Error"
}

Payment Channel

channel_authorize

channel_authorize operations.

channel_authorize

POST

https://xrp.nownodes.io/

Generate a signature for a claim against a specific payment channel. This method creates a cryptographic signature that can be used to claim XRP from a payment channel.

Body

application/json

Generate a signature for a claim against a specific payment channel. This method creates a cryptographic signature that can be used to claim XRP from a payment channel.

JSON-RPC request payload.

methodstringchannel_authorizerequired

The JSON-RPC method name

paramsArray<object>required

Ordered JSON-RPC method parameters.

Show child attributes

channel_idstringrequired

The unique identifier of the payment channel. This is 64-character hexadecimal string.

seedstringrequired

The secret seed of the account that owns the payment channel. Used to generate the signature. Should be kept secure.

key_typestringsecp256k1ed25519

The cryptographic key type to use for signing. Defaults to "secp256k1" if not specified.

amountstringrequired

The amount of XRP to authorize for the claim, in drops. Represented as a string to maintain precision.

Response

200OK

HTTP 200 response for channel_authorize. The body contains either a successful result or a method-level JSON-RPC error.

400Bad Request

Bad Request. The request body is malformed or contains invalid JSON-RPC parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or node failed while processing the request.

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

channel_authorize

curl -X POST 'https://xrp.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "method": "channel_authorize",
    "params": [
      {
        "channel_id": "5DB01B7FFED6B67E6B0414DED11E051D2EE2B7619CE0EAA6286D67A3A4D5BDB3",
        "seed": "s████████████████████████████",
        "key_type": "secp256k1",
        "amount": "1000000"
      }
    ]
  }'

const response = await fetch('https://xrp.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "method": "channel_authorize",
      "params": [
        {
          "channel_id": "5DB01B7FFED6B67E6B0414DED11E051D2EE2B7619CE0EAA6286D67A3A4D5BDB3",
          "seed": "s████████████████████████████",
          "key_type": "secp256k1",
          "amount": "1000000"
        }
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "method": "channel_authorize",
  "params": [
    {
      "channel_id": "5DB01B7FFED6B67E6B0414DED11E051D2EE2B7619CE0EAA6286D67A3A4D5BDB3",
      "seed": "s████████████████████████████",
      "key_type": "secp256k1",
      "amount": "1000000"
    }
  ]
}

response = requests.post('https://xrp.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "method": "channel_authorize",
  "params": [
    {
      "channel_id": "5DB01B7FFED6B67E6B0414DED11E051D2EE2B7619CE0EAA6286D67A3A4D5BDB3",
      "seed": "s████████████████████████████",
      "key_type": "secp256k1",
      "amount": "1000000"
    }
  ]
}

{
  "result": {
    "ledger_index": 105281656,
    "status": "success",
    "validated": true
  }
}

{
  "result": {
    "error": "invalidParams",
    "error_code": 31,
    "error_message": "Invalid parameters.",
    "request": {
      "method": "channel_authorize",
      "params": [
        {}
      ]
    },
    "status": "error"
  }
}

{
  "code": 400,
  "message": "Bad Request"
}

Unknown API_key

Method Not Allowed

Missing API_key

{
  "code": 500,
  "message": "Internal Server Error"
}

channel_verify

channel_verify operations.

channel_verify

POST

https://xrp.nownodes.io/

Verify a signature for a claim against a specific payment channel. This method checks whether a cryptographic signature is valid for claiming XRP from a payment channel.

Body

application/json

Verify a signature for a claim against a specific payment channel. This method checks whether a cryptographic signature is valid for claiming XRP from a payment channel.

JSON-RPC request payload.

methodstringchannel_verifyrequired

The JSON-RPC method name

paramsArray<object>required

Ordered JSON-RPC method parameters.

Show child attributes

channel_idstringrequired

The unique identifier of the payment channel. This is 64-character hexadecimal string.

signaturestringrequired

The cryptographic signature to verify, in hexadecimal format. This is the signature generated by the channel_authorize method.

public_keystringrequired

The public key of the account that owns the payment channel, in base58 format. This should correspond to the private key that generated the signature.

amountstringrequired

The amount of XRP that the signature authorizes to claim, in drops. Represented as a string to maintain precision. Must match the amount used when generating the signature.

Response

200OK

HTTP 200 response for channel_verify. The body contains either a successful result or a method-level JSON-RPC error.

400Bad Request

Bad Request. The request body is malformed or contains invalid JSON-RPC parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or node failed while processing the request.

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

channel_verify

curl -X POST 'https://xrp.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "method": "channel_verify",
    "params": [
      {
        "channel_id": "5DB01B7FFED6B67E6B0414DED11E051D2EE2B7619CE0EAA6286D67A3A4D5BDB3",
        "signature": "304402204EF0AFB78AC23ED1C472E74F4299C0C21F1B21D07EFC0A3838A420F76D783A400220154FB11B6F54320666E4C36CA7F686C16A3A0456800BBC43746F34AF50290064",
        "public_key": "aB44YfzW24VDEJQ2UuLPV2PvqcPCSoLnL7y5M1EzhdW4LnK5xMS3",
        "amount": "1000000"
      }
    ]
  }'

const response = await fetch('https://xrp.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "method": "channel_verify",
      "params": [
        {
          "channel_id": "5DB01B7FFED6B67E6B0414DED11E051D2EE2B7619CE0EAA6286D67A3A4D5BDB3",
          "signature": "304402204EF0AFB78AC23ED1C472E74F4299C0C21F1B21D07EFC0A3838A420F76D783A400220154FB11B6F54320666E4C36CA7F686C16A3A0456800BBC43746F34AF50290064",
          "public_key": "aB44YfzW24VDEJQ2UuLPV2PvqcPCSoLnL7y5M1EzhdW4LnK5xMS3",
          "amount": "1000000"
        }
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "method": "channel_verify",
  "params": [
    {
      "channel_id": "5DB01B7FFED6B67E6B0414DED11E051D2EE2B7619CE0EAA6286D67A3A4D5BDB3",
      "signature": "304402204EF0AFB78AC23ED1C472E74F4299C0C21F1B21D07EFC0A3838A420F76D783A400220154FB11B6F54320666E4C36CA7F686C16A3A0456800BBC43746F34AF50290064",
      "public_key": "aB44YfzW24VDEJQ2UuLPV2PvqcPCSoLnL7y5M1EzhdW4LnK5xMS3",
      "amount": "1000000"
    }
  ]
}

response = requests.post('https://xrp.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "method": "channel_verify",
  "params": [
    {
      "channel_id": "5DB01B7FFED6B67E6B0414DED11E051D2EE2B7619CE0EAA6286D67A3A4D5BDB3",
      "signature": "304402204EF0AFB78AC23ED1C472E74F4299C0C21F1B21D07EFC0A3838A420F76D783A400220154FB11B6F54320666E4C36CA7F686C16A3A0456800BBC43746F34AF50290064",
      "public_key": "aB44YfzW24VDEJQ2UuLPV2PvqcPCSoLnL7y5M1EzhdW4LnK5xMS3",
      "amount": "1000000"
    }
  ]
}

{
  "result": {
    "ledger_index": 105281656,
    "status": "success",
    "validated": true
  }
}

{
  "result": {
    "error": "invalidParams",
    "error_code": 31,
    "error_message": "Invalid parameters.",
    "request": {
      "method": "channel_verify",
      "params": [
        {}
      ]
    },
    "status": "error"
  }
}

{
  "code": 400,
  "message": "Bad Request"
}

Unknown API_key

Method Not Allowed

Missing API_key

{
  "code": 500,
  "message": "Internal Server Error"
}

Server Info

fee

fee operations.

fee

POST

https://xrp.nownodes.io/

Retrieve current transaction cost information for the XRP Ledger. This method returns information about current and expected transaction fees, ledger sizes, and queue statistics to help determine appropriate fee levels.

Body

application/json

JSON-RPC request payload.

methodstringfeerequired

The JSON-RPC method name

paramsArray<object>required

Ordered JSON-RPC method parameters.

Response

200OK

HTTP 200 response for fee. The body contains either a successful result or a method-level JSON-RPC error.

400Bad Request

Bad Request. The request body is malformed or contains invalid JSON-RPC parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or node failed while processing the request.

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

fee

curl -X POST 'https://xrp.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "method": "fee",
    "params": [
      {}
    ]
  }'

const response = await fetch('https://xrp.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "method": "fee",
      "params": [
        {}
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "method": "fee",
  "params": [
    {}
  ]
}

response = requests.post('https://xrp.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "method": "fee",
  "params": [
    {}
  ]
}

{
  "result": {
    "current_ledger_size": "47",
    "current_queue_size": "0",
    "drops": {
      "base_fee": "10",
      "median_fee": "5000",
      "minimum_fee": "10",
      "open_ledger_fee": "10"
    },
    "expected_ledger_size": "52",
    "ledger_current_index": 105281656,
    "levels": {
      "median_level": "128000",
      "minimum_level": "256",
      "open_ledger_level": "256"
    },
    "status": "success"
  }
}

{
  "result": {
    "error": "invalidParams",
    "error_code": 31,
    "error_message": "Invalid parameters.",
    "request": {
      "method": "fee",
      "params": [
        {}
      ]
    },
    "status": "error"
  }
}

{
  "code": 400,
  "message": "Bad Request"
}

Unknown API_key

Method Not Allowed

Missing API_key

{
  "code": 500,
  "message": "Internal Server Error"
}

server_state

server_state operations.

server_state

POST

https://xrp.nownodes.io/

Retrieve the current state of the server including network connectivity, ledger information, and performance metrics. This method provides detailed information about the server's operational status.

Body

application/json

Retrieve the current state of the server including network connectivity, ledger information, and performance metrics. This method provides detailed information about the server's operational status.

JSON-RPC request payload.

methodstringserver_staterequired

The JSON-RPC method name

paramsArray<object>required

Ordered JSON-RPC method parameters.

Show child attributes

ledger_indexstringcurrentvalidatedclosed

The ledger index to use for the request. "current" uses the current in-progress ledger.

Response

200OK

HTTP 200 response for server_state. The body contains either a successful result or a method-level JSON-RPC error.

400Bad Request

Bad Request. The request body is malformed or contains invalid JSON-RPC parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or node failed while processing the request.

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

server_state

curl -X POST 'https://xrp.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "method": "server_state",
    "params": [
      {
        "ledger_index": "current"
      }
    ]
  }'

const response = await fetch('https://xrp.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "method": "server_state",
      "params": [
        {
          "ledger_index": "current"
        }
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "method": "server_state",
  "params": [
    {
      "ledger_index": "current"
    }
  ]
}

response = requests.post('https://xrp.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "method": "server_state",
  "params": [
    {
      "ledger_index": "current"
    }
  ]
}

{
  "result": {
    "ledger_index": 105281656,
    "status": "success",
    "validated": true
  }
}

{
  "result": {
    "error": "invalidParams",
    "error_code": 31,
    "error_message": "Invalid parameters.",
    "request": {
      "method": "server_state",
      "params": [
        {}
      ]
    },
    "status": "error"
  }
}

{
  "code": 400,
  "message": "Bad Request"
}

Unknown API_key

Method Not Allowed

Missing API_key

{
  "code": 500,
  "message": "Internal Server Error"
}

Subscription

POST

https://xrp.nownodes.io/

Subscribe to real-time updates for various types of data in the XRP Ledger. This method establishes a subscription to receive streaming data such as transactions, ledger closes, order book changes, and more.

Body

application/json

JSON-RPC request payload.

idstring

Optional unique identifier for the subscription request.

commandstringsubscriberequired

The command name

booksArray<object>required

Array of order book specifications to subscribe to.

Show child attributes

taker_paysobjectrequired

The currency the taker would pay in the exchange.

Show child attributes

currencystring

Currency code

taker_getsobjectrequired

The currency the taker would receive in the exchange.

Show child attributes

currencystring

Currency code

issuerstring

Issuer account address

snapshotboolean

If true, include a snapshot of the current order book state. Defaults to false.

methodstringsubscribe

JSON-RPC method name.

paramsarray

Ordered JSON-RPC method parameters.

Response

200OK

HTTP 200 response for subscribe. The body contains either a successful result or a method-level JSON-RPC error.

400Bad Request

Bad Request. The request body is malformed or contains invalid JSON-RPC parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or node failed while processing the request.

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

curl -X POST 'https://xrp.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "id": "Example subscribe to XRP/GateHub USD order book",
    "command": "subscribe",
    "books": [
      {
        "taker_pays": {
          "currency": "XRP"
        },
        "taker_gets": {
          "currency": "USD",
          "issuer": "rhub8VRN55s94qWKDv6jmDy1pUykJzF3wq"
        },
        "snapshot": true
      }
    ]
  }'

const response = await fetch('https://xrp.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "id": "Example subscribe to XRP/GateHub USD order book",
      "command": "subscribe",
      "books": [
        {
          "taker_pays": {
            "currency": "XRP"
          },
          "taker_gets": {
            "currency": "USD",
            "issuer": "rhub8VRN55s94qWKDv6jmDy1pUykJzF3wq"
          },
          "snapshot": true
        }
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "id": "Example subscribe to XRP/GateHub USD order book",
  "command": "subscribe",
  "books": [
    {
      "taker_pays": {
        "currency": "XRP"
      },
      "taker_gets": {
        "currency": "USD",
        "issuer": "rhub8VRN55s94qWKDv6jmDy1pUykJzF3wq"
      },
      "snapshot": True
    }
  ]
}

response = requests.post('https://xrp.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "id": "Example subscribe to XRP/GateHub USD order book",
  "command": "subscribe",
  "books": [
    {
      "taker_pays": {
        "currency": "XRP"
      },
      "taker_gets": {
        "currency": "USD",
        "issuer": "rhub8VRN55s94qWKDv6jmDy1pUykJzF3wq"
      },
      "snapshot": true
    }
  ]
}

{
  "result": {
    "ledger_index": 105281656,
    "status": "success",
    "validated": true
  }
}

{
  "result": {
    "error": "invalidParams",
    "error_code": 31,
    "error_message": "Invalid parameters.",
    "request": {
      "method": "subscribe",
      "params": [
        {}
      ]
    },
    "status": "error"
  }
}

{
  "code": 400,
  "message": "Bad Request"
}

Unknown API_key

Method Not Allowed

Missing API_key

{
  "code": 500,
  "message": "Internal Server Error"
}

unsubscribe

unsubscribe operations.

unsubscribe

POST

https://xrp.nownodes.io/

Unsubscribe from real-time updates for various types of data in the XRP Ledger. This method cancels existing subscriptions to streaming data such as transactions, ledger closes, order book changes, and account updates.

Body

application/json

JSON-RPC request payload.

idstring

Optional unique identifier for the unsubscribe request. Should match the ID used in the original subscribe request if applicable.

commandstringunsubscriberequired

The command name

streamsArray<string>ledgerservertransactionstransactions_proposedvalidationsmanifests

Array of stream types to unsubscribe from.

accountsArray<string>

Array of account addresses to unsubscribe from regular transaction streams.

accounts_proposedArray<string>

Array of account addresses to unsubscribe from proposed transaction streams.

booksArray<object>

Array of order book specifications to unsubscribe from.

Show child attributes

taker_paysobject

The currency the taker would pay in the exchange.

Show child attributes

currencystring

Currency code

taker_getsobject

The currency the taker would receive in the exchange.

Show child attributes

currencystring

Currency code

issuerstring

Issuer account address

bothboolean

If true, unsubscribe from both sides of the order book. If false or omitted, only unsubscribe from the specified side.

methodstringunsubscribe

JSON-RPC method name.

paramsarray

Ordered JSON-RPC method parameters.

Response

200OK

HTTP 200 response for unsubscribe. The body contains either a successful result or a method-level JSON-RPC error.

400Bad Request

Bad Request. The request body is malformed or contains invalid JSON-RPC parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or node failed while processing the request.

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

unsubscribe

curl -X POST 'https://xrp.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "id": "Unsubscribe a lot of stuff",
    "command": "unsubscribe",
    "streams": [
      "ledger",
      "server",
      "transactions",
      "transactions_proposed"
    ],
    "accounts": [
      "rrpNnNLKrartuEqfJGpqyDwPj1AFPg9vn1"
    ],
    "accounts_proposed": [
      "rrpNnNLKrartuEqfJGpqyDwPj1AFPg9vn1"
    ],
    "books": [
      {
        "taker_pays": {
          "currency": "XRP"
        },
        "taker_gets": {
          "currency": "USD",
          "issuer": "rUQTpMqAF5jhykj4FExVeXakrZpiKF6cQV"
        },
        "both": true
      }
    ]
  }'

const response = await fetch('https://xrp.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "id": "Unsubscribe a lot of stuff",
      "command": "unsubscribe",
      "streams": [
        "ledger",
        "server",
        "transactions",
        "transactions_proposed"
      ],
      "accounts": [
        "rrpNnNLKrartuEqfJGpqyDwPj1AFPg9vn1"
      ],
      "accounts_proposed": [
        "rrpNnNLKrartuEqfJGpqyDwPj1AFPg9vn1"
      ],
      "books": [
        {
          "taker_pays": {
            "currency": "XRP"
          },
          "taker_gets": {
            "currency": "USD",
            "issuer": "rUQTpMqAF5jhykj4FExVeXakrZpiKF6cQV"
          },
          "both": true
        }
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "id": "Unsubscribe a lot of stuff",
  "command": "unsubscribe",
  "streams": [
    "ledger",
    "server",
    "transactions",
    "transactions_proposed"
  ],
  "accounts": [
    "rrpNnNLKrartuEqfJGpqyDwPj1AFPg9vn1"
  ],
  "accounts_proposed": [
    "rrpNnNLKrartuEqfJGpqyDwPj1AFPg9vn1"
  ],
  "books": [
    {
      "taker_pays": {
        "currency": "XRP"
      },
      "taker_gets": {
        "currency": "USD",
        "issuer": "rUQTpMqAF5jhykj4FExVeXakrZpiKF6cQV"
      },
      "both": True
    }
  ]
}

response = requests.post('https://xrp.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "id": "Unsubscribe a lot of stuff",
  "command": "unsubscribe",
  "streams": [
    "ledger",
    "server",
    "transactions",
    "transactions_proposed"
  ],
  "accounts": [
    "rrpNnNLKrartuEqfJGpqyDwPj1AFPg9vn1"
  ],
  "accounts_proposed": [
    "rrpNnNLKrartuEqfJGpqyDwPj1AFPg9vn1"
  ],
  "books": [
    {
      "taker_pays": {
        "currency": "XRP"
      },
      "taker_gets": {
        "currency": "USD",
        "issuer": "rUQTpMqAF5jhykj4FExVeXakrZpiKF6cQV"
      },
      "both": true
    }
  ]
}

{
  "result": {
    "ledger_index": 105281656,
    "status": "success",
    "validated": true
  }
}

{
  "result": {
    "error": "invalidParams",
    "error_code": 31,
    "error_message": "Invalid parameters.",
    "request": {
      "method": "unsubscribe",
      "params": [
        {}
      ]
    },
    "status": "error"
  }
}

{
  "code": 400,
  "message": "Bad Request"
}

Unknown API_key

Method Not Allowed

Missing API_key

{
  "code": 500,
  "message": "Internal Server Error"
}

Transaction

simulate

simulate operations.

simulate

POST

https://xrp.nownodes.io/

Simulates a transaction without actually submitting it to the network. This method allows you to test transaction outcomes, check for errors, and see the exact ledger changes that would occur if the transaction were executed. The simulation runs against the current working ledger state.

Body

application/json

JSON-RPC request payload.

methodstringsimulaterequired

JSON-RPC method name. Must be "simulate" for transaction simulation.

paramsArray<object>required

Array containing transaction simulation parameters. Must contain exactly one object.

Show child attributes

tx_jsonobjectrequired

Transaction object to simulate. Contains all transaction fields except signatures.

Show child attributes

TransactionTypestringPaymentTrustSetOfferCreateOfferCancelPaymentChannelCreatePaymentChannelClaimPaymentChannelFundCheckCreateCheckCashCheckCancelEscrowCreateEscrowFinishEscrowCancelAccountSetSetRegularKeySignerListSetTicketCreateDepositPreauthrequired

Type of transaction to execute. For payment simulation, must be "Payment".

Accountstringrequired

XRP Ledger address of the transaction sender (source account). Must be a valid XRP address starting with 'r'.

Destinationstringrequired

XRP Ledger address of the transaction recipient. Must be a valid XRP address starting with 'r'.

Amountobjectrequired

Amount of issued currency (IOU) to send. Required for non-XRP payments.

Show child attributes

currencystringrequired

Three-letter ISO 4217 currency code or 160-bit hex string for custom currencies. For USD, use "USD".

valuestringrequired

Amount of currency to send as a decimal string. Can include decimal point.

issuerstringrequired

XRP Ledger address of the currency issuer. Must be a valid XRP address.

Feestring

Transaction fee in drops. Automatically calculated if omitted. For simulation, can be omitted or estimated.

Sequenceinteger>= 1

Transaction sequence number. Must be one greater than the sender's current sequence number. If omitted, uses next available sequence.

LastLedgerSequenceinteger>= 1

Highest ledger index in which the transaction can be validated. Provides transaction expiration. Recommended for reliable simulation.

Flagsinteger

Bitwise flags for transaction options. 2147483648 (0x80000000) indicates fully canonical signature.

SigningPubKeystring

Public key used to verify the transaction signature. Can be empty string for simulation.

TxnSignaturestring

Transaction signature. Can be empty string for simulation.

Response

200OK

HTTP 200 response for simulate. The body contains either a successful result or a method-level JSON-RPC error.

400Bad Request

Bad Request. The request body is malformed or contains invalid JSON-RPC parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or node failed while processing the request.

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

simulate

curl -X POST 'https://xrp.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "method": "simulate",
    "params": [
      {
        "tx_json": {
          "TransactionType": "Payment",
          "Account": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn",
          "Destination": "ra5nK24KXen9AHvsdFTKHSANinZseWnPcX",
          "Amount": {
            "currency": "USD",
            "value": "1",
            "issuer": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn"
          }
        }
      }
    ]
  }'

const response = await fetch('https://xrp.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "method": "simulate",
      "params": [
        {
          "tx_json": {
            "TransactionType": "Payment",
            "Account": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn",
            "Destination": "ra5nK24KXen9AHvsdFTKHSANinZseWnPcX",
            "Amount": {
              "currency": "USD",
              "value": "1",
              "issuer": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn"
            }
          }
        }
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "method": "simulate",
  "params": [
    {
      "tx_json": {
        "TransactionType": "Payment",
        "Account": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn",
        "Destination": "ra5nK24KXen9AHvsdFTKHSANinZseWnPcX",
        "Amount": {
          "currency": "USD",
          "value": "1",
          "issuer": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn"
        }
      }
    }
  ]
}

response = requests.post('https://xrp.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "method": "simulate",
  "params": [
    {
      "tx_json": {
        "TransactionType": "Payment",
        "Account": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn",
        "Destination": "ra5nK24KXen9AHvsdFTKHSANinZseWnPcX",
        "Amount": {
          "currency": "USD",
          "value": "1",
          "issuer": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn"
        }
      }
    }
  ]
}

{
  "result": {
    "ledger_index": 105281656,
    "status": "success",
    "validated": true
  }
}

{
  "result": {
    "error": "invalidParams",
    "error_code": 31,
    "error_message": "Invalid parameters.",
    "request": {
      "method": "simulate",
      "params": [
        {}
      ]
    },
    "status": "error"
  }
}

{
  "code": 400,
  "message": "Bad Request"
}

Unknown API_key

Method Not Allowed

Missing API_key

{
  "code": 500,
  "message": "Internal Server Error"
}

submit_multisigned

submit_multisigned operations.

submit_multisigned

POST

https://xrp.nownodes.io/

Submits a multi-signed transaction to the XRP Ledger. Multi-signing allows multiple accounts to jointly authorize transactions from a single account using a signer list. This method submits a transaction that has already been signed by the required number of signers.

Body

application/json

JSON-RPC request payload.

methodstringsubmit_multisignedrequired

The JSON-RPC method name

paramsArray<object>required

Ordered JSON-RPC method parameters.

Show child attributes

tx_jsonobjectrequired

XRPL transaction hash.

Show child attributes

Accountstringrequired

The account that is sending the transaction (the multi-signed account).

TransactionTypestringrequired

The type of transaction to submit.

Feestringrequired

The transaction fee in drops of XRP. Multi-signed transactions typically require higher fees due to larger size.

Sequenceintegerrequired

The sequence number for the transaction.

Flagsinteger

Transaction flags.

262144: tfClearNoRipple - Clear the NoRipple flag on a trust line

SignersArray<object>required

Array of signers who have signed this transaction. Must meet the quorum requirements defined in the account's signer list.

Show child attributes

Signerobject

Signer value.

Show child attributes

Accountstringrequired

The account of one of the signers.

SigningPubKeystringrequired

The public key used by this signer to sign the transaction.

TxnSignaturestringrequired

The cryptographic signature from this signer.

SigningPubKeystring

Empty string for multi-signed transactions. The actual signing is done by the signers in the Signers array.

hashstring

(Optional) The hash of the transaction. Can be provided for verification purposes.

LimitAmountobject

For TrustSet transactions, the trust line limit to set.

Show child attributes

currencystring

The currency code for the trust line.

issuerstring

The issuer of the currency.

valuestring

The limit amount for the trust line.

Response

200OK

HTTP 200 response for submit_multisigned. The body contains either a successful result or a method-level JSON-RPC error.

400Bad Request

Bad Request. The request body is malformed or contains invalid JSON-RPC parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or node failed while processing the request.

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

submit_multisigned

curl -X POST 'https://xrp.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "method": "submit_multisigned",
    "params": [
      {
        "tx_json": {
          "Account": "rEuLyBCvcw4CFmzv8RepSiAoNgF8tTGJQC",
          "Fee": "30000",
          "Flags": 262144,
          "LimitAmount": {
            "currency": "USD",
            "issuer": "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
            "value": "0"
          },
          "Sequence": 4,
          "Signers": [
            {
              "Signer": {
                "Account": "rsA2LpzuawewSBQXkiju3YQTMzW13pAAdW",
                "SigningPubKey": "02B3EC4E5DD96029A647CFA20DA07FE1F85296505552CCAC114087E66B46BD77DF",
                "TxnSignature": "3045022100CC9C56DF51251CB04BB047E5F3B5EF01A0F4A8A549D7A20A7402BF54BA744064022061EF8EF1BCCBF144F480B32508B1D10FD4271831D5303F920DE41C64671CB5B7"
              }
            },
            {
              "Signer": {
                "Account": "raKEEVSGnKSD9Zyvxu4z6Pqpm4ABH8FS6n",
                "SigningPubKey": "03398A4EDAE8EE009A5879113EAA5BA15C7BB0F612A87F4103E793AC919BD1E3C1",
                "TxnSignature": "3045022100FEE8D8FA2D06CE49E9124567DCA265A21A9F5465F4A9279F075E4CE27E4430DE022042D5305777DA1A7801446780308897699412E4EDF0E1AEFDF3C8A0532BDE4D08"
              }
            }
          ],
          "SigningPubKey": "",
          "TransactionType": "TrustSet",
          "hash": "81A477E2A362D171BB16BE17B4120D9F809A327FA00242ABCA867283BEA2F4F8"
        }
      }
    ]
  }'

const response = await fetch('https://xrp.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "method": "submit_multisigned",
      "params": [
        {
          "tx_json": {
            "Account": "rEuLyBCvcw4CFmzv8RepSiAoNgF8tTGJQC",
            "Fee": "30000",
            "Flags": 262144,
            "LimitAmount": {
              "currency": "USD",
              "issuer": "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
              "value": "0"
            },
            "Sequence": 4,
            "Signers": [
              {
                "Signer": {
                  "Account": "rsA2LpzuawewSBQXkiju3YQTMzW13pAAdW",
                  "SigningPubKey": "02B3EC4E5DD96029A647CFA20DA07FE1F85296505552CCAC114087E66B46BD77DF",
                  "TxnSignature": "3045022100CC9C56DF51251CB04BB047E5F3B5EF01A0F4A8A549D7A20A7402BF54BA744064022061EF8EF1BCCBF144F480B32508B1D10FD4271831D5303F920DE41C64671CB5B7"
                }
              },
              {
                "Signer": {
                  "Account": "raKEEVSGnKSD9Zyvxu4z6Pqpm4ABH8FS6n",
                  "SigningPubKey": "03398A4EDAE8EE009A5879113EAA5BA15C7BB0F612A87F4103E793AC919BD1E3C1",
                  "TxnSignature": "3045022100FEE8D8FA2D06CE49E9124567DCA265A21A9F5465F4A9279F075E4CE27E4430DE022042D5305777DA1A7801446780308897699412E4EDF0E1AEFDF3C8A0532BDE4D08"
                }
              }
            ],
            "SigningPubKey": "",
            "TransactionType": "TrustSet",
            "hash": "81A477E2A362D171BB16BE17B4120D9F809A327FA00242ABCA867283BEA2F4F8"
          }
        }
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "method": "submit_multisigned",
  "params": [
    {
      "tx_json": {
        "Account": "rEuLyBCvcw4CFmzv8RepSiAoNgF8tTGJQC",
        "Fee": "30000",
        "Flags": 262144,
        "LimitAmount": {
          "currency": "USD",
          "issuer": "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
          "value": "0"
        },
        "Sequence": 4,
        "Signers": [
          {
            "Signer": {
              "Account": "rsA2LpzuawewSBQXkiju3YQTMzW13pAAdW",
              "SigningPubKey": "02B3EC4E5DD96029A647CFA20DA07FE1F85296505552CCAC114087E66B46BD77DF",
              "TxnSignature": "3045022100CC9C56DF51251CB04BB047E5F3B5EF01A0F4A8A549D7A20A7402BF54BA744064022061EF8EF1BCCBF144F480B32508B1D10FD4271831D5303F920DE41C64671CB5B7"
            }
          },
          {
            "Signer": {
              "Account": "raKEEVSGnKSD9Zyvxu4z6Pqpm4ABH8FS6n",
              "SigningPubKey": "03398A4EDAE8EE009A5879113EAA5BA15C7BB0F612A87F4103E793AC919BD1E3C1",
              "TxnSignature": "3045022100FEE8D8FA2D06CE49E9124567DCA265A21A9F5465F4A9279F075E4CE27E4430DE022042D5305777DA1A7801446780308897699412E4EDF0E1AEFDF3C8A0532BDE4D08"
            }
          }
        ],
        "SigningPubKey": "",
        "TransactionType": "TrustSet",
        "hash": "81A477E2A362D171BB16BE17B4120D9F809A327FA00242ABCA867283BEA2F4F8"
      }
    }
  ]
}

response = requests.post('https://xrp.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "method": "submit_multisigned",
  "params": [
    {
      "tx_json": {
        "Account": "rEuLyBCvcw4CFmzv8RepSiAoNgF8tTGJQC",
        "Fee": "30000",
        "Flags": 262144,
        "LimitAmount": {
          "currency": "USD",
          "issuer": "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
          "value": "0"
        },
        "Sequence": 4,
        "Signers": [
          {
            "Signer": {
              "Account": "rsA2LpzuawewSBQXkiju3YQTMzW13pAAdW",
              "SigningPubKey": "02B3EC4E5DD96029A647CFA20DA07FE1F85296505552CCAC114087E66B46BD77DF",
              "TxnSignature": "3045022100CC9C56DF51251CB04BB047E5F3B5EF01A0F4A8A549D7A20A7402BF54BA744064022061EF8EF1BCCBF144F480B32508B1D10FD4271831D5303F920DE41C64671CB5B7"
            }
          },
          {
            "Signer": {
              "Account": "raKEEVSGnKSD9Zyvxu4z6Pqpm4ABH8FS6n",
              "SigningPubKey": "03398A4EDAE8EE009A5879113EAA5BA15C7BB0F612A87F4103E793AC919BD1E3C1",
              "TxnSignature": "3045022100FEE8D8FA2D06CE49E9124567DCA265A21A9F5465F4A9279F075E4CE27E4430DE022042D5305777DA1A7801446780308897699412E4EDF0E1AEFDF3C8A0532BDE4D08"
            }
          }
        ],
        "SigningPubKey": "",
        "TransactionType": "TrustSet",
        "hash": "81A477E2A362D171BB16BE17B4120D9F809A327FA00242ABCA867283BEA2F4F8"
      }
    }
  ]
}

{
  "result": {
    "ledger_index": 105281656,
    "status": "success",
    "validated": true
  }
}

{
  "result": {
    "error": "invalidParams",
    "error_code": 31,
    "error_message": "Invalid parameters.",
    "request": {
      "method": "submit_multisigned",
      "params": [
        {}
      ]
    },
    "status": "error"
  }
}

{
  "code": 400,
  "message": "Bad Request"
}

Unknown API_key

Method Not Allowed

Missing API_key

{
  "code": 500,
  "message": "Internal Server Error"
}

submit

submit operations.

submit

POST

https://xrp.nownodes.io/

Submits a transaction to the XRP Ledger for inclusion in a future ledger. This method signs and broadcasts the transaction to the network. The transaction may be applied immediately or queued for later processing.

Body

application/json

JSON-RPC request body for submit.

JSON-RPC request body for the XRPL submit method.

jsonrpcstring2.0required

JSON-RPC protocol version.

methodstringsubmitrequired

RPC method name.

paramsArray<object>required

Submit method parameters. The first object must contain a signed transaction blob.

Show child attributes

tx_blobstringrequired

Hex representation of the signed transaction to submit.

fail_hardboolean

If true and the transaction fails locally, do not retry or relay the transaction to other servers. Defaults to false.

idinteger | stringrequired

Client-supplied JSON-RPC request identifier.

Response

200OK

JSON-RPC response. XRPL transaction-engine failures can still be returned with HTTP 200.

400Bad Request

Bad Request. The request body is malformed or contains invalid JSON-RPC parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or node failed while processing the request.

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

submit

curl -X POST 'https://xrp.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "submit",
    "params": [
      {
        "tx_blob": "1200002280000000240000000361D4838D7EA4C6800000000000000000000000000055534400000000004B4E9C06F24296074F7BC48F92A97916C6DC5EA968400000000000000A732103AB40A0490F9B7ED8DF29D246BF2D6269820A0EE7742ACDD457BEA7C7D0931EDB74473045022100D184EB4AE5956FF600E7536EE459345C7BBCF097A84CC61A93B9AF7197EDB98702201CEA8009B7BEEBAA2AACC0359B41C427C1C5B550A4CA4B80CF2174AF2D6D5DCE81144B4E9C06F24296074F7BC48F92A97916C6DC5EA983143E9D4A2B8AA0780F682D136F7A56D6724EF53754",
        "fail_hard": false
      }
    ],
    "id": 1
  }'

const response = await fetch('https://xrp.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "submit",
      "params": [
        {
          "tx_blob": "1200002280000000240000000361D4838D7EA4C6800000000000000000000000000055534400000000004B4E9C06F24296074F7BC48F92A97916C6DC5EA968400000000000000A732103AB40A0490F9B7ED8DF29D246BF2D6269820A0EE7742ACDD457BEA7C7D0931EDB74473045022100D184EB4AE5956FF600E7536EE459345C7BBCF097A84CC61A93B9AF7197EDB98702201CEA8009B7BEEBAA2AACC0359B41C427C1C5B550A4CA4B80CF2174AF2D6D5DCE81144B4E9C06F24296074F7BC48F92A97916C6DC5EA983143E9D4A2B8AA0780F682D136F7A56D6724EF53754",
          "fail_hard": false
        }
      ],
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "submit",
  "params": [
    {
      "tx_blob": "1200002280000000240000000361D4838D7EA4C6800000000000000000000000000055534400000000004B4E9C06F24296074F7BC48F92A97916C6DC5EA968400000000000000A732103AB40A0490F9B7ED8DF29D246BF2D6269820A0EE7742ACDD457BEA7C7D0931EDB74473045022100D184EB4AE5956FF600E7536EE459345C7BBCF097A84CC61A93B9AF7197EDB98702201CEA8009B7BEEBAA2AACC0359B41C427C1C5B550A4CA4B80CF2174AF2D6D5DCE81144B4E9C06F24296074F7BC48F92A97916C6DC5EA983143E9D4A2B8AA0780F682D136F7A56D6724EF53754",
      "fail_hard": False
    }
  ],
  "id": 1
}

response = requests.post('https://xrp.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "jsonrpc": "2.0",
  "method": "submit",
  "params": [
    {
      "tx_blob": "1200002280000000240000000361D4838D7EA4C6800000000000000000000000000055534400000000004B4E9C06F24296074F7BC48F92A97916C6DC5EA968400000000000000A732103AB40A0490F9B7ED8DF29D246BF2D6269820A0EE7742ACDD457BEA7C7D0931EDB74473045022100D184EB4AE5956FF600E7536EE459345C7BBCF097A84CC61A93B9AF7197EDB98702201CEA8009B7BEEBAA2AACC0359B41C427C1C5B550A4CA4B80CF2174AF2D6D5DCE81144B4E9C06F24296074F7BC48F92A97916C6DC5EA983143E9D4A2B8AA0780F682D136F7A56D6724EF53754"
    }
  ],
  "id": 1
}

{
  "jsonrpc": "2.0",
  "method": "submit",
  "params": [
    {
      "tx_blob": "00",
      "fail_hard": true
    }
  ],
  "id": 1
}

{
  "result": {
    "accepted": true,
    "account_sequence_available": 395,
    "account_sequence_next": 395,
    "applied": false,
    "broadcast": false,
    "engine_result": "tefPAST_SEQ",
    "engine_result_code": -190,
    "engine_result_message": "This sequence number has already passed.",
    "kept": true,
    "open_ledger_cost": "10",
    "queued": false,
    "tx_blob": "1200002280000000240000000361D4838D7EA4C6800000000000000000000000000055534400000000004B4E9C06F24296074F7BC48F92A97916C6DC5EA968400000000000000A732103AB40A0490F9B7ED8DF29D246BF2D6269820A0EE7742ACDD457BEA7C7D0931EDB74473045022100D184EB4AE5956FF600E7536EE459345C7BBCF097A84CC61A93B9AF7197EDB98702201CEA8009B7BEEBAA2AACC0359B41C427C1C5B550A4CA4B80CF2174AF2D6D5DCE81144B4E9C06F24296074F7BC48F92A97916C6DC5EA983143E9D4A2B8AA0780F682D136F7A56D6724EF53754",
    "tx_json": {
      "Account": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn",
      "Amount": {
        "currency": "USD",
        "issuer": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn",
        "value": "1"
      },
      "Destination": "ra5nK24KXen9AHvsdFTKHSANinZseWnPcX",
      "Fee": "10",
      "Flags": 2147483648,
      "Sequence": 3,
      "SigningPubKey": "03AB40A0490F9B7ED8DF29D246BF2D6269820A0EE7742ACDD457BEA7C7D0931EDB",
      "TransactionType": "Payment",
      "TxnSignature": "3045022100D184EB4AE5956FF600E7536EE459345C7BBCF097A84CC61A93B9AF7197EDB98702201CEA8009B7BEEBAA2AACC0359B41C427C1C5B550A4CA4B80CF2174AF2D6D5DCE",
      "hash": "82230B9D489370504B39BC2CE46216176CAC9E752E5C1774A8CBEC9FBB819208"
    },
    "validated_ledger_index": 102609807,
    "status": "success"
  },
  "status": "success",
  "type": "response",
  "forwarded": true,
  "warnings": [
    {
      "id": 2001,
      "message": "This is a clio server. clio only serves validated data. If you want to talk to rippled, include 'ledger_index':'current' in your request"
    }
  ]
}

{
  "code": 400,
  "message": "Bad Request"
}

Unknown API_key

Method Not Allowed

Missing API_key

{
  "code": 500,
  "message": "Internal Server Error"
}

transaction_entry

transaction_entry operations.

transaction_entry

POST

https://xrp.nownodes.io/

Returns information about a specific transaction from a particular ledger version. This method allows you to retrieve transaction details by specifying both the transaction hash and the ledger index where it was included. This is more specific than the tx method which searches across multiple ledgers.

Body

application/json

JSON-RPC request payload.

methodstringtransaction_entryrequired

The JSON-RPC method name

paramsArray<object>required

Ordered JSON-RPC method parameters.

Show child attributes

tx_hashstringrequired

The 256-bit hash of the transaction to look up. This uniquely identifies the transaction across the entire ledger history.

ledger_hashstring

(Optional) A 20-byte hex string identifying a specific ledger version to search in. Either ledger_hash or ledger_index must be specified.

ledger_indexinteger

The ledger index of the ledger to search in. Either ledger_hash or ledger_index must be specified.

binaryboolean

If true, return transaction data as hex strings instead of JSON.

Response

200OK

HTTP 200 response for transaction_entry. The body contains either a successful result or a method-level JSON-RPC error.

400Bad Request

Bad Request. The request body is malformed or contains invalid JSON-RPC parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or node failed while processing the request.

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

transaction_entry

curl -X POST 'https://xrp.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "method": "transaction_entry",
    "params": [
      {
        "tx_hash": "C53ECF838647FA5A4C780377025FEC7999AB4182590510CA461444B207AB74A9",
        "ledger_index": 56865245
      }
    ]
  }'

const response = await fetch('https://xrp.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "method": "transaction_entry",
      "params": [
        {
          "tx_hash": "C53ECF838647FA5A4C780377025FEC7999AB4182590510CA461444B207AB74A9",
          "ledger_index": 56865245
        }
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "method": "transaction_entry",
  "params": [
    {
      "tx_hash": "C53ECF838647FA5A4C780377025FEC7999AB4182590510CA461444B207AB74A9",
      "ledger_index": 56865245
    }
  ]
}

response = requests.post('https://xrp.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "method": "transaction_entry",
  "params": [
    {
      "tx_hash": "C53ECF838647FA5A4C780377025FEC7999AB4182590510CA461444B207AB74A9",
      "ledger_index": 56865245
    }
  ]
}

{
  "result": {
    "Account": "rJ8hb4jMHgRNhEQ7BTGz6vt14kWn2z6H78",
    "Amount": "10481740797",
    "Destination": "r3uX3Vsy1E4NG8uo4Vx1Jx66MN9TowkX2t",
    "Fee": "10000",
    "Flags": 2147483648,
    "LastLedgerSequence": 105291628,
    "Sequence": 92896974,
    "TransactionType": "Payment",
    "hash": "C6F5A09685595EF5401C8EAB11A5CA9DF3C8CC064DE1CA470B4432AD03251648",
    "ledger_index": 105281633,
    "date": 836151662,
    "meta": {
      "AffectedNodes": [
        {
          "ModifiedNode": {
            "LedgerEntryType": "AccountRoot",
            "LedgerIndex": "5139D633ED1CE7DDD48BD0C5FDD05A80068F448E2DA7D0030859BBA9438AEB01"
          }
        },
        {
          "ModifiedNode": {
            "LedgerEntryType": "AccountRoot",
            "LedgerIndex": "8C1ABF682E8C5CC85545157139CFDEB76F20904AB5FFC73B5371606B31CA3C16"
          }
        }
      ],
      "TransactionIndex": 0,
      "TransactionResult": "tesSUCCESS",
      "delivered_amount": "10481740797"
    },
    "status": "success",
    "validated": true
  }
}

{
  "result": {
    "error": "invalidParams",
    "error_code": 31,
    "error_message": "Invalid parameters.",
    "request": {
      "method": "transaction_entry",
      "params": [
        {}
      ]
    },
    "status": "error"
  }
}

{
  "code": 400,
  "message": "Bad Request"
}

Unknown API_key

Method Not Allowed

Missing API_key

{
  "code": 500,
  "message": "Internal Server Error"
}

tx_history

tx_history operations.

tx_history

POST

https://xrp.nownodes.io/

Returns a paginated list of recent transactions from the XRP Ledger. This method provides a transaction history view, showing the most recent transactions that have been included in validated ledgers. It's useful for monitoring network activity and recent trading.

Body

application/json

JSON-RPC request payload.

methodstringtx_historyrequired

The JSON-RPC method name

paramsArray<object>required

Ordered JSON-RPC method parameters.

Show child attributes

startinteger

The starting index for pagination. Use 0 to start from the most recent transactions.

limitinteger

(Optional) The number of transactions to return. The server may enforce a maximum limit.

Response

200OK

HTTP 200 response for tx_history. The body contains either a successful result or a method-level JSON-RPC error.

400Bad Request

Bad Request. The request body is malformed or contains invalid JSON-RPC parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or node failed while processing the request.

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

tx_history

curl -X POST 'https://xrp.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "method": "tx_history",
    "params": [
      {
        "start": 0
      }
    ]
  }'

const response = await fetch('https://xrp.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "method": "tx_history",
      "params": [
        {
          "start": 0
        }
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "method": "tx_history",
  "params": [
    {
      "start": 0
    }
  ]
}

response = requests.post('https://xrp.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "method": "tx_history",
  "params": [
    {
      "start": 0
    }
  ]
}

{
  "result": {
    "Account": "rJ8hb4jMHgRNhEQ7BTGz6vt14kWn2z6H78",
    "Amount": "10481740797",
    "Destination": "r3uX3Vsy1E4NG8uo4Vx1Jx66MN9TowkX2t",
    "Fee": "10000",
    "Flags": 2147483648,
    "LastLedgerSequence": 105291628,
    "Sequence": 92896974,
    "TransactionType": "Payment",
    "hash": "C6F5A09685595EF5401C8EAB11A5CA9DF3C8CC064DE1CA470B4432AD03251648",
    "ledger_index": 105281633,
    "date": 836151662,
    "meta": {
      "AffectedNodes": [
        {
          "ModifiedNode": {
            "LedgerEntryType": "AccountRoot",
            "LedgerIndex": "5139D633ED1CE7DDD48BD0C5FDD05A80068F448E2DA7D0030859BBA9438AEB01"
          }
        },
        {
          "ModifiedNode": {
            "LedgerEntryType": "AccountRoot",
            "LedgerIndex": "8C1ABF682E8C5CC85545157139CFDEB76F20904AB5FFC73B5371606B31CA3C16"
          }
        }
      ],
      "TransactionIndex": 0,
      "TransactionResult": "tesSUCCESS",
      "delivered_amount": "10481740797"
    },
    "status": "success",
    "validated": true
  }
}

{
  "result": {
    "error": "invalidParams",
    "error_code": 31,
    "error_message": "Invalid parameters.",
    "request": {
      "method": "tx_history",
      "params": [
        {}
      ]
    },
    "status": "error"
  }
}

{
  "code": 400,
  "message": "Bad Request"
}

Unknown API_key

Method Not Allowed

Missing API_key

{
  "code": 500,
  "message": "Internal Server Error"
}

tx

tx operations.

tx

POST

https://xrp.nownodes.io/

Retrieves information about a specific transaction by its hash. This method searches across multiple ledgers to find the transaction and returns comprehensive details including the transaction data, metadata about ledger changes, and validation status.

Body

application/json

JSON-RPC request payload.

methodstringtxrequired

The JSON-RPC method name

paramsArray<object>required

Ordered JSON-RPC method parameters.

Show child attributes

transactionstringrequired

The unique hash of the transaction to look up. This is the primary identifier for transactions in the XRP Ledger.

binaryboolean

If true, return transaction data as hex strings instead of JSON. When false (recommended), transactions are returned in parsed JSON format.

min_ledgerinteger

(Optional) The minimum ledger index to search from.

max_ledgerinteger

(Optional) The maximum ledger index to search to.

api_versioninteger

(Optional) The API version to use. Version 2 provides enhanced response formatting including the CTID (Compact Transaction ID) field.

Response

200OK

HTTP 200 response for tx. The body contains either a successful result or a method-level JSON-RPC error.

400Bad Request

Bad Request. The request body is malformed or contains invalid JSON-RPC parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or node failed while processing the request.

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

curl -X POST 'https://xrp.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "method": "tx",
    "params": [
      {
        "transaction": "C53ECF838647FA5A4C780377025FEC7999AB4182590510CA461444B207AB74A9",
        "binary": false,
        "api_version": 2
      }
    ]
  }'

const response = await fetch('https://xrp.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "method": "tx",
      "params": [
        {
          "transaction": "C53ECF838647FA5A4C780377025FEC7999AB4182590510CA461444B207AB74A9",
          "binary": false,
          "api_version": 2
        }
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "method": "tx",
  "params": [
    {
      "transaction": "C53ECF838647FA5A4C780377025FEC7999AB4182590510CA461444B207AB74A9",
      "binary": False,
      "api_version": 2
    }
  ]
}

response = requests.post('https://xrp.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "method": "tx",
  "params": [
    {
      "transaction": "C53ECF838647FA5A4C780377025FEC7999AB4182590510CA461444B207AB74A9",
      "binary": false,
      "api_version": 2
    }
  ]
}

{
  "result": {
    "Account": "rJ8hb4jMHgRNhEQ7BTGz6vt14kWn2z6H78",
    "Amount": "10481740797",
    "Destination": "r3uX3Vsy1E4NG8uo4Vx1Jx66MN9TowkX2t",
    "Fee": "10000",
    "Flags": 2147483648,
    "LastLedgerSequence": 105291628,
    "Sequence": 92896974,
    "TransactionType": "Payment",
    "hash": "C6F5A09685595EF5401C8EAB11A5CA9DF3C8CC064DE1CA470B4432AD03251648",
    "ledger_index": 105281633,
    "date": 836151662,
    "meta": {
      "AffectedNodes": [
        {
          "ModifiedNode": {
            "LedgerEntryType": "AccountRoot",
            "LedgerIndex": "5139D633ED1CE7DDD48BD0C5FDD05A80068F448E2DA7D0030859BBA9438AEB01"
          }
        },
        {
          "ModifiedNode": {
            "LedgerEntryType": "AccountRoot",
            "LedgerIndex": "8C1ABF682E8C5CC85545157139CFDEB76F20904AB5FFC73B5371606B31CA3C16"
          }
        }
      ],
      "TransactionIndex": 0,
      "TransactionResult": "tesSUCCESS",
      "delivered_amount": "10481740797"
    },
    "status": "success",
    "validated": true
  }
}

{
  "result": {
    "error": "invalidParams",
    "error_code": 31,
    "error_message": "Invalid parameters.",
    "request": {
      "method": "tx",
      "params": [
        {}
      ]
    },
    "status": "error"
  }
}

{
  "code": 400,
  "message": "Bad Request"
}

Unknown API_key

Method Not Allowed

Missing API_key

{
  "code": 500,
  "message": "Internal Server Error"
}

Utility

ping

ping operations.

ping

POST

https://xrp.nownodes.io/

Check the server's connectivity and responsiveness. This method provides a simple way to verify that the server is online and responding to requests. It returns a minimal response with a success status if the server is operational.

Body

application/json

JSON-RPC request payload.

methodstringpingrequired

The JSON-RPC method name

paramsArray<object>required

Ordered JSON-RPC method parameters.

Response

200OK

HTTP 200 response for ping. The body contains either a successful result or a method-level JSON-RPC error.

400Bad Request

Bad Request. The request body is malformed or contains invalid JSON-RPC parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or node failed while processing the request.

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

ping

curl -X POST 'https://xrp.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "method": "ping",
    "params": [
      {}
    ]
  }'

const response = await fetch('https://xrp.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "method": "ping",
      "params": [
        {}
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "method": "ping",
  "params": [
    {}
  ]
}

response = requests.post('https://xrp.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "method": "ping",
  "params": [
    {}
  ]
}

{
  "result": {
    "status": "success"
  }
}

{
  "result": {
    "error": "invalidParams",
    "error_code": 31,
    "error_message": "Invalid parameters.",
    "request": {
      "method": "ping",
      "params": [
        {}
      ]
    },
    "status": "error"
  }
}

{
  "code": 400,
  "message": "Bad Request"
}

Unknown API_key

Method Not Allowed

Missing API_key

{
  "code": 500,
  "message": "Internal Server Error"
}

random

random operations.

random

POST

https://xrp.nownodes.io/

Generate a random number using the server's random number generator. This method returns a high-quality random value that can be used for cryptographic operations, nonce generation, or other applications requiring secure randomness. The random value is generated using the server's cryptographically secure random number generator.

Body

application/json

JSON-RPC request payload.

methodstringrandomrequired

The JSON-RPC method name

paramsArray<object>required

Ordered JSON-RPC method parameters.

Response

200OK

HTTP 200 response for random. The body contains either a successful result or a method-level JSON-RPC error.

400Bad Request

Bad Request. The request body is malformed or contains invalid JSON-RPC parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

405Method Not Allowed

Method Not Allowed. Returned by the NOWNodes gateway for malformed or unsupported gateway-level requests.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or node failed while processing the request.

Authorization

api-keyAuthapiKey in header

NOWNodes API key passed in the api-key header.

random

curl -X POST 'https://xrp.nownodes.io/' \
  -H 'Content-Type: application/json' \
  -d '{
    "method": "random",
    "params": [
      {}
    ]
  }'

const response = await fetch('https://xrp.nownodes.io/', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "method": "random",
      "params": [
        {}
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "method": "random",
  "params": [
    {}
  ]
}

response = requests.post('https://xrp.nownodes.io/', json=payload)
data = response.json()

Request Body

{
  "method": "random",
  "params": [
    {}
  ]
}

{
  "result": {
    "random": "8ED765A3727B25E152C5B3A9F0A1C3E44E8848703A659A8F3E1BAF18264C2C0A",
    "status": "success"
  }
}

{
  "result": {
    "error": "invalidParams",
    "error_code": 31,
    "error_message": "Invalid parameters.",
    "request": {
      "method": "random",
      "params": [
        {}
      ]
    },
    "status": "error"
  }
}

{
  "code": 400,
  "message": "Bad Request"
}

Unknown API_key

Method Not Allowed

Missing API_key

{
  "code": 500,
  "message": "Internal Server Error"
}

Documentation

Authentication

Account

account_channels

Body

Response

Authorization

account_currencies

Body

Response

Authorization

account_info

Body

Response

Authorization

account_lines

Body

Response

Authorization

account_nfts

Body

Response

Authorization

account_objects

Body

Response

Authorization

account_offers

Body

Response

Authorization

account_tx

Body

Response

Authorization

gateway_balances

Body

Response

Authorization

noripple_check

Body

Response

Authorization

Clio

ledger

Body

Response

Authorization

server_info

Body

Response

Authorization

Ledger

ledger

Body

Response

Authorization

ledger_closed

Body

Response

Authorization

ledger_current

Body

Response

Authorization

ledger_data

Body

Response

Authorization

EVM

eth_accounts

Body

Response

Authorization

eth_blockNumber

Body

Response

Authorization

eth_call

Body