ARDR Node API

v1.0.0

Base URL

https://ardr.nownodes.io

JSON-RPC API for ARDR network

Authentication

ApiKeyAuthapiKey

API Key: api-key in header

Account Control

getAccount

Get account information given an account ID

POST

https://ardr.nownodes.io/nxt

Body

application/json

jsonrpcstringrequired

methodstringrequired

paramsobjectrequired

Show child attributes

requestTypestring

accountstring

The account ID

includeLessorsboolean

true to include lessors, lessorsRS and lessorsInfo

includeAssetsboolean

true to include assetBalances and unconfirmedAssetBalances

includeCurrenciesboolean

true to include accountCurrencies

includeEffectiveBalanceboolean

true to include effectiveBalanceNXT and guaranteedBalanceNQT

requireBlockstring

The block ID of a block that must be present in the blockchain

requireLastBlockstring

The block ID of a block that must be last in the blockchain

idintegerrequired

Response

200OK

Account information

400Bad Request

Bad Request

401Unauthorized

Unauthorized — Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Get account information given an account ID

curl -X POST 'https://ardr.nownodes.io/nxt' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "getAccount",
    "params": {
      "requestType": "getAccount",
      "account": "string",
      "includeLessors": true,
      "includeAssets": true,
      "includeCurrencies": true,
      "includeEffectiveBalance": true,
      "requireBlock": "string",
      "requireLastBlock": "string"
    },
    "id": 1
  }'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "getAccount",
      "params": {
        "requestType": "getAccount",
        "account": "string",
        "includeLessors": true,
        "includeAssets": true,
        "includeCurrencies": true,
        "includeEffectiveBalance": true,
        "requireBlock": "string",
        "requireLastBlock": "string"
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "getAccount",
  "params": {
    "requestType": "getAccount",
    "account": "string",
    "includeLessors": True,
    "includeAssets": True,
    "includeCurrencies": True,
    "includeEffectiveBalance": True,
    "requireBlock": "string",
    "requireLastBlock": "string"
  },
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "getAccount",
  "params": {
    "requestType": "getAccount",
    "account": "string",
    "includeLessors": true,
    "includeAssets": true,
    "includeCurrencies": true,
    "includeEffectiveBalance": true,
    "requireBlock": "string",
    "requireLastBlock": "string"
  },
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "forgedBalanceFQT": "string",
    "assetBalances": [
      {
        "balanceQNT": "string",
        "asset": "string"
      }
    ],
    "unconfirmedAssetBalances": [
      {
        "unconfirmedBalanceQNT": "string",
        "asset": "string"
      }
    ],
    "accountCurrencies": [
      {}
    ],
    "lessorsInfo": [
      {
        "currentHeightTo": "string",
        "nextHeightFrom": "string",
        "nextLesseeRS": "string",
        "currentLesseeRS": "string",
        "currentHeightFrom": "string",
        "nextHeightTo": "string"
      }
    ],
    "lessors": [
      "string"
    ],
    "currentLessee": "string",
    "currentLeasingHeightTo": 0,
    "balanceNQT": "string",
    "publicKey": "string",
    "requestProcessingTime": 0,
    "guaranteedBalanceFQT": "string",
    "currentLesseeRS": "string",
    "accountRS": "string",
    "lessorsRS": [
      "string"
    ],
    "name": "string",
    "description": "string",
    "effectiveBalanceFXT": "string",
    "account": "string",
    "currentLeasingHeightFrom": 0,
    "lastBlock": "string"
  }
}

getAllPhasingOnlyControls

Get All Phasing Only Controls

GET

https://ardr.nownodes.io/nxt

Retrieve all accounts subject to phasing control with their respective restrictions.

Parameters

requestTypestringrequiredquery

firstIndexintegerquery

lastIndexintegerquery

requireBlockstringquery

requireLastBlockstringquery

Response

200OK

Phasing only controls information

400Bad Request

Bad Request

401Unauthorized

Unauthorized — Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Get All Phasing Only Controls

curl -X GET 'https://ardr.nownodes.io/nxt'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ardr.nownodes.io/nxt')
data = response.json()

200

{
  "phasingOnlyControls": [
    {
      "minDuration": 0,
      "votingModel": 0,
      "minBalance": "string",
      "accountRS": "string",
      "quorum": "string",
      "maxFees": "string",
      "whitelist": [
        {
          "whitelistedRS": "string",
          "whitelisted": "string"
        }
      ],
      "minBalanceModel": 0,
      "account": "string",
      "maxDuration": 0
    }
  ],
  "requestProcessingTime": 0
}

getPhasingOnlyControl

Get Phasing Only Control

GET

https://ardr.nownodes.io/nxt

Retrieve phasing control with their respective restrictions for a specific account.

Parameters

requestTypestringrequiredquery

accountstringrequiredquery

requireBlockstringquery

requireLastBlockstringquery

Response

200OK

Phasing control information for specific account

400Bad Request

Bad Request

401Unauthorized

Unauthorized — Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Get Phasing Only Control

curl -X GET 'https://ardr.nownodes.io/nxt'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ardr.nownodes.io/nxt')
data = response.json()

200

{
  "account": "string",
  "accountRS": "string",
  "quorum": "string",
  "whitelist": [
    {
      "whitelisted": "string",
      "whitelistedRS": "string"
    }
  ],
  "maxFees": "string",
  "minDuration": 0,
  "maxDuration": 0,
  "votingModel": 0,
  "minBalance": "string",
  "minBalanceModel": 0,
  "holding": "string",
  "requestProcessingTime": 0
}

leaseBalance

Lease Balance

POST

https://ardr.nownodes.io/nxt

Lease the entire guaranteed balance of ARDR to another account, after 1440 confirmations. POST only.

Body

application/json

requestTypestringrequired

chainintegerrequired

periodintegerrequired

recipientstringrequired

recipientPublicKeystring

secretPhrasestring

feeNQTstring

deadlineinteger

Response

200OK

Transaction creation response

400Bad Request

Bad Request

401Unauthorized

Unauthorized — Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Lease Balance

curl -X POST 'https://ardr.nownodes.io/nxt' \
  -H 'Content-Type: application/json' \
  -d '{
    "requestType": "leaseBalance",
    "chain": 1,
    "period": 1440,
    "recipient": "ARDOR-4VNQ-RWZC-4WWQ-GVM8S",
    "recipientPublicKey": "string",
    "secretPhrase": "string",
    "feeNQT": "100000000",
    "deadline": 60
  }'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "requestType": "leaseBalance",
      "chain": 1,
      "period": 1440,
      "recipient": "ARDOR-4VNQ-RWZC-4WWQ-GVM8S",
      "recipientPublicKey": "string",
      "secretPhrase": "string",
      "feeNQT": "100000000",
      "deadline": 60
    }),
});

const data = await response.json();

import requests

payload = {
  "requestType": "leaseBalance",
  "chain": 1,
  "period": 1440,
  "recipient": "ARDOR-4VNQ-RWZC-4WWQ-GVM8S",
  "recipientPublicKey": "string",
  "secretPhrase": "string",
  "feeNQT": "100000000",
  "deadline": 60
}

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

Request Body

{
  "requestType": "leaseBalance",
  "chain": 1,
  "period": 1440,
  "recipient": "ARDOR-4VNQ-RWZC-4WWQ-GVM8S",
  "recipientPublicKey": "string",
  "secretPhrase": "string",
  "feeNQT": "100000000",
  "deadline": 60
}

200

{
  "signatureHash": "string",
  "unsignedTransactionBytes": "string",
  "transactionJSON": {
    "senderPublicKey": "string",
    "signature": "string",
    "feeNQT": "string",
    "type": 0,
    "fullHash": "string",
    "version": 0,
    "ecBlockId": "string",
    "signatureHash": "string",
    "attachment": {
      "version.EffectiveBalanceLeasing": 0,
      "period": 0
    },
    "senderRS": "string",
    "subtype": 0,
    "amountNQT": "string",
    "sender": "string",
    "recipientRS": "string",
    "recipient": "string",
    "ecBlockHeight": 0,
    "deadline": 0,
    "transaction": "string",
    "timestamp": 0,
    "height": 0
  },
  "broadcasted": true,
  "requestProcessingTime": 0,
  "transactionBytes": "string",
  "fullHash": "string",
  "transaction": "string"
}

setPhasingOnlyControl

Set Phasing Only Control

POST

https://ardr.nownodes.io/nxt

Sets (or removes) phasing control for a specific account. POST only.

Body

application/json

requestTypestringrequired

chainintegerrequired

controlVotingModelintegerrequired

controlQuoruminteger

controlMinBalanceinteger

controlMinBalanceModelinteger

controlHoldingstring

controlWhitelistedArray<string>

controlMaxFeesstring

controlMinDurationinteger

controlMaxDurationinteger

secretPhrasestring

feeNQTstring

deadlineinteger

Response

200OK

Transaction creation response

400Bad Request

Bad Request

401Unauthorized

Unauthorized — Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Set Phasing Only Control

curl -X POST 'https://ardr.nownodes.io/nxt' \
  -H 'Content-Type: application/json' \
  -d '{
    "requestType": "setPhasingOnlyControl",
    "chain": 2,
    "controlVotingModel": 0,
    "controlQuorum": 1,
    "controlMinBalance": 0,
    "controlMinBalanceModel": 0,
    "controlHolding": "string",
    "controlWhitelisted": [
      "ARDOR-5MYN-AP7M-NKMH-CRQJZ"
    ],
    "controlMaxFees": "string",
    "controlMinDuration": 0,
    "controlMaxDuration": 0,
    "secretPhrase": "string",
    "feeNQT": "100000000",
    "deadline": 60
  }'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "requestType": "setPhasingOnlyControl",
      "chain": 2,
      "controlVotingModel": 0,
      "controlQuorum": 1,
      "controlMinBalance": 0,
      "controlMinBalanceModel": 0,
      "controlHolding": "string",
      "controlWhitelisted": [
        "ARDOR-5MYN-AP7M-NKMH-CRQJZ"
      ],
      "controlMaxFees": "string",
      "controlMinDuration": 0,
      "controlMaxDuration": 0,
      "secretPhrase": "string",
      "feeNQT": "100000000",
      "deadline": 60
    }),
});

const data = await response.json();

import requests

payload = {
  "requestType": "setPhasingOnlyControl",
  "chain": 2,
  "controlVotingModel": 0,
  "controlQuorum": 1,
  "controlMinBalance": 0,
  "controlMinBalanceModel": 0,
  "controlHolding": "string",
  "controlWhitelisted": [
    "ARDOR-5MYN-AP7M-NKMH-CRQJZ"
  ],
  "controlMaxFees": "string",
  "controlMinDuration": 0,
  "controlMaxDuration": 0,
  "secretPhrase": "string",
  "feeNQT": "100000000",
  "deadline": 60
}

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

Request Body

{
  "requestType": "setPhasingOnlyControl",
  "chain": 2,
  "controlVotingModel": 0,
  "controlQuorum": 1,
  "controlMinBalance": 0,
  "controlMinBalanceModel": 0,
  "controlHolding": "string",
  "controlWhitelisted": [
    "ARDOR-5MYN-AP7M-NKMH-CRQJZ"
  ],
  "controlMaxFees": "string",
  "controlMinDuration": 0,
  "controlMaxDuration": 0,
  "secretPhrase": "string",
  "feeNQT": "100000000",
  "deadline": 60
}

200

{
  "signatureHash": "string",
  "transactionJSON": {
    "senderPublicKey": "string",
    "chain": 0,
    "signature": "string",
    "feeNQT": "string",
    "type": 0,
    "fullHash": "string",
    "version": 0,
    "phased": true,
    "ecBlockId": "string",
    "signatureHash": "string",
    "attachment": {
      "version.SetPhasingOnly": 0,
      "controlMaxFees": "string",
      "controlMinDuration": 0,
      "controlMaxDuration": 0,
      "phasingControlParams": {
        "phasingHolding": "string",
        "phasingQuorum": 0,
        "phasingWhitelist": [
          "string"
        ],
        "phasingMinBalance": 0,
        "phasingMinBalanceModel": 0,
        "phasingVotingModel": 0
      }
    },
    "senderRS": "string",
    "subtype": 0,
    "amountNQT": "string",
    "sender": "string",
    "ecBlockHeight": 0,
    "deadline": 0,
    "transaction": "string",
    "timestamp": 0,
    "height": 0
  },
  "unsignedTransactionBytes": "string",
  "broadcasted": true,
  "requestProcessingTime": 0,
  "transactionBytes": "string",
  "fullHash": "string",
  "transaction": "string"
}

Forging

leaseBalance

Lease the entire guaranteed balance of ARDR to another account, after 1440 confirmations

POST

https://ardr.nownodes.io/nxt

Body

application/json

jsonrpcstringrequired

methodstringrequired

paramsobjectrequired

Show child attributes

requestTypestring

periodinteger

The lease period (in number of blocks, 1440 minimum)

recipientstring

The lessee (recipient) account

recipientPublicKeystring

The public key of the lessee (recipient) account

idintegerrequired

Response

200OK

Balance leased successfully

400Bad Request

Bad Request

401Unauthorized

Unauthorized — Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Lease the entire guaranteed balance of ARDR to another account, after 1440 confirmations

curl -X POST 'https://ardr.nownodes.io/nxt' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "leaseBalance",
    "params": {
      "requestType": "leaseBalance",
      "period": 0,
      "recipient": "string",
      "recipientPublicKey": "string"
    },
    "id": 1
  }'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "leaseBalance",
      "params": {
        "requestType": "leaseBalance",
        "period": 0,
        "recipient": "string",
        "recipientPublicKey": "string"
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "leaseBalance",
  "params": {
    "requestType": "leaseBalance",
    "period": 0,
    "recipient": "string",
    "recipientPublicKey": "string"
  },
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "leaseBalance",
  "params": {
    "requestType": "leaseBalance",
    "period": 0,
    "recipient": "string",
    "recipientPublicKey": "string"
  },
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "signatureHash": "string",
    "unsignedTransactionBytes": "string",
    "transactionJSON": {
      "senderPublicKey": "string",
      "signature": "string",
      "feeNQT": "string",
      "type": 0,
      "fullHash": "string",
      "version": 0,
      "ecBlockId": "string",
      "signatureHash": "string",
      "attachment": {
        "version.EffectiveBalanceLeasing": 0,
        "period": 0
      },
      "senderRS": "string",
      "subtype": 0,
      "amountNQT": "string",
      "sender": "string",
      "recipientRS": "string",
      "recipient": "string",
      "ecBlockHeight": 0,
      "deadline": 0,
      "transaction": "string",
      "timestamp": 0,
      "height": 0
    },
    "broadcasted": true,
    "requestProcessingTime": 0,
    "transactionBytes": "string",
    "fullHash": "string",
    "transaction": "string"
  }
}

addBundlingRule

Add a bundling rule to an account bundler

POST

https://ardr.nownodes.io/nxt

Body

application/json

jsonrpcstringrequired

methodstringrequired

paramsobjectrequired

Show child attributes

requestTypestring

chaininteger

The child chain related to the operation (eg 2 for Ignis)

minRateNQTPerFXTstring

The minimum rate in chain NQT per ARDR NQT accepted by the bundler

totalFeesLimitFQTstring

The maximum amount of ARDR NQT to be paid in total by the bundler

overpayFQTPerFXTstring

An additional factor of the Ardor fee to pay in case of competing bundlers

feeCalculatorNamestring

A bundling rule for filtering

filterArray<string>

Filter or filters to be applied (PersonalBundler, PropertyBundler, AssetBundler, CurrencyBundler, PurchaseBundler or QuotaBundler)

idintegerrequired

Response

200OK

Bundling rule added successfully

400Bad Request

Bad Request

401Unauthorized

Unauthorized — Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Add a bundling rule to an account bundler

curl -X POST 'https://ardr.nownodes.io/nxt' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "addBundlingRule",
    "params": {
      "requestType": "addBundlingRule",
      "chain": 0,
      "minRateNQTPerFXT": "string",
      "totalFeesLimitFQT": "string",
      "overpayFQTPerFXT": "string",
      "feeCalculatorName": "string",
      "filter": [
        "string"
      ]
    },
    "id": 1
  }'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "addBundlingRule",
      "params": {
        "requestType": "addBundlingRule",
        "chain": 0,
        "minRateNQTPerFXT": "string",
        "totalFeesLimitFQT": "string",
        "overpayFQTPerFXT": "string",
        "feeCalculatorName": "string",
        "filter": [
          "string"
        ]
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "addBundlingRule",
  "params": {
    "requestType": "addBundlingRule",
    "chain": 0,
    "minRateNQTPerFXT": "string",
    "totalFeesLimitFQT": "string",
    "overpayFQTPerFXT": "string",
    "feeCalculatorName": "string",
    "filter": [
      "string"
    ]
  },
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "addBundlingRule",
  "params": {
    "requestType": "addBundlingRule",
    "chain": 0,
    "minRateNQTPerFXT": "string",
    "totalFeesLimitFQT": "string",
    "overpayFQTPerFXT": "string",
    "feeCalculatorName": "string",
    "filter": [
      "string"
    ]
  },
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "totalFeesLimitFQT": "string",
    "currentTotalFeesFQT": "string",
    "chain": 0,
    "announcedMinRateNQTPerFXT": "string",
    "bundler": "string",
    "bundlingRules": [
      {
        "minRateNQTPerFXT": "string",
        "feeCalculatorName": "string",
        "filters": [
          {
            "name": "string"
          }
        ]
      }
    ],
    "requestProcessingTime": 0,
    "bundlerRS": "string"
  }
}

blacklistBundler

Blacklist a specific bundler

POST

https://ardr.nownodes.io/nxt

Body

application/json

jsonrpcstringrequired

methodstringrequired

paramsobjectrequired

Show child attributes

requestTypestring

accountstring

The account to blacklist bundling

adminPasswordstring

The admin password

idintegerrequired

Response

200OK

Bundler blacklisted successfully

400Bad Request

Bad Request

401Unauthorized

Unauthorized — Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Blacklist a specific bundler

curl -X POST 'https://ardr.nownodes.io/nxt' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "blacklistBundler",
    "params": {
      "requestType": "blacklistBundler",
      "account": "string",
      "adminPassword": "string"
    },
    "id": 1
  }'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "blacklistBundler",
      "params": {
        "requestType": "blacklistBundler",
        "account": "string",
        "adminPassword": "string"
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "blacklistBundler",
  "params": {
    "requestType": "blacklistBundler",
    "account": "string",
    "adminPassword": "string"
  },
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "blacklistBundler",
  "params": {
    "requestType": "blacklistBundler",
    "account": "string",
    "adminPassword": "string"
  },
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "done": true,
    "requestProcessingTime": 0
  }
}

bundleTransactions

Bundle unconfirmed transactions

POST

https://ardr.nownodes.io/nxt

Body

application/json

jsonrpcstringrequired

methodstringrequired

paramsobjectrequired

Show child attributes

requestTypestring

chaininteger

The chain related to the operation. For bundling transactions it is a must to select chain 1 = ARDOR

transactionFullHashArray<string>

The transaction full hash of the transaction(s) to be bundled

feeNQTstring

The fee in chain NQT

feeRateNQTPerFXTstring

The fee to be paid to bundle the child chain block

minBundlerBalanceFXTstring

The minimum bundler ARDR balance

idintegerrequired

Response

200OK

Transactions bundled successfully

400Bad Request

Bad Request

401Unauthorized

Unauthorized — Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Bundle unconfirmed transactions

curl -X POST 'https://ardr.nownodes.io/nxt' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "bundleTransactions",
    "params": {
      "requestType": "bundleTransactions",
      "chain": 0,
      "transactionFullHash": [
        "string"
      ],
      "feeNQT": "string",
      "feeRateNQTPerFXT": "string",
      "minBundlerBalanceFXT": "string"
    },
    "id": 1
  }'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "bundleTransactions",
      "params": {
        "requestType": "bundleTransactions",
        "chain": 0,
        "transactionFullHash": [
          "string"
        ],
        "feeNQT": "string",
        "feeRateNQTPerFXT": "string",
        "minBundlerBalanceFXT": "string"
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "bundleTransactions",
  "params": {
    "requestType": "bundleTransactions",
    "chain": 0,
    "transactionFullHash": [
      "string"
    ],
    "feeNQT": "string",
    "feeRateNQTPerFXT": "string",
    "minBundlerBalanceFXT": "string"
  },
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "bundleTransactions",
  "params": {
    "requestType": "bundleTransactions",
    "chain": 0,
    "transactionFullHash": [
      "string"
    ],
    "feeNQT": "string",
    "feeRateNQTPerFXT": "string",
    "minBundlerBalanceFXT": "string"
  },
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "bundled": true,
    "minimumFeeFQT": "string",
    "signatureHash": "string",
    "transactionJSON": {
      "senderPublicKey": "string",
      "chain": 0,
      "signature": "string",
      "feeNQT": "string",
      "type": 0,
      "fullHash": "string",
      "version": 0,
      "phased": true,
      "ecBlockId": "string",
      "signatureHash": "string",
      "attachment": {
        "version.ChildChainBlock": 0,
        "chain": 0,
        "childTransactionFullHashes": [
          "string"
        ],
        "hash": "string"
      },
      "senderRS": "string",
      "subtype": 0,
      "amountNQT": "string",
      "sender": "string",
      "ecBlockHeight": 0,
      "deadline": 0,
      "transaction": "string",
      "timestamp": 0,
      "height": 0
    },
    "unsignedTransactionBytes": "string",
    "broadcasted": true,
    "requestProcessingTime": 0,
    "transactionBytes": "string",
    "fullHash": "string"
  }
}

getAllBundlersRates

Check all bundler rates ordered by chain

POST

https://ardr.nownodes.io/nxt

Body

application/json

jsonrpcstringrequired

methodstringrequired

paramsobjectrequired

Show child attributes

requestTypestring

minBundlerBalanceFXTstring

For filtering based on the minimum bundler balance FXT

accountstring

The account to stop bundling

idintegerrequired

Response

200OK

All bundler rates information

400Bad Request

Bad Request

401Unauthorized

Unauthorized — Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Check all bundler rates ordered by chain

curl -X POST 'https://ardr.nownodes.io/nxt' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "getAllBundlersRates",
    "params": {
      "requestType": "getAllBundlersRates",
      "minBundlerBalanceFXT": "string",
      "account": "string"
    },
    "id": 1
  }'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "getAllBundlersRates",
      "params": {
        "requestType": "getAllBundlersRates",
        "minBundlerBalanceFXT": "string",
        "account": "string"
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "getAllBundlersRates",
  "params": {
    "requestType": "getAllBundlersRates",
    "minBundlerBalanceFXT": "string",
    "account": "string"
  },
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "getAllBundlersRates",
  "params": {
    "requestType": "getAllBundlersRates",
    "minBundlerBalanceFXT": "string",
    "account": "string"
  },
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "rates": [
      {
        "chain": 0,
        "rates": [
          {
            "minRateNQTPerFXT": "string",
            "currentFeeLimitFQT": "string",
            "accountRS": "string",
            "account": "string"
          }
        ]
      }
    ],
    "requestProcessingTime": 0
  }
}

getBundlers

Get bundlers running

POST

https://ardr.nownodes.io/nxt

Body

application/json

jsonrpcstringrequired

methodstringrequired

paramsobjectrequired

Show child attributes

requestTypestring

chaininteger

The child chain related to the operation (eg 2 for Ignis)

accountstring

The account to stop bundling

adminPasswordstring

The admin password

secretPhrasestring

The secret passphrase of the account

privateKeystring

The privateKey (hex) of the derived account

idintegerrequired

Response

200OK

Bundlers information

400Bad Request

Bad Request

401Unauthorized

Unauthorized — Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Get bundlers running

curl -X POST 'https://ardr.nownodes.io/nxt' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "getBundlers",
    "params": {
      "requestType": "getBundlers",
      "chain": 0,
      "account": "string",
      "adminPassword": "string",
      "secretPhrase": "string",
      "privateKey": "string"
    },
    "id": 1
  }'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "getBundlers",
      "params": {
        "requestType": "getBundlers",
        "chain": 0,
        "account": "string",
        "adminPassword": "string",
        "secretPhrase": "string",
        "privateKey": "string"
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "getBundlers",
  "params": {
    "requestType": "getBundlers",
    "chain": 0,
    "account": "string",
    "adminPassword": "string",
    "secretPhrase": "string",
    "privateKey": "string"
  },
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "getBundlers",
  "params": {
    "requestType": "getBundlers",
    "chain": 0,
    "account": "string",
    "adminPassword": "string",
    "secretPhrase": "string",
    "privateKey": "string"
  },
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "bundlers": [
      {
        "totalFeesLimitFQT": "string",
        "currentTotalFeesFQT": "string",
        "minimumRateNQTPerFXT": "string",
        "overpayFQTPerFXT": "string",
        "chain": 0,
        "announcedMinRateNQTPerFXT": "string",
        "bundler": "string",
        "bundlingRules": [
          {
            "minRateNQTPerFXT": "string",
            "feeCalculatorName": "string"
          }
        ],
        "bundlerRS": "string"
      }
    ],
    "requestProcessingTime": 0
  }
}

getBundlersRates

Get the most competitive rates per chain

POST

https://ardr.nownodes.io/nxt

Body

application/json

jsonrpcstringrequired

methodstringrequired

paramsobjectrequired

Show child attributes

requestTypestring

minBundlerBalanceFXTstring

For filtering based on the minimum bundler balance FXT

idintegerrequired

Response

200OK

Most competitive bundler rates per chain

400Bad Request

Bad Request

401Unauthorized

Unauthorized — Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Get the most competitive rates per chain

curl -X POST 'https://ardr.nownodes.io/nxt' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "getBundlersRates",
    "params": {
      "requestType": "getBundlersRates",
      "minBundlerBalanceFXT": "string"
    },
    "id": 1
  }'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "getBundlersRates",
      "params": {
        "requestType": "getBundlersRates",
        "minBundlerBalanceFXT": "string"
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "getBundlersRates",
  "params": {
    "requestType": "getBundlersRates",
    "minBundlerBalanceFXT": "string"
  },
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "getBundlersRates",
  "params": {
    "requestType": "getBundlersRates",
    "minBundlerBalanceFXT": "string"
  },
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "rates": [
      {
        "minRateNQTPerFXT": "string",
        "currentFeeLimitFQT": "string",
        "chain": 0,
        "accountRS": "string",
        "account": "string"
      }
    ],
    "requestProcessingTime": 0
  }
}

getGuaranteedBalance

Get the balance of an account in ARDR that is confirmed at least a specified number of times

POST

https://ardr.nownodes.io/nxt

Body

application/json

jsonrpcstringrequired

methodstringrequired

paramsobjectrequired

Show child attributes

requestTypestring

accountstring

The account ID

numberOfConfirmationsinteger

The minimum number of confirmations for a transaction to be included in the guaranteed balance

requireBlockstring

The block ID of a block that must be present in the blockchain during execution

requireLastBlockstring

The block ID of a block that must be last in the blockchain during execution

idintegerrequired

Response

200OK

Guaranteed balance information

400Bad Request

Bad Request

401Unauthorized

Unauthorized — Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Get the balance of an account in ARDR that is confirmed at least a specified number of times

curl -X POST 'https://ardr.nownodes.io/nxt' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "getGuaranteedBalance",
    "params": {
      "requestType": "getGuaranteedBalance",
      "account": "string",
      "numberOfConfirmations": 0,
      "requireBlock": "string",
      "requireLastBlock": "string"
    },
    "id": 1
  }'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "getGuaranteedBalance",
      "params": {
        "requestType": "getGuaranteedBalance",
        "account": "string",
        "numberOfConfirmations": 0,
        "requireBlock": "string",
        "requireLastBlock": "string"
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "getGuaranteedBalance",
  "params": {
    "requestType": "getGuaranteedBalance",
    "account": "string",
    "numberOfConfirmations": 0,
    "requireBlock": "string",
    "requireLastBlock": "string"
  },
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "getGuaranteedBalance",
  "params": {
    "requestType": "getGuaranteedBalance",
    "account": "string",
    "numberOfConfirmations": 0,
    "requireBlock": "string",
    "requireLastBlock": "string"
  },
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "guaranteedBalanceNQT": "string",
    "lastBlock": "string",
    "requestProcessingTime": 0
  }
}

getNextBlockGenerators

Returns the next block generators ordered by hit time

POST

https://ardr.nownodes.io/nxt

Body

application/json

jsonrpcstringrequired

methodstringrequired

paramsobjectrequired

Show child attributes

requestTypestring

limitinteger

The number of next block generators to display

idintegerrequired

Response

200OK

Next block generators information

400Bad Request

Bad Request

401Unauthorized

Unauthorized — Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Returns the next block generators ordered by hit time

curl -X POST 'https://ardr.nownodes.io/nxt' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "getNextBlockGenerators",
    "params": {
      "requestType": "getNextBlockGenerators",
      "limit": 0
    },
    "id": 1
  }'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "getNextBlockGenerators",
      "params": {
        "requestType": "getNextBlockGenerators",
        "limit": 0
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "getNextBlockGenerators",
  "params": {
    "requestType": "getNextBlockGenerators",
    "limit": 0
  },
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "getNextBlockGenerators",
  "params": {
    "requestType": "getNextBlockGenerators",
    "limit": 0
  },
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "activeCount": 0,
    "lastBlock": "string",
    "generators": [
      {
        "effectiveBalanceFXT": 0,
        "accountRS": "string",
        "deadline": 0,
        "account": "string",
        "hitTime": 0
      }
    ],
    "requestProcessingTime": 0,
    "timestamp": 0,
    "height": 0
  }
}

startBundler

Start a bundler with an account, or check to see if an account is bundling

POST

https://ardr.nownodes.io/nxt

Body

application/json

jsonrpcstringrequired

methodstringrequired

paramsobjectrequired

Show child attributes

requestTypestring

chaininteger

The child chain related to the operation (eg 2 for Ignis)

minRateNQTPerFXTstring

The minimum rate in chain NQT per ARDR NQT accepted by the bundler

totalFeesLimitFQTstring

The maximum amount of ARDR NQT to be paid in total by the bundler

overpayFQTPerFXTstring

An additional factor of the Ardor fee to pay in case of competing bundlers

feeCalculatorNamestring

A bundling rule for filtering

filterstring

A filter to be applied

bundlingRulesJSONstring

A list of bundling rules as a Json format

secretPhrasestring

The secret passphrase of the account

privateKeystring

The privateKey (hex) of the derived account

idintegerrequired

Response

200OK

Bundler started successfully

400Bad Request

Bad Request

401Unauthorized

Unauthorized — Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Start a bundler with an account, or check to see if an account is bundling

curl -X POST 'https://ardr.nownodes.io/nxt' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "startBundler",
    "params": {
      "requestType": "startBundler",
      "chain": 0,
      "minRateNQTPerFXT": "string",
      "totalFeesLimitFQT": "string",
      "overpayFQTPerFXT": "string",
      "feeCalculatorName": "string",
      "filter": "string",
      "bundlingRulesJSON": "string",
      "secretPhrase": "string",
      "privateKey": "string"
    },
    "id": 1
  }'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "startBundler",
      "params": {
        "requestType": "startBundler",
        "chain": 0,
        "minRateNQTPerFXT": "string",
        "totalFeesLimitFQT": "string",
        "overpayFQTPerFXT": "string",
        "feeCalculatorName": "string",
        "filter": "string",
        "bundlingRulesJSON": "string",
        "secretPhrase": "string",
        "privateKey": "string"
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "startBundler",
  "params": {
    "requestType": "startBundler",
    "chain": 0,
    "minRateNQTPerFXT": "string",
    "totalFeesLimitFQT": "string",
    "overpayFQTPerFXT": "string",
    "feeCalculatorName": "string",
    "filter": "string",
    "bundlingRulesJSON": "string",
    "secretPhrase": "string",
    "privateKey": "string"
  },
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "startBundler",
  "params": {
    "requestType": "startBundler",
    "chain": 0,
    "minRateNQTPerFXT": "string",
    "totalFeesLimitFQT": "string",
    "overpayFQTPerFXT": "string",
    "feeCalculatorName": "string",
    "filter": "string",
    "bundlingRulesJSON": "string",
    "secretPhrase": "string",
    "privateKey": "string"
  },
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "totalFeesLimitFQT": "string",
    "currentTotalFeesFQT": "string",
    "minimumRateNQTPerFXT": "string",
    "overpayFQTPerFXT": "string",
    "chain": 0,
    "announcedMinRateNQTPerFXT": "string",
    "bundler": "string",
    "bundlingRules": [
      {
        "minRateNQTPerFXT": "string",
        "feeCalculatorName": "string"
      }
    ],
    "bundlerRS": "string",
    "requestProcessingTime": 0
  }
}

startForging

Start or stop forging with an account, or check to see if an account is forging

POST

https://ardr.nownodes.io/nxt

Body

application/json

jsonrpcstringrequired

methodstringstartForgingstopForginggetForgingrequired

paramsobjectrequired

Show child attributes

requestTypestringstartForgingstopForginggetForging

secretPhrasestring

The secret passphrase of the account

privateKeystring

The privateKey (hex) of the derived account

idintegerrequired

Response

200OK

Forging operation completed successfully

400Bad Request

Bad Request

401Unauthorized

Unauthorized — Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Start or stop forging with an account, or check to see if an account is forging

curl -X POST 'https://ardr.nownodes.io/nxt' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "startForging",
    "params": {
      "requestType": "startForging",
      "secretPhrase": "string",
      "privateKey": "string"
    },
    "id": 1
  }'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "startForging",
      "params": {
        "requestType": "startForging",
        "secretPhrase": "string",
        "privateKey": "string"
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "startForging",
  "params": {
    "requestType": "startForging",
    "secretPhrase": "string",
    "privateKey": "string"
  },
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "startForging",
  "params": {
    "requestType": "startForging",
    "secretPhrase": "string",
    "privateKey": "string"
  },
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "deadline": 0,
    "hitTime": 0,
    "remaining": 0,
    "foundAndStopped": true,
    "account": "string",
    "accountRS": "string",
    "requestProcessingTime": 0
  }
}

stopForging

Start or stop forging with an account, or check to see if an account is forging

POST

https://ardr.nownodes.io/nxt

Body

application/json

jsonrpcstringrequired

methodstringstartForgingstopForginggetForgingrequired

paramsobjectrequired

Show child attributes

requestTypestringstartForgingstopForginggetForging

secretPhrasestring

The secret passphrase of the account

privateKeystring

The privateKey (hex) of the derived account

idintegerrequired

Response

200OK

Forging operation completed successfully

400Bad Request

Bad Request

401Unauthorized

Unauthorized — Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Start or stop forging with an account, or check to see if an account is forging

curl -X POST 'https://ardr.nownodes.io/nxt' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "startForging",
    "params": {
      "requestType": "startForging",
      "secretPhrase": "string",
      "privateKey": "string"
    },
    "id": 1
  }'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "startForging",
      "params": {
        "requestType": "startForging",
        "secretPhrase": "string",
        "privateKey": "string"
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "startForging",
  "params": {
    "requestType": "startForging",
    "secretPhrase": "string",
    "privateKey": "string"
  },
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "startForging",
  "params": {
    "requestType": "startForging",
    "secretPhrase": "string",
    "privateKey": "string"
  },
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "deadline": 0,
    "hitTime": 0,
    "remaining": 0,
    "foundAndStopped": true,
    "account": "string",
    "accountRS": "string",
    "requestProcessingTime": 0
  }
}

getForging

Start or stop forging with an account, or check to see if an account is forging

POST

https://ardr.nownodes.io/nxt

Body

application/json

jsonrpcstringrequired

methodstringstartForgingstopForginggetForgingrequired

paramsobjectrequired

Show child attributes

requestTypestringstartForgingstopForginggetForging

secretPhrasestring

The secret passphrase of the account

privateKeystring

The privateKey (hex) of the derived account

idintegerrequired

Response

200OK

Forging operation completed successfully

400Bad Request

Bad Request

401Unauthorized

Unauthorized — Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Start or stop forging with an account, or check to see if an account is forging

curl -X POST 'https://ardr.nownodes.io/nxt' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "startForging",
    "params": {
      "requestType": "startForging",
      "secretPhrase": "string",
      "privateKey": "string"
    },
    "id": 1
  }'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "startForging",
      "params": {
        "requestType": "startForging",
        "secretPhrase": "string",
        "privateKey": "string"
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "startForging",
  "params": {
    "requestType": "startForging",
    "secretPhrase": "string",
    "privateKey": "string"
  },
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "startForging",
  "params": {
    "requestType": "startForging",
    "secretPhrase": "string",
    "privateKey": "string"
  },
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "deadline": 0,
    "hitTime": 0,
    "remaining": 0,
    "foundAndStopped": true,
    "account": "string",
    "accountRS": "string",
    "requestProcessingTime": 0
  }
}

stopBundler

Stop a bundler with an account

POST

https://ardr.nownodes.io/nxt

Body

application/json

jsonrpcstringrequired

methodstringrequired

paramsobjectrequired

Show child attributes

requestTypestring

chaininteger

The child chain related to the operation (eg 2 for Ignis)

accountstring

The account to stop bundling

adminPasswordstring

The admin password

secretPhrasestring

The secret passphrase of the account

privateKeystring

The privateKey (hex) of the derived account

idintegerrequired

Response

200OK

Bundler stopped successfully

400Bad Request

Bad Request

401Unauthorized

Unauthorized — Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Stop a bundler with an account

curl -X POST 'https://ardr.nownodes.io/nxt' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "stopBundler",
    "params": {
      "requestType": "stopBundler",
      "chain": 0,
      "account": "string",
      "adminPassword": "string",
      "secretPhrase": "string",
      "privateKey": "string"
    },
    "id": 1
  }'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "stopBundler",
      "params": {
        "requestType": "stopBundler",
        "chain": 0,
        "account": "string",
        "adminPassword": "string",
        "secretPhrase": "string",
        "privateKey": "string"
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "stopBundler",
  "params": {
    "requestType": "stopBundler",
    "chain": 0,
    "account": "string",
    "adminPassword": "string",
    "secretPhrase": "string",
    "privateKey": "string"
  },
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "stopBundler",
  "params": {
    "requestType": "stopBundler",
    "chain": 0,
    "account": "string",
    "adminPassword": "string",
    "secretPhrase": "string",
    "privateKey": "string"
  },
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "stoppedChildChainBundlers": true,
    "requestProcessingTime": 0
  }
}

Aliases

deleteAlias

Delete an alias given an alias ID or name

POST

https://ardr.nownodes.io/nxt

Parameters

requestTypestringrequiredquery

chainintegerrequiredquery

aliasstringquery

aliasNamestringquery

Response

200OK

Successful alias deletion

400Bad Request

Bad Request - Invalid parameters

401Unauthorized

Unauthorized - Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Delete an alias given an alias ID or name

curl -X POST 'https://ardr.nownodes.io/nxt'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
});

const data = await response.json();

import requests

response = requests.post('https://ardr.nownodes.io/nxt')
data = response.json()

200

{
  "signatureHash": "a6e68daed99c1015dd12546c042466612b52a9f5193d8513f7f12684aba5bf1d",
  "unsignedTransactionBytes": "011809e60c023c0010f09c34f225d425306e5be55a49469081...",
  "transactionJSON": {
    "senderPublicKey": "10f09c34f225d425306e5be55a4946908156072afbead4d574a512d7e086ef5c",
    "chain": 2,
    "signature": "a5088bc6469e528d884e7fd3c49afeefc8656dd59c9fa5ffeab2a17b465f6d03e77...",
    "feeNQT": "100000000",
    "type": 1,
    "fullHash": "63afc769e677b6210617ff7a9f5be2d7fe1aea7e46ccad968017d28df578fabf",
    "version": 1,
    "ecBlockId": "17895923487075501156",
    "signatureHash": "a6e68daed99c1015dd12546c042466612b52a9f5193d8513f7f12684aba5bf1d",
    "attachment": {
      "version.AliasDelete": 1,
      "alias": "mystical"
    },
    "senderRS": "ARDOR-4VDY-LNVT-LMAY-FMCKA",
    "subtype": 8,
    "amountNQT": "0",
    "sender": "15295723609781267838",
    "ecBlockHeight": 161137,
    "deadline": 60,
    "transaction": "2429260880513838947",
    "timestamp": 34399753,
    "height": 2147483647
  },
  "broadcasted": true,
  "requestProcessingTime": 52,
  "transactionBytes": "011809e60c023c0010f09c34f225d425306e5be55a4946908156072...",
  "transaction": "2429260880513838947"
}

getAlias

Get information about a given alias

GET

https://ardr.nownodes.io/nxt

Parameters

requestTypestringrequiredquery

chainintegerrequiredquery

aliasstringquery

aliasNamestringquery

requireBlockstringquery

requireLastBlockstringquery

Response

200OK

Successful alias information retrieval

400Bad Request

Bad Request - Invalid parameters

401Unauthorized

Unauthorized - Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Get information about a given alias

curl -X GET 'https://ardr.nownodes.io/nxt'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ardr.nownodes.io/nxt')
data = response.json()

200

{
  "timestamp": 2409343,
  "aliasName": "google",
  "account": "5629477397208681336",
  "accountRS": "ARDOR-FLVS-VRBV-LDPD-6DZ9W",
  "aliasURI": "http://google.com",
  "alias": "15515279700680480368",
  "priceNQT": "string",
  "buyer": "string",
  "lastBlock": "string",
  "requestProcessingTime": 1
}

getAliasCount

Get the number of aliases owned by an account given the account ID

GET

https://ardr.nownodes.io/nxt

Parameters

requestTypestringrequiredquery

chainintegerrequiredquery

accountstringrequiredquery

requireBlockstringquery

requireLastBlockstringquery

Response

200OK

Successful alias count retrieval

400Bad Request

Bad Request - Invalid parameters

401Unauthorized

Unauthorized - Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Get the number of aliases owned by an account given the account ID

curl -X GET 'https://ardr.nownodes.io/nxt'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ardr.nownodes.io/nxt')
data = response.json()

200

{
  "numberOfAliases": 200,
  "lastBlock": "string",
  "requestProcessingTime": 2
}

sellAlias

Sell an alias to another account

GET

https://ardr.nownodes.io/nxt

Parameters

chainintegerrequiredquery

requestTypestringrequiredquery

secretPhrasestringrequiredquery

aliasNamestringrequiredquery

priceNQTstringrequiredquery

recipientstringrequiredquery

feeNQTstringrequiredquery

deadlineintegerrequiredquery

Response

200OK

Successful alias sale transaction

400Bad Request

Bad Request - Invalid parameters

401Unauthorized

Unauthorized - Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Sell an alias to another account

curl -X GET 'https://ardr.nownodes.io/nxt'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ardr.nownodes.io/nxt')
data = response.json()

200

{
  "signatureHash": "d6f026cd8a883b5b6ff78a7d0121e4847eb6744b02757427de6d7ca0bf304226",
  "unsignedTransactionBytes": "01166e01d4013c0057fb6f3a958e320bb49c4e81b4c2cf28b9f25d086c143...",
  "transactionJSON": {
    "senderPublicKey": "57fb6f3a958e320bb49c4e81b4c2cf28b9f25d086c143b473beec228f79ff93c",
    "chain": 2,
    "signature": "2041afc1687da2693ba092e33a84f665ad461e3b6762c18af61778261bc7e...",
    "feeNQT": "100000000",
    "type": 1,
    "fullHash": "14a3eeb17cd4082db287259a768d32065d4cf5397ed6053fffa25e92a8a66ac7",
    "version": 1,
    "ecBlockId": "1612829598027150491",
    "signatureHash": "d6f026cd8a883b5b6ff78a7d0121e4847eb6744b02757427de6d7ca0bf304226",
    "attachment": {
      "alias": "nextus",
      "priceNQT": "5",
      "version.AliasSell": 1
    },
    "senderRS": "ARDOR-L6FM-89WK-VK8P-FCRBB",
    "subtype": 6,
    "amountNQT": "0",
    "sender": "15323192282528158131",
    "recipientRS": "ARDOR-4VNQ-RWZC-4WWQ-GVM8S",
    "recipient": "17013046603665206934",
    "ecBlockHeight": 284050,
    "deadline": 60,
    "transaction": "3245077163546682132",
    "timestamp": 30671214,
    "height": 2147483647
  },
  "broadcasted": true,
  "requestProcessingTime": 8515,
  "transactionBytes": "01166e01d4013c0057fb6f3a958e320bb49c4e81b4c2cf28b9f25d086c143...",
  "fullHash": "14a3eeb17cd4082db287259a768d32065d4cf5397ed6053fffa25e92a8a66ac7",
  "transaction": "3245077163546682132"
}

setAlias

Create and/or assign an alias

POST

https://ardr.nownodes.io/nxt

Parameters

requestTypestringrequiredquery

chainintegerrequiredquery

secretPhrasestringrequiredquery

aliasNamestringrequiredquery

aliasURIstringquery

feeNQTstringrequiredquery

deadlineintegerrequiredquery

Response

200OK

Successful alias creation/assignment

400Bad Request

Bad Request - Invalid parameters

401Unauthorized

Unauthorized - Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Create and/or assign an alias

curl -X POST 'https://ardr.nownodes.io/nxt'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
});

const data = await response.json();

import requests

response = requests.post('https://ardr.nownodes.io/nxt')
data = response.json()

200

{
  "signatureHash": "0dc7e07acef27fe86686cfabe2d1bd57c0c038f9465c3fe3d10f67932a97af10",
  "unsignedTransactionBytes": "011135d0d3013c0057fb6f3a958e320bb49c4e81b4c2cf28b9f25d086c143...",
  "transactionJSON": {
    "senderPublicKey": "57fb6f3a958e320bb49c4e81b4c2cf28b9f25d086c143b473beec228f79ff93c",
    "chain": 2,
    "signature": "d92aefbab189b6e61f890c34b06a47e14a1a2b2ce868f77a4591d2067c51d...",
    "feeNQT": "100000000",
    "type": 1,
    "fullHash": "53917acbf44109391609a9bb57832c0d5903301e3d2bd6ffcf45cf893480f5a1",
    "version": 1,
    "ecBlockId": "4181883296304410027",
    "signatureHash": "0dc7e07acef27fe86686cfabe2d1bd57c0c038f9465c3fe3d10f67932a97af10",
    "attachment": {
      "alias": "iwonttellyou",
      "version.AliasAssignment": 1,
      "uri": "acct:ardor-l6fm-89wk-vk8p-fcrbb@nxt"
    },
    "senderRS": "ARDOR-L6FM-89WK-VK8P-FCRBB",
    "subtype": 1,
    "amountNQT": "0",
    "sender": "15323192282528158131",
    "ecBlockHeight": 283939,
    "deadline": 60,
    "transaction": "4109888654593921363",
    "timestamp": 30658613,
    "height": 2147483647
  },
  "broadcasted": true,
  "requestProcessingTime": 8104,
  "transactionBytes": "011135d0d3013c0057fb6f3a958e320bb49c4e81b4c2cf28b9f25d086c143b473...",
  "fullHash": "53917acbf44109391609a9bb57832c0d5903301e3d2bd6ffcf45cf893480f5a1",
  "transaction": "4109888654593921363"
}

Bip 32

deriveAccountFromMasterPublicKey

Derives an account from their serialized master public key

GET

https://ardr.nownodes.io/nxt

Parameters

requestTypestringrequiredquery

serializedMasterPublicKeystringrequiredquery

childIndexintegerrequiredquery

Response

200OK

Successful account derivation

400Bad Request

Bad Request - Invalid parameters

401Unauthorized

Unauthorized - Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Derives an account from their serialized master public key

curl -X GET 'https://ardr.nownodes.io/nxt'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ardr.nownodes.io/nxt')
data = response.json()

200

{
  "accountRS": "ARDOR-6533-8UKV-WPVT-D53RV",
  "publicKey": "fe31a184e24d1f9b6cc5aec7efaa8ca8670f749ccea84af0009e126d67fca76b",
  "requestProcessingTime": 15,
  "account": "13680848485626285089"
}

deriveAccountFromSeed

Derives an account from a seed

GET

https://ardr.nownodes.io/nxt

Parameters

requestTypestringrequiredquery

mnemonicstringrequiredquery

passphrasestringquery

bip32Pathstringrequiredquery

Response

200OK

Successful account derivation from seed

400Bad Request

Bad Request - Invalid parameters

401Unauthorized

Unauthorized - Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Derives an account from a seed

curl -X GET 'https://ardr.nownodes.io/nxt'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ardr.nownodes.io/nxt')
data = response.json()

200

{
  "privateKey": "00f83df3d7237253a3b5c7e3e789b92deb0e12ee449e845695f7190a89d5c342",
  "seed": "216d614810238abd2b482a7b6abdfd2b871b31cabaa3934cd180fa922ed0a636bb85be8db4180a7812d0929a20ee3ea069533e6e2513dc108513f095560a58a3",
  "chainCode": "80985596b59a8cf910ab08e1c31e3d6ef231a619a6053a182d7ce896760a146d",
  "accountRS": "ARDOR-GASH-XEMA-G3MH-7LTBA",
  "bip32Path": "m/44'/16754'/0'/1'/0",
  "masterPublicKey": "95093a0aacdccea7f4bdc58af8c6dc296e3505ce3f6f73cccb7bf28cd92f00e1",
  "publicKey": "de225c3ebc46aacb9124a9e143cceb4b64f5a19d7ccc4a633fc622119f4f3575",
  "requestProcessingTime": 19,
  "privateKeyRight": "b8df48729cd324eb9cde2409b523b015643ee19a6dc52e7688af2ec1c61d6115",
  "account": "6063871408822756111"
}

getLedgerMasterPublicKey

Returns the hardware Ledger master public key

GET

https://ardr.nownodes.io/nxt

It requires the hardware wallet to be connected

Parameters

requestTypestringrequiredquery

bip32Pathstringrequiredquery

Response

200OK

Successful Ledger master public key retrieval

400Bad Request

Bad Request - Invalid parameters

401Unauthorized

Unauthorized - Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Returns the hardware Ledger master public key

curl -X GET 'https://ardr.nownodes.io/nxt'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ardr.nownodes.io/nxt')
data = response.json()

200

{
  "chainCode": "14efba6597718a4a7f5d9bfbd0f7f2177216068d90ced2475a52e06caf82759f",
  "accountRS": "ARDOR-ATW3-48WT-SHPC-2K85M",
  "bip32Path": "m/44'/16754'/0'/1'/0",
  "masterPublicKey": "ee55d3df4b01376561b70a249155cfa8a388740ca8eaa5a8879a070a001bfb14",
  "publicKey": "3e604f4ee11bea4dc8628c8af2215e764ee2e344aa14f4ca11048fa144f8c11c",
  "requestProcessingTime": 3693,
  "account": "688154717139003265"
}

Blocks

getBlock

Get a block object given a block ID or block height

GET

https://ardr.nownodes.io/nxt

Parameters

requestTypestringrequiredquery

blockstringquery

heightintegerquery

timestampintegerquery

includeTransactionsbooleanquery

includeExecutedPhasedbooleanquery

requireBlockstringquery

requireLastBlockstringquery

Response

200OK

Successful block retrieval

400Bad Request

Bad Request - Invalid parameters

401Unauthorized

Unauthorized - Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Get a block object given a block ID or block height

curl -X GET 'https://ardr.nownodes.io/nxt'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ardr.nownodes.io/nxt')
data = response.json()

200

{
  "previousBlockHash": "c0574d7a7b8497373dbead497c2dc7f60fdcfc8c5a9fcb48f7d373acc9bbb099",
  "payloadLength": 1189,
  "generationSignature": "c5098d37267bc71134fc8572a87b4af8727a2e5139d60fe8833fab98af22244a",
  "generator": "11693867635361772359",
  "generatorPublicKey": "fbb72a280228af5c8c74c7c754a290e1539f839553c00bc560cac7bfdb324a7c",
  "baseTarget": "1530224444",
  "payloadHash": "633992be640a593ba04e31ca4028deed70bbf47cff333e2a0372a4e2a4aba205",
  "generatorRS": "ARDOR-TWU9-P3E4-HCDM-CQ9L6",
  "nextBlock": "5937170741469897491",
  "numberOfTransactions": 6,
  "blockSignature": "ff65a82e385c135cf9bd5be0861e9e5d3d3174fbd993e5b7f57935ec4...",
  "transactions": [
    "15184285173972564233"
  ],
  "executedPhasedTransactions": [
    "string"
  ],
  "version": 3,
  "totalFeeFQT": "string",
  "totalFeeNQT": "600000000",
  "previousBlock": "4005816059437078464",
  "cumulativeDifficulty": "10229109959119715",
  "block": "8455642159445842600",
  "height": 275730,
  "timestamp": 29797208,
  "lastBlock": "string",
  "requestProcessingTime": 175
}

getBlockchainStatus

Get the blockchain status

GET

https://ardr.nownodes.io/nxt

Parameters

requestTypestringrequiredquery

Response

200OK

Successful blockchain status retrieval

400Bad Request

Bad Request - Invalid parameters

401Unauthorized

Unauthorized - Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Get the blockchain status

curl -X GET 'https://ardr.nownodes.io/nxt'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ardr.nownodes.io/nxt')
data = response.json()

200

{
  "currentMinRollbackHeight": 362200,
  "numberOfBlocks": 363697,
  "isTestnet": true,
  "includeExpiredPrunable": true,
  "requestProcessingTime": 0,
  "version": "2.1.0e",
  "maxRollback": 800,
  "lastBlock": "4927201194742852793",
  "application": "Ardor",
  "isScanning": false,
  "isDownloading": false,
  "cumulativeDifficulty": "37665721693045685",
  "lastBlockchainFeederHeight": 363492,
  "maxPrunableLifetime": 2147483647,
  "time": 21588850,
  "lastBlockchainFeeder": "107.150.3.13",
  "blockchainState": "UP_TO_DATE",
  "apiProxy": false,
  "correctInvalidFees": false,
  "ledgerTrimKeep": 30000,
  "maxAPIRecords": 100,
  "isLightClient": false,
  "services": [
    "PRUNABLE",
    "API",
    "API_SSL",
    "CORS"
  ]
}

getBlockId

Get a block ID given a block height

GET

https://ardr.nownodes.io/nxt

Parameters

requestTypestringrequiredquery

heightintegerrequiredquery

requireBlockstringquery

requireLastBlockstringquery

Response

200OK

Successful block ID retrieval

400Bad Request

Bad Request - Invalid parameters

401Unauthorized

Unauthorized - Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Get a block ID given a block height

curl -X GET 'https://ardr.nownodes.io/nxt'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ardr.nownodes.io/nxt')
data = response.json()

200

{
  "block": "2680262203532249785",
  "lastBlock": "string",
  "requestProcessingTime": 1
}

getBlocks

Get blocks from the blockchain in reverse block height order

GET

https://ardr.nownodes.io/nxt

Parameters

requestTypestringrequiredquery

timestampintegerquery

firstIndexintegerquery

lastIndexintegerquery

includeTransactionsbooleanquery

includeExecutedPhasedbooleanquery

requireBlockstringquery

requireLastBlockstringquery

Response

200OK

Successful blocks retrieval

400Bad Request

Bad Request - Invalid parameters

401Unauthorized

Unauthorized - Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Get blocks from the blockchain in reverse block height order

curl -X GET 'https://ardr.nownodes.io/nxt'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ardr.nownodes.io/nxt')
data = response.json()

200

{
  "blocks": [
    {
      "previousBlockHash": "f88c75a36317e1795348330cb9a944f33153b517ebdf05d9f3f9a606e997618d",
      "payloadLength": 981,
      "generationSignature": "02f7462b62270c0028c379d838d3a192cf0b782995f3bb1929a5378d26e7e8a9",
      "generator": "2218289317977832095",
      "generatorPublicKey": "98ccf5d5173b13e4c9eab2631372f61ce8ba506db559d73b285073a689872e75",
      "baseTarget": "151761236",
      "payloadHash": "82f8c8ca1f8f2252172ed1e9836d5228432fcb18aecfa7d55a119efcd242321c",
      "generatorRS": "ARDOR-TGNZ-E8VK-69EX-3L9LX",
      "numberOfTransactions": 5,
      "blockSignature": "76a3f7f966256c4985262fb4622190b2b9a19b900f6ce443ab7d581e3176c...",
      "transactions": [
        "10545999940082849455"
      ],
      "version": 3,
      "totalFeeNQT": "500000000",
      "previousBlock": "8782326465060769016",
      "block": "7299310714263322546",
      "height": 281683,
      "timestamp": 30416681,
      "totalAmountNQT": "0",
      "nextBlock": "7299310714263322546"
    }
  ],
  "lastBlock": "string",
  "requestProcessingTime": 2
}

getECBlock

Get Economic Cluster block data

GET

https://ardr.nownodes.io/nxt

Parameters

requestTypestringrequiredquery

timestampintegerquery

requireBlockstringquery

requireLastBlockstringquery

Response

200OK

Successful EC block data retrieval

400Bad Request

Bad Request - Invalid parameters

401Unauthorized

Unauthorized - Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Get Economic Cluster block data

curl -X GET 'https://ardr.nownodes.io/nxt'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ardr.nownodes.io/nxt')
data = response.json()

200

{
  "ecBlockHeight": 281777,
  "ecBlockId": "6565813579609649593",
  "timestamp": 30427868,
  "lastBlock": "string",
  "requestProcessingTime": 2
}

Child Chain Permissions

addAccountPermission

Grants a permission to an account

GET

https://ardr.nownodes.io/nxt

For extended information refer to Child Chain Control

Parameters

requestTypestringrequiredquery

chainintegerrequiredquery

recipientstringrequiredquery

permissionstringrequiredquery

publicKeystringquery

secretPhrasestringrequiredquery

feeNQTstringrequiredquery

deadlineintegerrequiredquery

Response

200OK

Successful account permission addition

400Bad Request

Bad Request - Invalid parameters

401Unauthorized

Unauthorized - Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Grants a permission to an account

curl -X GET 'https://ardr.nownodes.io/nxt'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ardr.nownodes.io/nxt')
data = response.json()

200

{
  "minimumFeeFQT": "1000000",
  "signatureHash": "465c1834e6b970db22392633685d7e5925fd80da4db995e09eb6b239c79eff8a",
  "transactionJSON": {
    "senderPublicKey": "028798b60eb4bbf7ebc974245164fdba476296a7ca6fc29d911c25b34cc8c508",
    "chain": 6,
    "signature": "59826b518355653f9da3e9f9aaa510ae77ffe80bbbf7697e8c074d656ba22408889c046de917b9103d1093acbd0e859c3fa1058e91969299331050f1a3e155ba",
    "feeNQT": "5000000",
    "type": 13,
    "fullHash": "27ad916646077c0b2ebe39b9b3507ed6994ba6290f6b384998952add017e474f",
    "version": 1,
    "fxtTransaction": "0",
    "phased": false,
    "ecBlockId": "7081362564929041377",
    "signatureHash": "465c1834e6b970db22392633685d7e5925fd80da4db995e09eb6b239c79eff8a",
    "attachment": {
      "version.AddPermission": 1,
      "permission": 2
    },
    "senderRS": "ARDOR-GHKP-XWB5-XMZB-CTUE3",
    "subtype": 0,
    "amountNQT": "0",
    "sender": "11579697950237343285",
    "recipientRS": "ARDOR-GHKP-XWB5-XMZB-CTUE3",
    "recipient": "11579697950237343285",
    "ecBlockHeight": 4822380,
    "deadline": 15,
    "timestamp": 76849388,
    "height": 2147483647
  },
  "unsignedTransactionBytes": "050000000d0001eca094040f00028798b60eb4bbf7ebc974245164fdba476296a7ca6fc29d911c25b34cc8c508353e3712ef59b3a00000000000000000404b4c0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006c954900e13358f0bb0d4662000000000102000000000000000000000000000000000000000000000000000000000000000000000000",
  "broadcasted": true,
  "requestProcessingTime": 1847,
  "transactionBytes": "050000000d0001eca094040f00028798b60eb4bbf7ebc974245164fdba476296a7ca6fc29d911c25b34cc8c508353e3712ef59b3a00000000000000000404b4c000000000059826b518355653f9da3e9f9aaa510ae77ffe80bbbf7697e8c074d656ba22408889c046de917b9103d1093acbd0e859c3fa1058e91969299331050f1a3e155ba6c954900e13358f0bb0d4662000000000102000000000000000000000000000000000000000000000000000000000000000000000000",
  "fullHash": "27ad916646077c0b2ebe39b9b3507ed6994ba6290f6b384998952add017e474f"
}

getAccountPermissions

Queries the permissions of an account

GET

https://ardr.nownodes.io/nxt

For extended information refer to Child Chain Control

Parameters

requestTypestringrequiredquery

chainintegerrequiredquery

accountstringrequiredquery

requireBlockstringquery

requireLastBlockstringquery

Response

200OK

Successful account permissions retrieval

400Bad Request

Bad Request - Invalid parameters

401Unauthorized

Unauthorized - Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Queries the permissions of an account

curl -X GET 'https://ardr.nownodes.io/nxt'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ardr.nownodes.io/nxt')
data = response.json()

200

{
  "hasPermissions": [
    {
      "accountRS": "ARDOR-W3LP-38DN-DCGZ-D46VG",
      "granterRS": "ARDOR-XUH6-ZNJZ-QCAB-G6VTJ",
      "permission": "CHAIN_USER",
      "granter": "16746464777760336356",
      "account": "13217081984130352725",
      "height": 616
    }
  ],
  "hasEffectivePermissions": [
    {
      "accountRS": "ARDOR-W3LP-38DN-DCGZ-D46VG",
      "granterRS": "ARDOR-XUH6-ZNJZ-QCAB-G6VTJ",
      "permission": "CHAIN_USER",
      "granter": "16746464777760336356",
      "account": "13217081984130352725",
      "height": 616
    }
  ],
  "canGrantPermissions": [
    "string"
  ],
  "requestProcessingTime": 3
}

getChainPermissions

Queries the permissions of a chain

GET

https://ardr.nownodes.io/nxt

For extended information refer to Child Chain Control

Parameters

requestTypestringrequiredquery

chainintegerrequiredquery

permissionstringquery

granterstringquery

firstIndexintegerquery

lastIndexintegerquery

adminPasswordstringquery

requireBlockstringquery

requireLastBlockstringquery

Response

200OK

Successful chain permissions retrieval

400Bad Request

Bad Request - Invalid parameters

401Unauthorized

Unauthorized - Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Queries the permissions of a chain

curl -X GET 'https://ardr.nownodes.io/nxt'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ardr.nownodes.io/nxt')
data = response.json()

200

{
  "permissions": [
    {
      "accountRS": "ARDOR-XUH6-ZNJZ-QCAB-G6VTJ",
      "granterRS": "ARDOR-2222-2222-2222-22222",
      "permission": "MASTER_ADMIN",
      "granter": "0",
      "account": "16746464777760336356",
      "height": -1
    }
  ],
  "requestProcessingTime": 0
}

removeAccountPermission

Revokes a permission to an account

GET

https://ardr.nownodes.io/nxt

For extended information refer to Child Chain Control

Parameters

requestTypestringrequiredquery

chainintegerrequiredquery

recipientstringrequiredquery

permissionstringrequiredquery

publicKeystringquery

secretPhrasestringrequiredquery

feeNQTstringrequiredquery

deadlineintegerrequiredquery

Response

200OK

Successful account permission removal

400Bad Request

Bad Request - Invalid parameters

401Unauthorized

Unauthorized - Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Revokes a permission to an account

curl -X GET 'https://ardr.nownodes.io/nxt'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ardr.nownodes.io/nxt')
data = response.json()

200

{
  "minimumFeeFQT": "1000000",
  "signatureHash": "21832398d8e44df848182716faea73bc915c477a941d20b86639b43e52edff4f",
  "transactionJSON": {
    "senderPublicKey": "028798b60eb4bbf7ebc974245164fdba476296a7ca6fc29d911c25b34cc8c508",
    "chain": 6,
    "signature": "8e571b25ea82d1a03396c507a42c7b82fa1aa4fd3f77ccd5543ca69169752a07de2a16385e7fa996eba5b1497a4bec06b68737332b0796f21292826ffefba3c1",
    "feeNQT": "5000000",
    "type": 13,
    "fullHash": "1ec2e926d90e83a21bc5d2c6cd4ac05aa347d8ffd9af07deff96ee0e048475ef",
    "version": 1,
    "fxtTransaction": "0",
    "phased": false,
    "ecBlockId": "5829720331734290044",
    "signatureHash": "21832398d8e44df848182716faea73bc915c477a941d20b86639b43e52edff4f",
    "attachment": {
      "version.RemovePermission": 1,
      "permission": 2,
      "height": -1
    },
    "senderRS": "ARDOR-GHKP-XWB5-XMZB-CTUE3",
    "subtype": 1,
    "amountNQT": "0",
    "sender": "11579697950237343285",
    "recipientRS": "ARDOR-GHKP-XWB5-XMZB-CTUE3",
    "recipient": "11579697950237343285",
    "ecBlockHeight": 4826679,
    "deadline": 15,
    "timestamp": 76849583,
    "height": 2147483647
  },
  "unsignedTransactionBytes": "050000000d0101afa194040f00028798b60eb4bbf7ebc974245164fdba476296a7ca6fc29d911c25b34cc8c508353e3712ef59b3a00000000000000000404b4c00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000037a649007c0ee528c153e750000000000102ffffffff000000000000000000000000000000000000000000000000000000000000000000000000",
  "broadcasted": true,
  "requestProcessingTime": 9,
  "transactionBytes": "050000000d0101afa194040f00028798b60eb4bbf7ebc974245164fdba476296a7ca6fc29d911c25b34cc8c508353e3712ef59b3a00000000000000000404b4c00000000008e571b25ea82d1a03396c507a42c7b82fa1aa4fd3f77ccd5543ca69169752a07de2a16385e7fa996eba5b1497a4bec06b68737332b0796f21292826ffefba3c137a649007c0ee528c153e750000000000102ffffffff000000000000000000000000000000000000000000000000000000000000000000000000",
  "fullHash": "1ec2e926d90e83a21bc5d2c6cd4ac05aa347d8ffd9af07deff96ee0e048475ef"
}

Coin Exchange

cancelCoinExchange

Cancel an existing coin exchange order

POST

https://ardr.nownodes.io/nxt

POST only

Parameters

requestTypestringrequiredquery

chainintegerrequiredquery

orderstringrequiredquery

secretPhrasestringrequiredquery

feeNQTstringrequiredquery

deadlineintegerrequiredquery

Response

200OK

Successful coin exchange cancellation

400Bad Request

Bad Request - Invalid parameters

401Unauthorized

Unauthorized - Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Cancel an existing coin exchange order

curl -X POST 'https://ardr.nownodes.io/nxt'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
});

const data = await response.json();

import requests

response = requests.post('https://ardr.nownodes.io/nxt')
data = response.json()

200

{
  "minimumFeeFQT": "50000000",
  "signatureHash": "74fa50d20fbb6b0ab2ba69f73debba46fcd2893ad8a7d53e7fa31dbb2e3735c5",
  "transactionJSON": {
    "senderPublicKey": "df21142bd38c04bd5c5c342c6ca36802f9de89b75b2a0a8cbd32d29dca481e5c",
    "chain": 1,
    "signature": "3bd5113715c89dd3694fad21f723df540149f93b7b7e21de07f837123fcd1d0c977d205a086ae1158ca8557ae11b3b1950ce330f5565fac609843b3b2373f440",
    "feeNQT": "50000000",
    "type": -4,
    "fullHash": "8c7efba47df565cb02feb9f9fb0ef6cba0a0d8dba90436e50a55a2a024709d77",
    "version": 1,
    "phased": false,
    "ecBlockId": "12397878866807509033",
    "signatureHash": "74fa50d20fbb6b0ab2ba69f73debba46fcd2893ad8a7d53e7fa31dbb2e3735c5",
    "attachment": {
      "version.FxtCoinExchangeOrderCancel": 1,
      "orderHash": "1305bacfb02d94b81d5f3e22bfe5aaf3af44a7f08d8097ae7833b1a9043d79df"
    },
    "senderRS": "ARDOR-X8ZN-WUJ2-SXY3-FBUYC",
    "subtype": 1,
    "amountNQT": "0",
    "sender": "15382970207090678772",
    "ecBlockHeight": 392917,
    "deadline": 15,
    "transaction": "14656390482334809740",
    "timestamp": 23359885,
    "height": 2147483647
  },
  "unsignedTransactionBytes": "01000000fc01018d7164010f00df21142bd38c04bd5c5c342c6ca36802f9de89b75b2a0a8cbd32d29dca481e5c0000000000000000000000000000000080f0fa020000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000d5fe050029506280241d0eac00000000011305bacfb02d94b81d5f3e22bfe5aaf3af44a7f08d8097ae7833b1a9043d79df",
  "broadcasted": true,
  "requestProcessingTime": 4,
  "transactionBytes": "01000000fc01018d7164010f00df21142bd38c04bd5c5c342c6ca36802f9de89b75b2a0a8cbd32d29dca481e5c0000000000000000000000000000000080f0fa02000000003bd5113715c89dd3694fad21f723df540149f93b7b7e21de07f837123fcd1d0c977d205a086ae1158ca8557ae11b3b1950ce330f5565fac609843b3b2373f440d5fe050029506280241d0eac00000000011305bacfb02d94b81d5f3e22bfe5aaf3af44a7f08d8097ae7833b1a9043d79df",
  "fullHash": "8c7efba47df565cb02feb9f9fb0ef6cba0a0d8dba90436e50a55a2a024709d77"
}

exchangeCoins

Place an asset order

POST

https://ardr.nownodes.io/nxt

POST only. The transaction ID is also the order ID.

Parameters

requestTypestringrequiredquery

chainintegerrequiredquery

exchangeintegerrequiredquery

quantityQNTstringrequiredquery

priceNQTPerCoinstringrequiredquery

secretPhrasestringrequiredquery

feeNQTstringrequiredquery

feeRateNQTPerFXTstringquery

Response

200OK

Successful coin exchange order placement

400Bad Request

Bad Request - Invalid parameters

401Unauthorized

Unauthorized - Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Place an asset order

curl -X POST 'https://ardr.nownodes.io/nxt'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
});

const data = await response.json();

import requests

response = requests.post('https://ardr.nownodes.io/nxt')
data = response.json()

200

{
  "minimumFeeFQT": "50000000",
  "transactionJSON": {
    "senderPublicKey": "df21142bd38c04bd5c5c342c6ca36802f9de89b75b2a0a8cbd32d29dca481e5c",
    "chain": 1,
    "feeNQT": "50000000",
    "type": -4,
    "version": 1,
    "phased": false,
    "ecBlockId": "2329106975025976796",
    "attachment": {
      "quantityQNT": "100000000",
      "version.FxtCoinExchangeOrderIssue": 1,
      "chain": 1,
      "priceNQTPerCoin": "100000000",
      "exchangeChain": 2
    },
    "senderRS": "ARDOR-X8ZN-WUJ2-SXY3-FBUYC",
    "subtype": 0,
    "amountNQT": "0",
    "sender": "15382970207090678772",
    "ecBlockHeight": 230000,
    "deadline": 15,
    "timestamp": 23360280,
    "height": 2147483647
  },
  "unsignedTransactionBytes": "01000000fc0001187364010f00df21142bd38c04bd5c5c342c6ca36802f9de89b75b2a0a8cbd32d29dca481e5c0000000000000000000000000000000080f0fa02000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000070820300dcd54e2274a652200000000001010000000200000000e1f5050000000000e1f50500000000",
  "broadcasted": true,
  "requestProcessingTime": 1
}

getCoinExchangeOrder

Get a bid/ask coin exchange order given an order ID

GET

https://ardr.nownodes.io/nxt

Parameters

requestTypestringrequiredquery

orderstringrequiredquery

requireBlockstringquery

requireLastBlockstringquery

Response

200OK

Successful coin exchange order retrieval

400Bad Request

Bad Request - Invalid parameters

401Unauthorized

Unauthorized - Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Get a bid/ask coin exchange order given an order ID

curl -X GET 'https://ardr.nownodes.io/nxt'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ardr.nownodes.io/nxt')
data = response.json()

200

{
  "askNQTPerCoin": "100000000",
  "exchangeQNT": "100000000",
  "quantityQNT": "100000000",
  "chain": 1,
  "bidNQTPerCoin": "100000000",
  "orderFullHash": "cc169a9ad7b70fb3ef89f284bf61a2ef0e3c2dc03737fc04e08a6171bd2b6240",
  "accountRS": "ARDOR-X8ZN-WUJ2-SXY3-FBUYC",
  "exchange": "2",
  "account": "15382970207090678772",
  "order": "12902733594079401676",
  "requestProcessingTime": 1
}

getCoinExchangeOrders

Get bid/ask order IDs given an account or a chain/exchange pair

GET

https://ardr.nownodes.io/nxt

Parameters

requestTypestringrequiredquery

chainintegerquery

exchangeintegerquery

accountstringquery

firstIndexintegerquery

lastIndexintegerquery

showExpectedCancellationsbooleanquery

adminPasswordstringquery

requireBlockstringquery

requireLastBlockstringquery

Response

200OK

Successful coin exchange orders retrieval

400Bad Request

Bad Request - Invalid parameters

401Unauthorized

Unauthorized - Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Get bid/ask order IDs given an account or a chain/exchange pair

curl -X GET 'https://ardr.nownodes.io/nxt'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ardr.nownodes.io/nxt')
data = response.json()

200

{
  "orders": [
    {
      "askNQTPerCoin": "5000000000000000",
      "exchangeQNT": "99983160",
      "quantityQNT": "4999158000000000",
      "chain": 2,
      "bidNQTPerCoin": "2",
      "orderFullHash": "5fd641a06e0a0f9eda9dda0319e6edc9c3539bc4187e0b460dbf9bdcef8ccf51",
      "accountRS": "ARDOR-RLF8-475F-LRFS-E2XBS",
      "exchange": "1",
      "account": "14710902703892711846",
      "order": "11389333452894623327"
    }
  ],
  "requestProcessingTime": 1
}

getCoinExchangeTrade

Get an executed trade given the full hash of the bid/ask coin exchange

GET

https://ardr.nownodes.io/nxt

Parameters

requestTypestringrequiredquery

orderFullHashstringrequiredquery

matchFullHashstringrequiredquery

requireLastBlockstringquery

Response

200OK

Successful coin exchange trade retrieval

400Bad Request

Bad Request - Invalid parameters

401Unauthorized

Unauthorized - Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Get an executed trade given the full hash of the bid/ask coin exchange

curl -X GET 'https://ardr.nownodes.io/nxt'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ardr.nownodes.io/nxt')
data = response.json()

200

{
  "quantityQNT": "100000000",
  "chain": 2,
  "requestProcessingTime": 0,
  "priceNQTPerCoin": "100000",
  "orderFullHash": "514eea666beadb1b04ab7d32658c5701851aca7195612e968128d7e01617abdf",
  "exchangeRate": "0.00100000",
  "accountRS": "ARDOR-XK4R-7VJU-6EQG-7R335",
  "exchange": "1",
  "block": "18261861240184495732",
  "matchFullHash": "962076f848d67c13825b33b0a569f8f8b18e12f49da7f95553f0442e66dd5f91",
  "account": "5873880488492319831",
  "height": 384444,
  "timestamp": 22817693
}

getExpectedCoinExchangeOrderCancellations

Get the expected coin exchange order cancellations for a specific chain

GET

https://ardr.nownodes.io/nxt

Since version 2.3.0e it returns both bundled and non-bundled transactions

Parameters

requestTypestringrequiredquery

chainintegerrequiredquery

requireBlockstringquery

requireLastBlockstringquery

Response

200OK

Successful expected coin exchange order cancellations retrieval

400Bad Request

Bad Request - Invalid parameters

401Unauthorized

Unauthorized - Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Get the expected coin exchange order cancellations for a specific chain

curl -X GET 'https://ardr.nownodes.io/nxt'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ardr.nownodes.io/nxt')
data = response.json()

200

{
  "orderCancellations": [
    {}
  ],
  "requestProcessingTime": 0
}

getExpectedCoinExchangeOrders

Get the expected coin exchange orders to be completed for a specific chain/exchange or an account

GET

https://ardr.nownodes.io/nxt

Since version 2.3.0e it returns both bundled and non-bundled transactions

Parameters

requestTypestringrequiredquery

chainintegerquery

exchangeintegerquery

accountstringquery

Response

200OK

Successful expected coin exchange orders retrieval

400Bad Request

Bad Request - Invalid parameters

401Unauthorized

Unauthorized - Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Get the expected coin exchange orders to be completed for a specific chain/exchange or an account

curl -X GET 'https://ardr.nownodes.io/nxt'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ardr.nownodes.io/nxt')
data = response.json()

200

{
  "orders": [
    {}
  ],
  "requestProcessingTime": 0
}

simulateCoinExchange

Simulate a coin exchange given a chain, exchange, quantity and a price per coin

GET

https://ardr.nownodes.io/nxt

Parameters

requestTypestringrequiredquery

chainintegerrequiredquery

exchangeintegerrequiredquery

quantityQNTstringrequiredquery

priceNQTPerCoinstringrequiredquery

bidNQTPerCoinstringquery

Response

200OK

Successful coin exchange simulation

400Bad Request

Bad Request - Invalid parameters

401Unauthorized

Unauthorized - Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Simulate a coin exchange given a chain, exchange, quantity and a price per coin

curl -X GET 'https://ardr.nownodes.io/nxt'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ardr.nownodes.io/nxt')
data = response.json()

200

{
  "askNQTPerCoin": 5000000000,
  "quantityQNT": "1000000",
  "bidNQTPerCoin": 2000000,
  "requestProcessingTime": 1
}

DGS

dgsDelisting

Delist a listed product

POST

https://ardr.nownodes.io/nxt

POST only

Parameters

requestTypestringrequiredquery

chainintegerrequiredquery

goodsstringrequiredquery

secretPhrasestringrequiredquery

feeNQTstringrequiredquery

deadlineintegerrequiredquery

Response

200OK

Successful product delisting

400Bad Request

Bad Request - Invalid parameters

401Unauthorized

Unauthorized - Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Delist a listed product

curl -X POST 'https://ardr.nownodes.io/nxt'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
});

const data = await response.json();

import requests

response = requests.post('https://ardr.nownodes.io/nxt')
data = response.json()

200

{
  "signatureHash": "87dd2aa00690acaa5da4e8cd9db6ab94b5ed8bf0f8fe2c2ba6a39c57d3073105",
  "unsignedTransactionBytes": "03111852e2013c0057fb6f3a958e320bb49c4e81b4c2cf28b9f25d086c143b...",
  "transactionJSON": {
    "senderPublicKey": "57fb6f3a958e320bb49c4e81b4c2cf28b9f25d086c143b473beec228f79ff93c",
    "signature": "39ee52204d0a32c0bbd0e4bc6a6fb52299cd7d16ab74e9a040f857d3b1c3e...",
    "feeNQT": "100000000",
    "type": 3,
    "fullHash": "40e64c357e240f9b7ca5780e757e34d48a58ae93eeb19e62d020d5719b43e2b6",
    "version": 1,
    "ecBlockId": "5345754442518111082",
    "signatureHash": "87dd2aa00690acaa5da4e8cd9db6ab94b5ed8bf0f8fe2c2ba6a39c57d3073105",
    "attachment": {
      "version.DigitalGoodsDelisting": 1,
      "goods": "11813734897437346473"
    },
    "senderRS": "ARDOR-L6FM-89WK-VK8P-FCRBB",
    "subtype": 1,
    "amountNQT": "0",
    "sender": "15323192282528158131",
    "ecBlockHeight": 292903,
    "deadline": 60,
    "transaction": "11173189325008201280",
    "timestamp": 31609368,
    "height": 2147483647
  },
  "broadcasted": true,
  "requestProcessingTime": 5188,
  "transactionBytes": "03111852e2013c0057fb6f3a958e320bb49c4e81b4c2cf28b9f25d086c143b...",
  "fullHash": "40e64c357e240f9b7ca5780e757e34d48a58ae93eeb19e62d020d5719b43e2b6",
  "transaction": "11173189325008201280"
}

dgsDelivery

Deliver a product

POST

https://ardr.nownodes.io/nxt

POST only

Parameters

requestTypestringrequiredquery

chainintegerrequiredquery

purchasestringrequiredquery

discountNQTstringquery

goodsToEncryptstringquery

goodsIsTextbooleanquery

goodsDatastringquery

goodsNoncestringquery

secretPhrasestringrequiredquery

feeNQTstringrequiredquery

deadlineintegerrequiredquery

Response

200OK

Successful product delivery

400Bad Request

Bad Request - Invalid parameters

401Unauthorized

Unauthorized - Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Deliver a product

curl -X POST 'https://ardr.nownodes.io/nxt'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
});

const data = await response.json();

import requests

response = requests.post('https://ardr.nownodes.io/nxt')
data = response.json()

200

{
  "signatureHash": "f3f1f1bf30c7a6f5a7776aa23502dfe5240efe0d5c016760f8e8a152c4eb1b1b",
  "unsignedTransactionBytes": "0315b20fe1013c0057fb6f3a958e320bb49c4e81b4c2cf28b9f25d086c143b...",
  "transactionJSON": {
    "senderPublicKey": "57fb6f3a958e320bb49c4e81b4c2cf28b9f25d086c143b473beec228f79ff93c",
    "signature": "b96c42161ce38177168de5a8906ce747a5415017df5b16cdce1c015cb6e1f10b...",
    "feeNQT": "100000000",
    "type": 3,
    "fullHash": "349926ea025b627117c05fbe3ff298e97a8efdb07f7ae552b5a91e7112c5b82b",
    "version": 1,
    "ecBlockId": "15813950788992376142",
    "signatureHash": "f3f1f1bf30c7a6f5a7776aa23502dfe5240efe0d5c016760f8e8a152c4eb1b1b",
    "attachment": {
      "goodsIsText": true,
      "discountNQT": "0",
      "purchase": "3723760852542296589",
      "goodsData": "aef91bfe543844964b0dadc51c6fe4c624b6b0c72c23c5c61f7e626f51e15...",
      "version.DigitalGoodsDelivery": 1,
      "goodsNonce": "4cb474ec53a590c6fd20d050c429d009ddefd286b2782eb3a0782ae45c2bbbbd"
    },
    "senderRS": "ARDOR-L6FM-89WK-VK8P-FCRBB",
    "subtype": 5,
    "amountNQT": "0",
    "sender": "15323192282528158131",
    "recipientRS": "ARDOR-6GMG-FC5F-YSX6-8CVEL",
    "recipient": "7580519603555678830",
    "ecBlockHeight": 292069,
    "deadline": 60,
    "transaction": "8170192742079961396",
    "timestamp": 31526834,
    "height": 2147483647
  },
  "broadcasted": true,
  "requestProcessingTime": 8832,
  "transactionBytes": "0315b20fe1013c0057fb6f3a958e320bb49c4e81b4c2cf28b9f25d086c143b...",
  "fullHash": "349926ea025b627117c05fbe3ff298e97a8efdb07f7ae552b5a91e7112c5b82b",
  "transaction": "8170192742079961396"
}

dgsFeedback

Give feedback about a purchased product after delivery

POST

https://ardr.nownodes.io/nxt

POST only. The unencrypted message parameter is used for public feedback, but in addition or instead, an encrypted message can be used for private feedback to the seller and/or an encrypted message can be sent to self (buyer) although the current NRS client does not recognize non-public feedback messages.

Parameters

requestTypestringrequiredquery

chainintegerrequiredquery

purchasestringrequiredquery

messagestringrequiredquery

secretPhrasestringrequiredquery

feeNQTstringrequiredquery

deadlineintegerrequiredquery

Response

200OK

Successful feedback submission

400Bad Request

Bad Request - Invalid parameters

401Unauthorized

Unauthorized - Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Give feedback about a purchased product after delivery

curl -X POST 'https://ardr.nownodes.io/nxt'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
});

const data = await response.json();

import requests

response = requests.post('https://ardr.nownodes.io/nxt')
data = response.json()

200

{
  "signatureHash": "bf31e4e3b2037bfe223efd72519e3a2d25cd1e0dc1a62e3eeefe59179e16a7a4",
  "unsignedTransactionBytes": "0316a463e2013c0057fb6f3a958e320bb49c4e81b4c2cf28b9f25d086c143b...",
  "transactionJSON": {
    "senderPublicKey": "57fb6f3a958e320bb49c4e81b4c2cf28b9f25d086c143b473beec228f79ff93c",
    "signature": "a3ee76ce4bec0328fe5cfc1a2adfc229a8c9959a81b7912664de51156987c...",
    "feeNQT": "100000000",
    "type": 3,
    "fullHash": "491d94b9031b7a7a32d9ab5d0491b81364941eb080ee9029de58cb6ffa0161f6",
    "version": 1,
    "ecBlockId": "5484311742753527844",
    "signatureHash": "bf31e4e3b2037bfe223efd72519e3a2d25cd1e0dc1a62e3eeefe59179e16a7a4",
    "attachment": {
      "purchase": "10234639413366748292",
      "version.Message": 1,
      "messageIsText": true,
      "version.DigitalGoodsFeedback": 1,
      "message": "Thank you!"
    },
    "senderRS": "ARDOR-L6FM-89WK-VK8P-FCRBB",
    "subtype": 6,
    "amountNQT": "0",
    "sender": "15323192282528158131",
    "recipientRS": "ARDOR-6GMG-FC5F-YSX6-8CVEL",
    "recipient": "7580519603555678830",
    "ecBlockHeight": 292938,
    "deadline": 60,
    "transaction": "8825396122598251849",
    "timestamp": 31613860,
    "height": 2147483647
  },
  "broadcasted": true,
  "requestProcessingTime": 9343,
  "transactionBytes": "0316a463e2013c0057fb6f3a958e320bb49c4e81b4c2cf28b9f25d086c143b...",
  "fullHash": "491d94b9031b7a7a32d9ab5d0491b81364941eb080ee9029de58cb6ffa0161f6",
  "transaction": "8825396122598251849"
}

dgsListing

List a product in the DGS by creating a listing transaction

POST

https://ardr.nownodes.io/nxt

POST only. The transaction ID is also the goods ID.

Parameters

requestTypestringrequiredquery

chainintegerrequiredquery

namestringrequiredquery

descriptionstringrequiredquery

tagsstringquery

quantityintegerrequiredquery

priceNQTstringrequiredquery

secretPhrasestringrequiredquery

feeNQTstringrequiredquery

deadlineintegerrequiredquery

Response

200OK

Successful product listing

400Bad Request

Bad Request - Invalid parameters

401Unauthorized

Unauthorized - Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

List a product in the DGS by creating a listing transaction

curl -X POST 'https://ardr.nownodes.io/nxt'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
});

const data = await response.json();

import requests

response = requests.post('https://ardr.nownodes.io/nxt')
data = response.json()

200

{
  "signatureHash": "565bc0a6140ae1331cd5db009fbd9da164d8802330939ef40204a9bc343b3149",
  "unsignedTransactionBytes": "031092aedf013c0057fb6f3a958e320bb49c4e81b4c2cf28b9f25d086c143b...",
  "transactionJSON": {
    "senderPublicKey": "57fb6f3a958e320bb49c4e81b4c2cf28b9f25d086c143b473beec228f79ff93c",
    "signature": "465ed3dfef9a02fc97fc18a6f83bb9f07c285aef41ff78c957d59cda2972ba...",
    "feeNQT": "100000000",
    "type": 3,
    "fullHash": "a98a63204cd1f2a3304cee79776854f290f0472883c576056fec16a23efa90df",
    "version": 1,
    "ecBlockId": "4480409615309425420",
    "signatureHash": "565bc0a6140ae1331cd5db009fbd9da164d8802330939ef40204a9bc343b3149",
    "attachment": {
      "priceNQT": "100000000",
      "quantity": 3,
      "name": "Test Product",
      "description": "Testing the DGS.",
      "version.DigitalGoodsListing": 1,
      "tags": "test, product, tag, extra"
    },
    "senderRS": "ARDOR-L6FM-89WK-VK8P-FCRBB",
    "subtype": 0,
    "amountNQT": "0",
    "sender": "15323192282528158131",
    "ecBlockHeight": 291240,
    "deadline": 60,
    "transaction": "11813734897437346473",
    "timestamp": 31436434,
    "height": 2147483647
  },
  "broadcasted": true,
  "requestProcessingTime": 8958,
  "transactionBytes": "031092aedf013c0057fb6f3a958e320bb49c4e81b4c2cf28b9f25d086c143b473b...",
  "fullHash": "a98a63204cd1f2a3304cee79776854f290f0472883c576056fec16a23efa90df",
  "transaction": "11813734897437346473"
}

dgsPriceChange

Change the price of a listed product

POST

https://ardr.nownodes.io/nxt

POST only

Parameters

requestTypestringrequiredquery

chainintegerrequiredquery

goodsstringrequiredquery

priceNQTstringrequiredquery

secretPhrasestringrequiredquery

feeNQTstringrequiredquery

deadlineintegerrequiredquery

Response

200OK

Successful price change

400Bad Request

Bad Request - Invalid parameters

401Unauthorized

Unauthorized - Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Change the price of a listed product

curl -X POST 'https://ardr.nownodes.io/nxt'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
});

const data = await response.json();

import requests

response = requests.post('https://ardr.nownodes.io/nxt')
data = response.json()

200

{
  "signatureHash": "aad88476935eda8ca3a9190163b83106e6ca95733ddfa274d29a0378d773cc3c",
  "unsignedTransactionBytes": "0312cebbdf013c0057fb6f3a958e320bb49c4e81b4c2cf28b9f25d086c143b...",
  "transactionJSON": {
    "senderPublicKey": "57fb6f3a958e320bb49c4e81b4c2cf28b9f25d086c143b473beec228f79ff93c",
    "signature": "533f9c330100cab8a7a0f9375b49a09f6432b0e029660ab715a728ac75e6c2...",
    "feeNQT": "100000000",
    "type": 3,
    "fullHash": "1964e4fe11f4a00a96c79e274f9da21f64d7fe10ed77a154975b92d3c65f1287",
    "version": 1,
    "ecBlockId": "14411471768450948944",
    "signatureHash": "aad88476935eda8ca3a9190163b83106e6ca95733ddfa274d29a0378d773cc3c",
    "attachment": {
      "goods": "11813734897437346473",
      "priceNQT": "200000000",
      "version.DigitalGoodsPriceChange": 1
    },
    "senderRS": "ARDOR-L6FM-89WK-VK8P-FCRBB",
    "subtype": 2,
    "amountNQT": "0",
    "sender": "15323192282528158131",
    "ecBlockHeight": 291259,
    "deadline": 60,
    "transaction": "765880294780986393",
    "timestamp": 31439822,
    "height": 2147483647
  },
  "broadcasted": true,
  "requestProcessingTime": 6444,
  "transactionBytes": "0312cebbdf013c0057fb6f3a958e320bb49c4e81b4c2cf28b9f25d086c143b...",
  "fullHash": "1964e4fe11f4a00a96c79e274f9da21f64d7fe10ed77a154975b92d3c65f1287",
  "transaction": "765880294780986393"
}

dgsPurchase

Purchase a product for sale

POST

https://ardr.nownodes.io/nxt

POST only. The transaction ID is also the purchase order ID.

Parameters

requestTypestringrequiredquery

chainintegerrequiredquery

goodsstringrequiredquery

priceNQTstringrequiredquery

quantityintegerrequiredquery

deliveryDeadlineTimestampintegerrequiredquery

secretPhrasestringrequiredquery

feeNQTstringrequiredquery

deadlineintegerrequiredquery

Response

200OK

Successful product purchase

400Bad Request

Bad Request - Invalid parameters

401Unauthorized

Unauthorized - Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Purchase a product for sale

curl -X POST 'https://ardr.nownodes.io/nxt'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
});

const data = await response.json();

import requests

response = requests.post('https://ardr.nownodes.io/nxt')
data = response.json()

200

{
  "signatureHash": "03e112d8707ae33ec37ff4405f31920c0e67c58439e33033c248b3eaca81d2c3",
  "unsignedTransactionBytes": "0314805be2013c0057fb6f3a958e320bb49c4e81b4c2cf28b9f25d086c143b...",
  "transactionJSON": {
    "senderPublicKey": "57fb6f3a958e320bb49c4e81b4c2cf28b9f25d086c143b473beec228f79ff93c",
    "signature": "a2739ef63024d9d3c61bebbb2692e7a2092666e13fc380c2e8b29c3a3fc24...",
    "feeNQT": "100000000",
    "type": 3,
    "fullHash": "84f4ef2d52be088e011e5b7857fbab88665918e0df02102a8333aee53c3bb88b",
    "version": 1,
    "ecBlockId": "3186563001195424357",
    "signatureHash": "03e112d8707ae33ec37ff4405f31920c0e67c58439e33033c248b3eaca81d2c3",
    "attachment": {
      "goods": "1587116104511359906",
      "priceNQT": "100000000",
      "quantity": 1,
      "deliveryDeadlineTimestamp": 31800000,
      "version.DigitalGoodsPurchase": 1
    },
    "senderRS": "ARDOR-L6FM-89WK-VK8P-FCRBB",
    "subtype": 4,
    "amountNQT": "0",
    "sender": "15323192282528158131",
    "recipientRS": "ARDOR-6GMG-FC5F-YSX6-8CVEL",
    "recipient": "7580519603555678830",
    "ecBlockHeight": 292925,
    "deadline": 60,
    "transaction": "10234639413366748292",
    "timestamp": 31611776,
    "height": 2147483647
  },
  "broadcasted": true,
  "requestProcessingTime": 5536,
  "transactionBytes": "0314805be2013c0057fb6f3a958e320bb49c4e81b4c2cf28b9f25d086c143b...",
  "fullHash": "84f4ef2d52be088e011e5b7857fbab88665918e0df02102a8333aee53c3bb88b",
  "transaction": "10234639413366748292"
}

dgsQuantityChange

Change the quantity of a listed product

POST

https://ardr.nownodes.io/nxt

POST only

Parameters

requestTypestringrequiredquery

chainintegerrequiredquery

goodsstringrequiredquery

deltaQuantityintegerrequiredquery

secretPhrasestringrequiredquery

feeNQTstringrequiredquery

deadlineintegerrequiredquery

Response

200OK

Successful quantity change

400Bad Request

Bad Request - Invalid parameters

401Unauthorized

Unauthorized - Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Change the quantity of a listed product

curl -X POST 'https://ardr.nownodes.io/nxt'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
});

const data = await response.json();

import requests

response = requests.post('https://ardr.nownodes.io/nxt')
data = response.json()

200

{
  "signatureHash": "5c60fc94452980f88423c3a16a74d49209d246d0f7454024c87cc76ea3221500",
  "unsignedTransactionBytes": "031334b7df013c0057fb6f3a958e320bb49c4e81b4c2cf28b9f25d086c143b...",
  "transactionJSON": {
    "senderPublicKey": "57fb6f3a958e320bb49c4e81b4c2cf28b9f25d086c143b473beec228f79ff93c",
    "signature": "7eaf8e48a780f51aa7e01c01091c9388b72a1bf075dddbd3594d55ad169272...",
    "feeNQT": "100000000",
    "type": 3,
    "fullHash": "f3cd9046bba3706dd6f63cf387f23c7c29532ff15e3423f57900613c844a646f",
    "version": 1,
    "ecBlockId": "14589429051005044326",
    "signatureHash": "5c60fc94452980f88423c3a16a74d49209d246d0f7454024c87cc76ea3221500",
    "attachment": {
      "goods": "11813734897437346473",
      "version.DigitalGoodsQuantityChange": 1,
      "deltaQuantity": -1
    },
    "senderRS": "ARDOR-L6FM-89WK-VK8P-FCRBB",
    "subtype": 3,
    "amountNQT": "0",
    "sender": "15323192282528158131",
    "ecBlockHeight": 291249,
    "deadline": 60,
    "transaction": "7885982972263845363",
    "timestamp": 31438644,
    "height": 2147483647
  },
  "broadcasted": true,
  "requestProcessingTime": 7474,
  "transactionBytes": "031334b7df013c0057fb6f3a958e320bb49c4e81b4c2cf28b9f25d086c143b...",
  "fullHash": "f3cd9046bba3706dd6f63cf387f23c7c29532ff15e3423f57900613c844a646f",
  "transaction": "7885982972263845363"
}

dgsRefund

Refund a purchase

POST

https://ardr.nownodes.io/nxt

POST only

Parameters

requestTypestringrequiredquery

chainintegerrequiredquery

purchasestringrequiredquery

refundNQTstringrequiredquery

secretPhrasestringrequiredquery

feeNQTstringrequiredquery

deadlineintegerrequiredquery

Response

200OK

Successful refund

400Bad Request

Bad Request - Invalid parameters

401Unauthorized

Unauthorized - Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Refund a purchase

curl -X POST 'https://ardr.nownodes.io/nxt'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
});

const data = await response.json();

import requests

response = requests.post('https://ardr.nownodes.io/nxt')
data = response.json()

200

{
  "signatureHash": "dafa980759db6bd6e5f11aa7bdc1cff1bb201be750328c397870f1758cef975c",
  "unsignedTransactionBytes": "0317944ee2013c0057fb6f3a958e320bb49c4e81b4c2cf28b9f25d086c143b...",
  "transactionJSON": {
    "senderPublicKey": "57fb6f3a958e320bb49c4e81b4c2cf28b9f25d086c143b473beec228f79ff93c",
    "signature": "43a90c1f0dde1bca84623e69b0abe0284883600d7bfb5286b3489a9ee417...",
    "feeNQT": "100000000",
    "type": 3,
    "fullHash": "64c2af2811da3306f4671002ed1f12655fca1937a0b68164da2a71f3ee63adce",
    "version": 1,
    "ecBlockId": "11418000967717599433",
    "signatureHash": "dafa980759db6bd6e5f11aa7bdc1cff1bb201be750328c397870f1758cef975c",
    "attachment": {
      "purchase": "3723760852542296589",
      "version.DigitalGoodsRefund": 1,
      "refundNQT": "100000000"
    },
    "senderRS": "ARDOR-L6FM-89WK-VK8P-FCRBB",
    "subtype": 7,
    "amountNQT": "0",
    "sender": "15323192282528158131",
    "recipientRS": "ARDOR-6GMG-FC5F-YSX6-8CVEL",
    "recipient": "7580519603555678830",
    "ecBlockHeight": 292899,
    "deadline": 60,
    "transaction": "446940555271717476",
    "timestamp": 31608468,
    "height": 2147483647
  },
  "broadcasted": true,
  "requestProcessingTime": 10509,
  "transactionBytes": "0317944ee2013c0057fb6f3a958e320bb49c4e81b4c2cf28b9f25d086c143b...",
  "fullHash": "64c2af2811da3306f4671002ed1f12655fca1937a0b68164da2a71f3ee63adce",
  "transaction": "446940555271717476"
}

getDGSExpiredPurchases

Get purchase orders which have expired without being delivered, given a seller ID, in reverse chronological order

GET

https://ardr.nownodes.io/nxt

Parameters

requestTypestringrequiredquery

chainintegerrequiredquery

sellerstringrequiredquery

firstIndexintegerquery

lastIndexintegerquery

requireBlockstringquery

requireLastBlockstringquery

Response

200OK

Successful expired purchases retrieval

400Bad Request

Bad Request - Invalid parameters

401Unauthorized

Unauthorized - Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Get purchase orders which have expired without being delivered, given a seller ID, in reverse chronological order

curl -X GET 'https://ardr.nownodes.io/nxt'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ardr.nownodes.io/nxt')
data = response.json()

200

{
  "purchases": [
    {
      "seller": "5873880488492319831",
      "priceNQT": "1000000000",
      "quantity": 1,
      "deliveryDeadlineTimestamp": 44955165,
      "buyerRS": "ARDOR-XK4R-7VJU-6EQG-7R335",
      "pending": false,
      "purchase": "17272258199467687054",
      "name": "MyProduct",
      "goods": "4830545483228225683",
      "sellerRS": "ARDOR-XK4R-7VJU-6EQG-7R335",
      "buyer": "5873880488492319831",
      "timestamp": 44397533
    }
  ],
  "lastBlock": "string",
  "requestProcessingTime": 1
}

getDGSGood

Get a DGS product given a goods ID

GET

https://ardr.nownodes.io/nxt

Parameters

requestTypestringrequiredquery

chainintegerrequiredquery

goodsstringrequiredquery

includeCountsbooleanquery

requireBlockstringquery

requireLastBlockstringquery

Response

200OK

Successful DGS product retrieval

400Bad Request

Bad Request - Invalid parameters

401Unauthorized

Unauthorized - Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Get a DGS product given a goods ID

curl -X GET 'https://ardr.nownodes.io/nxt'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ardr.nownodes.io/nxt')
data = response.json()

200

{
  "seller": "15323192282528158131",
  "quantity": 3,
  "goods": "11813734897437346473",
  "description": "Testing the DGS.",
  "sellerRS": "ARDOR-L6FM-89WK-VK8P-FCRBB",
  "requestProcessingTime": 1,
  "delisted": false,
  "parsedTags": [
    "test",
    "product",
    "tag"
  ],
  "tags": "test, product, tag, extra",
  "priceNQT": "100000000",
  "numberOfPublicFeedbacks": 0,
  "name": "Test Product",
  "numberOfPurchases": 0,
  "timestamp": 31436434,
  "lastBlock": "string"
}

getDGSGoods

Get DGS products for sale in reverse chronological listing creation order unless a seller is given, then in product name order

GET

https://ardr.nownodes.io/nxt

If none of the optional parameters are specified, all in-stock products in the blockchain are retrieved at once, which may take a long time.

Parameters

requestTypestringrequiredquery

chainintegerrequiredquery

sellerstringquery

firstIndexintegerquery

lastIndexintegerquery

inStockOnlybooleanquery

hideDelistedbooleanquery

includeCountsbooleanquery

requireBlockstringquery

requireLastBlockstringquery

Response

200OK

Successful DGS goods retrieval

400Bad Request

Bad Request - Invalid parameters

401Unauthorized

Unauthorized - Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Get DGS products for sale in reverse chronological listing creation order unless a seller is given, then in product name order

curl -X GET 'https://ardr.nownodes.io/nxt'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ardr.nownodes.io/nxt')
data = response.json()

200

{
  "goods": [
    {
      "seller": "15323192282528158131",
      "quantity": 2,
      "goods": "11813734897437346473",
      "description": "Testing the DGS.",
      "sellerRS": "ARDOR-L6FM-89WK-VK8P-FCRBB",
      "delisted": false,
      "parsedTags": [
        "test",
        "product",
        "tag"
      ],
      "tags": "test, product, tag, extra",
      "priceNQT": "200000000",
      "numberOfPublicFeedbacks": 0,
      "name": "Test Product",
      "numberOfPurchases": 0,
      "timestamp": 31436434
    }
  ],
  "lastBlock": "string",
  "requestProcessingTime": 46
}

getDGSGoodsCount

Get the number of products for sale by a given seller or all sellers

GET

https://ardr.nownodes.io/nxt

The numberOfGoods field refers to the number of distinct products for sale, regardless of the quantity of each.

Parameters

requestTypestringrequiredquery

chainintegerrequiredquery

sellerstringquery

inStockOnlybooleanquery

requireBlockstringquery

requireLastBlockstringquery

Response

200OK

Successful DGS goods count retrieval

400Bad Request

Bad Request - Invalid parameters

401Unauthorized

Unauthorized - Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Get the number of products for sale by a given seller or all sellers

curl -X GET 'https://ardr.nownodes.io/nxt'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ardr.nownodes.io/nxt')
data = response.json()

200

{
  "numberOfGoods": 1,
  "lastBlock": "string",
  "requestProcessingTime": 2
}

getDGSGoodsPurchaseCount

Get the number of completed purchase orders given a goods ID

GET

https://ardr.nownodes.io/nxt

Parameters

requestTypestringrequiredquery

chainintegerrequiredquery

goodsstringrequiredquery

withPublicFeedbacksOnlybooleanquery

completedbooleanquery

requireBlockstringquery

requireLastBlockstringquery

Response

200OK

Successful DGS goods purchase count retrieval

400Bad Request

Bad Request - Invalid parameters

401Unauthorized

Unauthorized - Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Get the number of completed purchase orders given a goods ID

curl -X GET 'https://ardr.nownodes.io/nxt'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ardr.nownodes.io/nxt')
data = response.json()

200

{
  "numberOfPurchases": 1,
  "lastBlock": "string",
  "requestProcessingTime": 1
}

getDGSGoodsPurchases

Get completed purchase orders given a goods ID and optionally a buyer ID in reverse chronological order

GET

https://ardr.nownodes.io/nxt

Parameters

requestTypestringrequiredquery

chainintegerrequiredquery

goodsstringrequiredquery

buyerstringquery

firstIndexintegerquery

lastIndexintegerquery

withPublicFeedbacksOnlybooleanquery

completedbooleanquery

requireBlockstringquery

requireLastBlockstringquery

Response

200OK

Successful DGS goods purchases retrieval

400Bad Request

Bad Request - Invalid parameters

401Unauthorized

Unauthorized - Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Get completed purchase orders given a goods ID and optionally a buyer ID in reverse chronological order

curl -X GET 'https://ardr.nownodes.io/nxt'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ardr.nownodes.io/nxt')
data = response.json()

200

{
  "purchases": [
    {
      "seller": "15323192282528158131",
      "quantity": 2,
      "pending": false,
      "purchase": "3723760852542296589",
      "goods": "11813734897437346473",
      "sellerRS": "ARDOR-L6FM-89WK-VK8P-FCRBB",
      "buyer": "7580519603555678830",
      "priceNQT": "200000000",
      "deliveryDeadlineTimestamp": 31600000,
      "goodsIsText": false,
      "buyerRS": "ARDOR-6GMG-FC5F-YSX6-8CVEL",
      "name": "Test Product",
      "goodsData": {
        "data": "aef91bfe543844964b0dadc51c6fe4c624b6b0c72c23c5c61f7e626f51e15...",
        "nonce": "4cb474ec53a590c6fd20d050c429d009ddefd286b2782eb3a0782ae45c2bbbbd"
      },
      "timestamp": 31520720
    }
  ],
  "lastBlock": "string",
  "requestProcessingTime": 305
}

getDGSPendingPurchases

Get pending purchase orders given a seller ID in reverse chronological order

GET

https://ardr.nownodes.io/nxt

Parameters

requestTypestringrequiredquery

chainintegerrequiredquery

sellerstringrequiredquery

firstIndexintegerquery

lastIndexintegerquery

requireBlockstringquery

requireLastBlockstringquery

Response

200OK

Successful DGS pending purchases retrieval

400Bad Request

Bad Request - Invalid parameters

401Unauthorized

Unauthorized - Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Get pending purchase orders given a seller ID in reverse chronological order

curl -X GET 'https://ardr.nownodes.io/nxt'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ardr.nownodes.io/nxt')
data = response.json()

200

{
  "purchases": [
    {
      "seller": "15323192282528158131",
      "priceNQT": "200000000",
      "quantity": 2,
      "deliveryDeadlineTimestamp": 31600000,
      "buyerRS": "ARDOR-6GMG-FC5F-YSX6-8CVEL",
      "pending": true,
      "purchase": "3723760852542296589",
      "name": "Test Product",
      "goods": "11813734897437346473",
      "sellerRS": "ARDOR-L6FM-89WK-VK8P-FCRBB",
      "buyer": "7580519603555678830",
      "timestamp": 31520720
    }
  ],
  "lastBlock": "string",
  "requestProcessingTime": 1
}

getDGSPurchase

Get a purchase order given a purchase order ID

GET

https://ardr.nownodes.io/nxt

Parameters

requestTypestringrequiredquery

chainintegerrequiredquery

purchasestringrequiredquery

sharedKeystringquery

requireBlockstringquery

requireLastBlockstringquery

Response

200OK

Successful DGS purchase retrieval

400Bad Request

Bad Request - Invalid parameters

401Unauthorized

Unauthorized - Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Get a purchase order given a purchase order ID

curl -X GET 'https://ardr.nownodes.io/nxt'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ardr.nownodes.io/nxt')
data = response.json()

200

{
  "seller": "7580519603555678830",
  "quantity": 1,
  "feedbackNotes": [
    {
      "data": "7086a82f4da0708d4eaa9b16d5fc5a25c556596ea29d957d0a1dddd0a482c...",
      "nonce": "c521481ce67f7778c41c6716806047d4ea641005392cd7e5ce8d20c49623dad8"
    }
  ],
  "publicFeedbacks": [
    "Thank you again!"
  ],
  "pending": false,
  "purchase": "10234639413366748292",
  "goods": "1587116104511359906",
  "sellerRS": "ARDOR-6GMG-FC5F-YSX6-8CVEL",
  "buyer": "15323192282528158131",
  "priceNQT": "100000000",
  "deliveryDeadlineTimestamp": 31800000,
  "goodsIsText": false,
  "buyerRS": "ARDOR-L6FM-89WK-VK8P-FCRBB",
  "refundNQT": "string",
  "discountNQT": "100000000",
  "name": "Test Product",
  "goodsData": {
    "data": "5f4868022381aa9532614a7aae1600e59e84c80571add107dabca891df97e7...",
    "nonce": "c017b846de4375741ebc9f3bff894270d218ff4090a66dfd505770ccdc2f54bd"
  },
  "timestamp": 31611776,
  "lastBlock": "string",
  "requestProcessingTime": 1
}

getDGSPurchaseCount

Get the number of purchase orders given a seller and/or buyer ID, or all orders combined

GET

https://ardr.nownodes.io/nxt

Parameters

requestTypestringrequiredquery

chainintegerrequiredquery

sellerstringquery

buyerstringquery

withPublicFeedbacksOnlybooleanquery

completedbooleanquery

requireBlockstringquery

requireLastBlockstringquery

Response

200OK

Successful DGS purchase count retrieval

400Bad Request

Bad Request - Invalid parameters

401Unauthorized

Unauthorized - Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Get the number of purchase orders given a seller and/or buyer ID, or all orders combined

curl -X GET 'https://ardr.nownodes.io/nxt'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ardr.nownodes.io/nxt')
data = response.json()

200

{
  "numberOfPurchases": 2,
  "lastBlock": "string",
  "requestProcessingTime": 1
}

getDGSPurchases

Get purchase orders given a seller and/or buyer ID in reverse chronological order

GET

https://ardr.nownodes.io/nxt

Parameters

requestTypestringrequiredquery

chainintegerrequiredquery

sellerstringquery

buyerstringquery

firstIndexintegerquery

lastIndexintegerquery

withPublicFeedbacksOnlybooleanquery

completedbooleanquery

requireBlockstringquery

requireLastBlockstringquery

Response

200OK

Successful DGS purchases retrieval

400Bad Request

Bad Request - Invalid parameters

401Unauthorized

Unauthorized - Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Get purchase orders given a seller and/or buyer ID in reverse chronological order

curl -X GET 'https://ardr.nownodes.io/nxt'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ardr.nownodes.io/nxt')
data = response.json()

200

{
  "purchases": [
    {
      "seller": "15323192282528158131",
      "priceNQT": "200000000",
      "quantity": 2,
      "deliveryDeadlineTimestamp": 31600000,
      "buyerRS": "ARDOR-6GMG-FC5F-YSX6-8CVEL",
      "pending": true,
      "purchase": "3723760852542296589",
      "name": "Test Product",
      "goods": "11813734897437346473",
      "sellerRS": "ARDOR-L6FM-89WK-VK8P-FCRBB",
      "buyer": "7580519603555678830",
      "timestamp": 31520720
    }
  ],
  "lastBlock": "string",
  "requestProcessingTime": 1
}

getDGSTagCount

Get the number of tags used by all sellers

GET

https://ardr.nownodes.io/nxt

Parameters

requestTypestringrequiredquery

chainintegerrequiredquery

inStockOnlybooleanquery

requireBlockstringquery

requireLastBlockstringquery

Response

200OK

Successful DGS tag count retrieval

400Bad Request

Bad Request - Invalid parameters

401Unauthorized

Unauthorized - Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Get the number of tags used by all sellers

curl -X GET 'https://ardr.nownodes.io/nxt'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ardr.nownodes.io/nxt')
data = response.json()

200

{
  "numberOfTags": 383,
  "lastBlock": "string",
  "requestProcessingTime": 472
}

getDGSTags

Get tags used by all sellers in reverse inStockCount, reverse totalCount, tag order

GET

https://ardr.nownodes.io/nxt

The ...Count fields refer to the number of distinct products tagged, regardless of the quantity of each.

Parameters

requestTypestringrequiredquery

chainintegerrequiredquery

inStockOnlybooleanquery

firstIndexintegerquery

lastIndexintegerquery

requireBlockstringquery

requireLastBlockstringquery

Response

200OK

Successful DGS tags retrieval

400Bad Request

Bad Request - Invalid parameters

401Unauthorized

Unauthorized - Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Get tags used by all sellers in reverse inStockCount, reverse totalCount, tag order

curl -X GET 'https://ardr.nownodes.io/nxt'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ardr.nownodes.io/nxt')
data = response.json()

200

{
  "tags": [
    {
      "inStockCount": 40,
      "tag": "domains",
      "totalCount": 42
    }
  ],
  "lastBlock": "string",
  "requestProcessingTime": 2
}

getDGSTagsLike

Get all tags starting with a given prefix (at least 2 characters long) in reverse inStockCount, reverse totalCount, tag order

GET

https://ardr.nownodes.io/nxt

The ...Count fields refer to the number of distinct products tagged, regardless of the quantity of each.

Parameters

requestTypestringrequiredquery

chainintegerrequiredquery

tagPrefixstringrequiredquery

inStockOnlybooleanquery

firstIndexintegerquery

lastIndexintegerquery

requireBlockstringquery

requireLastBlockstringquery

Response

200OK

Successful DGS tags like retrieval

400Bad Request

Bad Request - Invalid parameters

401Unauthorized

Unauthorized - Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Get all tags starting with a given prefix (at least 2 characters long) in reverse inStockCount, reverse totalCount, tag order

curl -X GET 'https://ardr.nownodes.io/nxt'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ardr.nownodes.io/nxt')
data = response.json()

200

{
  "tags": [
    {
      "inStockCount": 1,
      "tag": "items",
      "totalCount": 1
    }
  ],
  "lastBlock": "string",
  "requestProcessingTime": 1
}

searchDGSGoods

Get product listings that have a name or description that match a given query in reverse relevance order, then name order (given a seller), then reverse chronological order

GET

https://ardr.nownodes.io/nxt

Parameters

requestTypestringrequiredquery

chainintegerrequiredquery

querystringquery

tagstringquery

sellerstringquery

firstIndexintegerquery

lastIndexintegerquery

inStockOnlybooleanquery

hideDelistedbooleanquery

includeCountsbooleanquery

requireBlockstringquery

requireLastBlockstringquery

Response

200OK

Successful DGS goods search

400Bad Request

Bad Request - Invalid parameters

401Unauthorized

Unauthorized - Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Get product listings that have a name or description that match a given query in reverse relevance order, then name order (given a seller), then reverse chronological order

curl -X GET 'https://ardr.nownodes.io/nxt'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ardr.nownodes.io/nxt')
data = response.json()

200

{
  "goods": [
    {
      "seller": "7580519603555678830",
      "quantity": 1,
      "goods": "1587116104511359906",
      "description": "This is a test. Please do not order.",
      "sellerRS": "ARDOR-6GMG-FC5F-YSX6-8CVEL",
      "delisted": false,
      "parsedTags": [
        "test",
        "product",
        "tag"
      ],
      "tags": "test,product,tag",
      "priceNQT": "100000000",
      "numberOfPublicFeedbacks": 1,
      "name": "Test Product",
      "numberOfPurchases": 1,
      "timestamp": 31611435
    }
  ],
  "lastBlock": "string",
  "requestProcessingTime": 4
}

Messages

decryptFrom

Decrypt an AES-encrypted message

POST

https://ardr.nownodes.io/nxt

Body

application/json

jsonrpcstringrequired

methodstringrequired

paramsobjectrequired

Show child attributes

requestTypestring

secretPhrasestring

The secret passphrase of the recipient

privateKeystring

The privateKey (hex) of the derived account

accountstring

The account ID of the message sender

datastring

AES-encrypted data

noncestring

The unique nonce associated with the encrypted data

decryptedMessageIsTextboolean

False if the decrypted message is a hex string, otherwise the decrypted message is text

uncompressDecryptedMessageboolean

False to prevent gzip uncompression after decryption

idintegerrequired

Response

200OK

Message decrypted successfully

400Bad Request

Bad Request

401Unauthorized

Unauthorized — Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Decrypt an AES-encrypted message

curl -X POST 'https://ardr.nownodes.io/nxt' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "decryptFrom",
    "params": {
      "requestType": "decryptFrom",
      "secretPhrase": "string",
      "privateKey": "string",
      "account": "string",
      "data": "string",
      "nonce": "string",
      "decryptedMessageIsText": true,
      "uncompressDecryptedMessage": true
    },
    "id": 1
  }'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "decryptFrom",
      "params": {
        "requestType": "decryptFrom",
        "secretPhrase": "string",
        "privateKey": "string",
        "account": "string",
        "data": "string",
        "nonce": "string",
        "decryptedMessageIsText": true,
        "uncompressDecryptedMessage": true
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "decryptFrom",
  "params": {
    "requestType": "decryptFrom",
    "secretPhrase": "string",
    "privateKey": "string",
    "account": "string",
    "data": "string",
    "nonce": "string",
    "decryptedMessageIsText": True,
    "uncompressDecryptedMessage": True
  },
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "decryptFrom",
  "params": {
    "requestType": "decryptFrom",
    "secretPhrase": "string",
    "privateKey": "string",
    "account": "string",
    "data": "string",
    "nonce": "string",
    "decryptedMessageIsText": true,
    "uncompressDecryptedMessage": true
  },
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "decryptedMessage": "string",
    "requestProcessingTime": 0
  }
}

downloadPrunableMessage

Downloading a prunable message attachments directly as binary data

POST

https://ardr.nownodes.io/nxt

Body

application/json

jsonrpcstringrequired

methodstringrequired

paramsobjectrequired

Show child attributes

requestTypestring

chaininteger

The chain related to the message

transactionstring

The transaction ID

secretPhrasestring

The secret passphrase used to decrypt the encrypted part of the message

privateKeystring

The privateKey (hex) of the derived account

sharedKeystring

The shared key used to decrypt the message

retrieveboolean

True to retrieve the message from archival node if needed

requireBlockstring

The block ID of a block that must be present in the blockchain during execution

requireLastBlockstring

The block ID of a block that must be last in the blockchain during execution

idintegerrequired

Response

200OK

Prunable data as a binary file

400Bad Request

Bad Request

401Unauthorized

Unauthorized — Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Downloading a prunable message attachments directly as binary data

curl -X POST 'https://ardr.nownodes.io/nxt' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "downloadPrunableMessage",
    "params": {
      "requestType": "downloadPrunableMessage",
      "chain": 0,
      "transaction": "string",
      "secretPhrase": "string",
      "privateKey": "string",
      "sharedKey": "string",
      "retrieve": true,
      "requireBlock": "string",
      "requireLastBlock": "string"
    },
    "id": 1
  }'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "downloadPrunableMessage",
      "params": {
        "requestType": "downloadPrunableMessage",
        "chain": 0,
        "transaction": "string",
        "secretPhrase": "string",
        "privateKey": "string",
        "sharedKey": "string",
        "retrieve": true,
        "requireBlock": "string",
        "requireLastBlock": "string"
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "downloadPrunableMessage",
  "params": {
    "requestType": "downloadPrunableMessage",
    "chain": 0,
    "transaction": "string",
    "secretPhrase": "string",
    "privateKey": "string",
    "sharedKey": "string",
    "retrieve": True,
    "requireBlock": "string",
    "requireLastBlock": "string"
  },
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "downloadPrunableMessage",
  "params": {
    "requestType": "downloadPrunableMessage",
    "chain": 0,
    "transaction": "string",
    "secretPhrase": "string",
    "privateKey": "string",
    "sharedKey": "string",
    "retrieve": true,
    "requireBlock": "string",
    "requireLastBlock": "string"
  },
  "id": 1
}

200

"<binary>"

encryptTo

Encrypt a message using AES without sending it

POST

https://ardr.nownodes.io/nxt

Body

application/json

jsonrpcstringrequired

methodstringrequired

paramsobjectrequired

Show child attributes

requestTypestring

secretPhrasestring

The secret passphrase of the sender

privateKeystring

The privateKey (hex) of the derived account

recipientstring

The account ID of the recipient

messageToEncryptstring

Either UTF-8 text or a string of hex digits to be compressed and converted into a 1000 byte maximum bytecode then encrypted using AES

messageToEncryptIsTextboolean

False if the message to encrypt is a hex string, otherwise the message to encrypt is text

compressMessageToEncryptboolean

False to prevent gzip compression before encryption

idintegerrequired

Response

200OK

Message encrypted successfully

400Bad Request

Bad Request

401Unauthorized

Unauthorized — Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Encrypt a message using AES without sending it

curl -X POST 'https://ardr.nownodes.io/nxt' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "encryptTo",
    "params": {
      "requestType": "encryptTo",
      "secretPhrase": "string",
      "privateKey": "string",
      "recipient": "string",
      "messageToEncrypt": "string",
      "messageToEncryptIsText": true,
      "compressMessageToEncrypt": true
    },
    "id": 1
  }'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "encryptTo",
      "params": {
        "requestType": "encryptTo",
        "secretPhrase": "string",
        "privateKey": "string",
        "recipient": "string",
        "messageToEncrypt": "string",
        "messageToEncryptIsText": true,
        "compressMessageToEncrypt": true
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "encryptTo",
  "params": {
    "requestType": "encryptTo",
    "secretPhrase": "string",
    "privateKey": "string",
    "recipient": "string",
    "messageToEncrypt": "string",
    "messageToEncryptIsText": True,
    "compressMessageToEncrypt": True
  },
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "encryptTo",
  "params": {
    "requestType": "encryptTo",
    "secretPhrase": "string",
    "privateKey": "string",
    "recipient": "string",
    "messageToEncrypt": "string",
    "messageToEncryptIsText": true,
    "compressMessageToEncrypt": true
  },
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "data": "string",
    "nonce": "string",
    "requestProcessingTime": 0
  }
}

getAllPrunableMessages

Get all available prunable messages in reverse block timestamp order

POST

https://ardr.nownodes.io/nxt

Body

application/json

jsonrpcstringrequired

methodstringrequired

paramsobjectrequired

Show child attributes

requestTypestring

chaininteger

The chain related to the messages

timestampinteger

The earliest message (in seconds since the genesis block) to retrieve

firstIndexinteger

A zero-based index to the first prunable message to retrieve

lastIndexinteger

A zero-based index to the last prunable message to retrieve

requireBlockstring

The block ID of a block that must be present in the blockchain during execution

requireLastBlockstring

The block ID of a block that must be last in the blockchain during execution

idintegerrequired

Response

200OK

All prunable messages retrieved successfully

400Bad Request

Bad Request

401Unauthorized

Unauthorized — Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Get all available prunable messages in reverse block timestamp order

curl -X POST 'https://ardr.nownodes.io/nxt' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "getAllPrunableMessages",
    "params": {
      "requestType": "getAllPrunableMessages",
      "chain": 0,
      "timestamp": 0,
      "firstIndex": 0,
      "lastIndex": 0,
      "requireBlock": "string",
      "requireLastBlock": "string"
    },
    "id": 1
  }'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "getAllPrunableMessages",
      "params": {
        "requestType": "getAllPrunableMessages",
        "chain": 0,
        "timestamp": 0,
        "firstIndex": 0,
        "lastIndex": 0,
        "requireBlock": "string",
        "requireLastBlock": "string"
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "getAllPrunableMessages",
  "params": {
    "requestType": "getAllPrunableMessages",
    "chain": 0,
    "timestamp": 0,
    "firstIndex": 0,
    "lastIndex": 0,
    "requireBlock": "string",
    "requireLastBlock": "string"
  },
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "getAllPrunableMessages",
  "params": {
    "requestType": "getAllPrunableMessages",
    "chain": 0,
    "timestamp": 0,
    "firstIndex": 0,
    "lastIndex": 0,
    "requireBlock": "string",
    "requireLastBlock": "string"
  },
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "prunableMessages": [
      {
        "senderRS": "string",
        "sender": "string",
        "recipientRS": "string",
        "recipient": "string",
        "blockTimestamp": 0,
        "message": "string",
        "transaction": "string",
        "isText": true,
        "transactionTimestamp": 0
      }
    ],
    "lastBlock": "string",
    "requestProcessingTime": 0
  }
}

getPrunableMessage

Get the prunable message given a transaction ID, optionally decrypting it if encrypted

POST

https://ardr.nownodes.io/nxt

Body

application/json

jsonrpcstringrequired

methodstringrequired

paramsobjectrequired

Show child attributes

requestTypestring

chaininteger

The chain related to the message

transactionFullHashstring

The transaction Full Hash

secretPhrasestring

The secret phrase needed for decryption

privateKeystring

The privateKey (hex) of the derived account

sharedKeystring

The shared key used to decrypt the message

retrieveboolean

True to retrieve pruned data from other nodes if not available

requireBlockstring

The block ID of a block that must be present in the blockchain during execution

requireLastBlockstring

The block ID of a block that must be last in the blockchain during execution

idintegerrequired

Response

200OK

Prunable message retrieved successfully

400Bad Request

Bad Request

401Unauthorized

Unauthorized — Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Get the prunable message given a transaction ID, optionally decrypting it if encrypted

curl -X POST 'https://ardr.nownodes.io/nxt' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "getPrunableMessage",
    "params": {
      "requestType": "getPrunableMessage",
      "chain": 0,
      "transactionFullHash": "string",
      "secretPhrase": "string",
      "privateKey": "string",
      "sharedKey": "string",
      "retrieve": true,
      "requireBlock": "string",
      "requireLastBlock": "string"
    },
    "id": 1
  }'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "getPrunableMessage",
      "params": {
        "requestType": "getPrunableMessage",
        "chain": 0,
        "transactionFullHash": "string",
        "secretPhrase": "string",
        "privateKey": "string",
        "sharedKey": "string",
        "retrieve": true,
        "requireBlock": "string",
        "requireLastBlock": "string"
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "getPrunableMessage",
  "params": {
    "requestType": "getPrunableMessage",
    "chain": 0,
    "transactionFullHash": "string",
    "secretPhrase": "string",
    "privateKey": "string",
    "sharedKey": "string",
    "retrieve": True,
    "requireBlock": "string",
    "requireLastBlock": "string"
  },
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "getPrunableMessage",
  "params": {
    "requestType": "getPrunableMessage",
    "chain": 0,
    "transactionFullHash": "string",
    "secretPhrase": "string",
    "privateKey": "string",
    "sharedKey": "string",
    "retrieve": true,
    "requireBlock": "string",
    "requireLastBlock": "string"
  },
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "sender": "string",
    "senderRS": "string",
    "recipient": "string",
    "recipientRS": "string",
    "message": "string",
    "messageIsText": true,
    "encryptedMessage": {
      "data": "string",
      "nonce": "string"
    },
    "encryptedMessageIsText": true,
    "decryptedMessage": "string",
    "isCompressed": true,
    "transaction": "string",
    "transactionTimestamp": 0,
    "blockTimestamp": 0,
    "lastBlock": "string",
    "requestProcessingTime": 0
  }
}

getSharedKey

Get the one-time shared key used for encryption of messages

POST

https://ardr.nownodes.io/nxt

Body

application/json

jsonrpcstringrequired

methodstringrequired

paramsobjectrequired

Show child attributes

requestTypestring

accountstring

The recipient account ID

secretPhrasestring

The secret phrase of the sender

privateKeystring

The privateKey (hex) of the derived account

noncestring

The 32-byte pseudorandom nonce

idintegerrequired

Response

200OK

Shared key retrieved successfully

400Bad Request

Bad Request

401Unauthorized

Unauthorized — Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Get the one-time shared key used for encryption of messages

curl -X POST 'https://ardr.nownodes.io/nxt' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "getSharedKey",
    "params": {
      "requestType": "getSharedKey",
      "account": "string",
      "secretPhrase": "string",
      "privateKey": "string",
      "nonce": "string"
    },
    "id": 1
  }'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "getSharedKey",
      "params": {
        "requestType": "getSharedKey",
        "account": "string",
        "secretPhrase": "string",
        "privateKey": "string",
        "nonce": "string"
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "getSharedKey",
  "params": {
    "requestType": "getSharedKey",
    "account": "string",
    "secretPhrase": "string",
    "privateKey": "string",
    "nonce": "string"
  },
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "getSharedKey",
  "params": {
    "requestType": "getSharedKey",
    "account": "string",
    "secretPhrase": "string",
    "privateKey": "string",
    "nonce": "string"
  },
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "sharedKey": "string",
    "requestProcessingTime": 0
  }
}

readMessage

Get a message given a transaction ID

POST

https://ardr.nownodes.io/nxt

Body

application/json

jsonrpcstringrequired

methodstringrequired

paramsobjectrequired

Show child attributes

requestTypestring

chaininteger

The chain related to the message

transactionstring

The transaction ID of the message

secretPhrasestring

The secret passphrase of the account that received the message

privateKeystring

The privateKey (hex) of the derived account

sharedKeystring

The shared key used to decrypt the message

retrieveboolean

True to retrieve pruned data from archival nodes

requireBlockstring

The block ID of a block that must be present in the blockchain during execution

requireLastBlockstring

The block ID of a block that must be last in the blockchain during execution

idintegerrequired

Response

200OK

Message retrieved successfully

400Bad Request

Bad Request

401Unauthorized

Unauthorized — Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Get a message given a transaction ID

curl -X POST 'https://ardr.nownodes.io/nxt' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "readMessage",
    "params": {
      "requestType": "readMessage",
      "chain": 0,
      "transaction": "string",
      "secretPhrase": "string",
      "privateKey": "string",
      "sharedKey": "string",
      "retrieve": true,
      "requireBlock": "string",
      "requireLastBlock": "string"
    },
    "id": 1
  }'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "readMessage",
      "params": {
        "requestType": "readMessage",
        "chain": 0,
        "transaction": "string",
        "secretPhrase": "string",
        "privateKey": "string",
        "sharedKey": "string",
        "retrieve": true,
        "requireBlock": "string",
        "requireLastBlock": "string"
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "readMessage",
  "params": {
    "requestType": "readMessage",
    "chain": 0,
    "transaction": "string",
    "secretPhrase": "string",
    "privateKey": "string",
    "sharedKey": "string",
    "retrieve": True,
    "requireBlock": "string",
    "requireLastBlock": "string"
  },
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "readMessage",
  "params": {
    "requestType": "readMessage",
    "chain": 0,
    "transaction": "string",
    "secretPhrase": "string",
    "privateKey": "string",
    "sharedKey": "string",
    "retrieve": true,
    "requireBlock": "string",
    "requireLastBlock": "string"
  },
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "messageIsPrunable": true,
    "message": "string",
    "encryptedMessageIsPrunable": true,
    "decryptedMessage": "string",
    "decryptedMessageToSelf": "string",
    "lastBlock": "string",
    "requestProcessingTime": 0
  }
}

sendMessage

Create an Arbitrary Message transaction

POST

https://ardr.nownodes.io/nxt

Body

application/json

jsonrpcstringrequired

methodstringrequired

paramsobjectrequired

Show child attributes

requestTypestring

chaininteger

The chain for the message to be sent

recipientstring

The account ID of the recipient

recipientPublicKeystring

The public key of the receiving account

messagestring

Either UTF-8 text or a string of hex digits to be converted into a bytecode with a maximum length of one kilobyte, 42 kilobytes if prunable

messageIsTextboolean

False if the message is a hex string, otherwise the message is text

messageIsPrunableboolean

True if the message is prunable

messageToEncryptstring

Either UTF-8 text or a string of hex digits to be compressed and converted into a bytecode with a maximum length of one kilobyte, 42 kilobytes if prunable, then encrypted using AES

messageToEncryptIsTextboolean

False if the message to encrypt is a hex string, otherwise the message to encrypt is text

encryptedMessageDatastring

Already encrypted data which overrides messageToEncrypt if provided

encryptedMessageNoncestring

A unique 32-byte number which cannot be reused

encryptedMessageIsPrunableboolean

True if the encrypted message is prunable

compressMessageToEncryptboolean

False to prevent gzip compression before encryption

messageToEncryptToSelfstring

Either UTF-8 text or a string of hex digits to be compressed and converted into a one kilobyte maximum bytecode then encrypted with AES, then sent to the sending account

messageToEncryptToSelfIsTextboolean

False if the message to self-encrypt is a hex string, otherwise the message to encrypt is text

encryptToSelfMessageDatastring

Already encrypted data which overrides messageToEncryptToSelf if provided

encryptToSelfMessageNoncestring

A unique 32-byte number which cannot be reused

compressMessageToEncryptToSelfboolean

False to prevent gzip compression before encryption

idintegerrequired

Response

200OK

Message sent successfully

400Bad Request

Bad Request

401Unauthorized

Unauthorized — Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Create an Arbitrary Message transaction

curl -X POST 'https://ardr.nownodes.io/nxt' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "sendMessage",
    "params": {
      "requestType": "sendMessage",
      "chain": 0,
      "recipient": "string",
      "recipientPublicKey": "string",
      "message": "string",
      "messageIsText": true,
      "messageIsPrunable": true,
      "messageToEncrypt": "string",
      "messageToEncryptIsText": true,
      "encryptedMessageData": "string",
      "encryptedMessageNonce": "string",
      "encryptedMessageIsPrunable": true,
      "compressMessageToEncrypt": true,
      "messageToEncryptToSelf": "string",
      "messageToEncryptToSelfIsText": true,
      "encryptToSelfMessageData": "string",
      "encryptToSelfMessageNonce": "string",
      "compressMessageToEncryptToSelf": true
    },
    "id": 1
  }'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "sendMessage",
      "params": {
        "requestType": "sendMessage",
        "chain": 0,
        "recipient": "string",
        "recipientPublicKey": "string",
        "message": "string",
        "messageIsText": true,
        "messageIsPrunable": true,
        "messageToEncrypt": "string",
        "messageToEncryptIsText": true,
        "encryptedMessageData": "string",
        "encryptedMessageNonce": "string",
        "encryptedMessageIsPrunable": true,
        "compressMessageToEncrypt": true,
        "messageToEncryptToSelf": "string",
        "messageToEncryptToSelfIsText": true,
        "encryptToSelfMessageData": "string",
        "encryptToSelfMessageNonce": "string",
        "compressMessageToEncryptToSelf": true
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "sendMessage",
  "params": {
    "requestType": "sendMessage",
    "chain": 0,
    "recipient": "string",
    "recipientPublicKey": "string",
    "message": "string",
    "messageIsText": True,
    "messageIsPrunable": True,
    "messageToEncrypt": "string",
    "messageToEncryptIsText": True,
    "encryptedMessageData": "string",
    "encryptedMessageNonce": "string",
    "encryptedMessageIsPrunable": True,
    "compressMessageToEncrypt": True,
    "messageToEncryptToSelf": "string",
    "messageToEncryptToSelfIsText": True,
    "encryptToSelfMessageData": "string",
    "encryptToSelfMessageNonce": "string",
    "compressMessageToEncryptToSelf": True
  },
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "sendMessage",
  "params": {
    "requestType": "sendMessage",
    "chain": 0,
    "recipient": "string",
    "recipientPublicKey": "string",
    "message": "string",
    "messageIsText": true,
    "messageIsPrunable": true,
    "messageToEncrypt": "string",
    "messageToEncryptIsText": true,
    "encryptedMessageData": "string",
    "encryptedMessageNonce": "string",
    "encryptedMessageIsPrunable": true,
    "compressMessageToEncrypt": true,
    "messageToEncryptToSelf": "string",
    "messageToEncryptToSelfIsText": true,
    "encryptToSelfMessageData": "string",
    "encryptToSelfMessageNonce": "string",
    "compressMessageToEncryptToSelf": true
  },
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "signatureHash": "string",
    "unsignedTransactionBytes": "string",
    "transactionJSON": {
      "senderPublicKey": "string",
      "chain": 0,
      "signature": "string",
      "feeNQT": "string",
      "type": 0,
      "fullHash": "string",
      "version": 0,
      "ecBlockId": "string",
      "signatureHash": "string",
      "attachment": {
        "version.Message": 0,
        "messageIsText": true,
        "message": "string"
      },
      "senderRS": "string",
      "subtype": 0,
      "amountNQT": "string",
      "sender": "string",
      "recipientRS": "string",
      "recipient": "string",
      "ecBlockHeight": 0,
      "deadline": 0,
      "transaction": "string",
      "timestamp": 0,
      "height": 0
    },
    "broadcasted": true,
    "requestProcessingTime": 0,
    "transactionBytes": "string",
    "fullHash": "string",
    "transaction": "string"
  }
}

verifyPrunableMessage

Verify that a prunable message obtained from any source, when hashed, matches the hash of the original prunable message

POST

https://ardr.nownodes.io/nxt

Body

application/json

jsonrpcstringrequired

methodstringrequired

paramsobjectrequired

Show child attributes

requestTypestring

chaininteger

The chain for the message to be verified

messagestring

The plain message, if applicable

messageIsTextboolean

False if the provided plain message is a hex string

encryptedMessageDatastring

The data part of the encrypted data-nonce pair

encryptedMessageNoncestring

The nonce part of the encrypted data-nonce pair

messageToEncryptIsTextboolean

False if the encrypted message was a hex string before encryption

compressMessageToEncryptboolean

False if the encrypted message was not compressed before encryption

requireBlockstring

The block ID of a block that must be present in the blockchain during execution

requireLastBlockstring

The block ID of a block that must be last in the blockchain during execution

idintegerrequired

Response

200OK

Prunable message verification result

400Bad Request

Bad Request

401Unauthorized

Unauthorized — Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Verify that a prunable message obtained from any source, when hashed, matches the hash of the original prunable message

curl -X POST 'https://ardr.nownodes.io/nxt' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "verifyPrunableMessage",
    "params": {
      "requestType": "verifyPrunableMessage",
      "chain": 0,
      "message": "string",
      "messageIsText": true,
      "encryptedMessageData": "string",
      "encryptedMessageNonce": "string",
      "messageToEncryptIsText": true,
      "compressMessageToEncrypt": true,
      "requireBlock": "string",
      "requireLastBlock": "string"
    },
    "id": 1
  }'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "verifyPrunableMessage",
      "params": {
        "requestType": "verifyPrunableMessage",
        "chain": 0,
        "message": "string",
        "messageIsText": true,
        "encryptedMessageData": "string",
        "encryptedMessageNonce": "string",
        "messageToEncryptIsText": true,
        "compressMessageToEncrypt": true,
        "requireBlock": "string",
        "requireLastBlock": "string"
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "verifyPrunableMessage",
  "params": {
    "requestType": "verifyPrunableMessage",
    "chain": 0,
    "message": "string",
    "messageIsText": True,
    "encryptedMessageData": "string",
    "encryptedMessageNonce": "string",
    "messageToEncryptIsText": True,
    "compressMessageToEncrypt": True,
    "requireBlock": "string",
    "requireLastBlock": "string"
  },
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "verifyPrunableMessage",
  "params": {
    "requestType": "verifyPrunableMessage",
    "chain": 0,
    "message": "string",
    "messageIsText": true,
    "encryptedMessageData": "string",
    "encryptedMessageNonce": "string",
    "messageToEncryptIsText": true,
    "compressMessageToEncrypt": true,
    "requireBlock": "string",
    "requireLastBlock": "string"
  },
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "version.PrunablePlainMessage": 0,
    "version.PrunableEncryptedMessage": 0,
    "verify": true,
    "message": "string",
    "encryptedMessage": {
      "data": "string",
      "nonce": "string",
      "isText": true,
      "isCompressed": true
    },
    "messageIsText": true,
    "messageHash": "string",
    "encryptedMessageHash": "string",
    "lastBlock": "string",
    "requestProcessingTime": 0
  }
}

Monetary System

canDeleteCurrency

Determine if a currency can be deleted

POST

https://ardr.nownodes.io/nxt

Body

application/json

jsonrpcstringrequired

methodstringrequired

paramsobjectrequired

Show child attributes

requestTypestring

accountstring

The account ID

currencystring

The currency ID

requireBlockstring

The block ID of a block that must be present in the blockchain during execution

requireLastBlockstring

The block ID of a block that must be last in the blockchain during execution

idintegerrequired

Response

200OK

Currency deletion capability check result

400Bad Request

Bad Request

401Unauthorized

Unauthorized — Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Determine if a currency can be deleted

curl -X POST 'https://ardr.nownodes.io/nxt' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "canDeleteCurrency",
    "params": {
      "requestType": "canDeleteCurrency",
      "account": "string",
      "currency": "string",
      "requireBlock": "string",
      "requireLastBlock": "string"
    },
    "id": 1
  }'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "canDeleteCurrency",
      "params": {
        "requestType": "canDeleteCurrency",
        "account": "string",
        "currency": "string",
        "requireBlock": "string",
        "requireLastBlock": "string"
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "canDeleteCurrency",
  "params": {
    "requestType": "canDeleteCurrency",
    "account": "string",
    "currency": "string",
    "requireBlock": "string",
    "requireLastBlock": "string"
  },
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "canDeleteCurrency",
  "params": {
    "requestType": "canDeleteCurrency",
    "account": "string",
    "currency": "string",
    "requireBlock": "string",
    "requireLastBlock": "string"
  },
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "canDelete": true,
    "lastBlock": "string",
    "requestProcessingTime": 0
  }
}

currencyBuy

Make an exchange request to buy an exchangeable currency

POST

https://ardr.nownodes.io/nxt

Body

application/json

jsonrpcstringrequired

methodstringrequired

paramsobjectrequired

Show child attributes

requestTypestring

chaininteger

The chain related to the operation

currencystring

The currency ID

rateNQTPerUnitstring

The exchange rate (in NQT per unit)

unitsQNTstring

The amount of the currency to buy (in QNT)

idintegerrequired

Response

200OK

Currency buy request created successfully

400Bad Request

Bad Request

401Unauthorized

Unauthorized — Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Make an exchange request to buy an exchangeable currency

curl -X POST 'https://ardr.nownodes.io/nxt' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "currencyBuy",
    "params": {
      "requestType": "currencyBuy",
      "chain": 0,
      "currency": "string",
      "rateNQTPerUnit": "string",
      "unitsQNT": "string"
    },
    "id": 1
  }'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "currencyBuy",
      "params": {
        "requestType": "currencyBuy",
        "chain": 0,
        "currency": "string",
        "rateNQTPerUnit": "string",
        "unitsQNT": "string"
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "currencyBuy",
  "params": {
    "requestType": "currencyBuy",
    "chain": 0,
    "currency": "string",
    "rateNQTPerUnit": "string",
    "unitsQNT": "string"
  },
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "currencyBuy",
  "params": {
    "requestType": "currencyBuy",
    "chain": 0,
    "currency": "string",
    "rateNQTPerUnit": "string",
    "unitsQNT": "string"
  },
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "signatureHash": "string",
    "unsignedTransactionBytes": "string",
    "transactionJSON": {
      "senderPublicKey": "string",
      "chain": 0,
      "signature": "string",
      "feeNQT": "string",
      "type": 0,
      "fullHash": "string",
      "version": 0,
      "fxtTransaction": "string",
      "phased": true,
      "ecBlockId": "string",
      "signatureHash": "string",
      "attachment": {
        "currency": "string",
        "version.ExchangeBuy": 0,
        "unitsQNT": "string",
        "rateNQTPerUnit": "string"
      },
      "senderRS": "string",
      "subtype": 0,
      "amountNQT": "string",
      "sender": "string",
      "ecBlockHeight": 0,
      "deadline": 0,
      "transaction": "string",
      "timestamp": 0,
      "height": 0
    },
    "broadcasted": true,
    "requestProcessingTime": 0,
    "transactionBytes": "string",
    "fullHash": "string",
    "transaction": "string",
    "bundlerRateNQTPerFXT": "string"
  }
}

currencyMint

Submit a valid computed nonce to the blockchain in return for newly minted currency

POST

https://ardr.nownodes.io/nxt

Body

application/json

jsonrpcstringrequired

methodstringrequired

paramsobjectrequired

Show child attributes

requestTypestring

chaininteger

The chain related to the operation

currencystring

The mintable currency ID

noncestring

The computed nonce

unitsQNTstring

The amount (in QNT) of currency to mint

counterinteger

The counter associated with the minting account

idintegerrequired

Response

200OK

Currency minting request created successfully

400Bad Request

Bad Request

401Unauthorized

Unauthorized — Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Submit a valid computed nonce to the blockchain in return for newly minted currency

curl -X POST 'https://ardr.nownodes.io/nxt' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "currencyMint",
    "params": {
      "requestType": "currencyMint",
      "chain": 0,
      "currency": "string",
      "nonce": "string",
      "unitsQNT": "string",
      "counter": 0
    },
    "id": 1
  }'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "currencyMint",
      "params": {
        "requestType": "currencyMint",
        "chain": 0,
        "currency": "string",
        "nonce": "string",
        "unitsQNT": "string",
        "counter": 0
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "currencyMint",
  "params": {
    "requestType": "currencyMint",
    "chain": 0,
    "currency": "string",
    "nonce": "string",
    "unitsQNT": "string",
    "counter": 0
  },
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "currencyMint",
  "params": {
    "requestType": "currencyMint",
    "chain": 0,
    "currency": "string",
    "nonce": "string",
    "unitsQNT": "string",
    "counter": 0
  },
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "signatureHash": "string",
    "unsignedTransactionBytes": "string",
    "transactionJSON": {
      "senderPublicKey": "string",
      "chain": 0,
      "signature": "string",
      "feeNQT": "string",
      "type": 0,
      "fullHash": "string",
      "version": 0,
      "ecBlockId": "string",
      "signatureHash": "string",
      "attachment": {
        "currency": "string",
        "unitsQNT": "string",
        "counter": "string",
        "version.CurrencyMinting": 0,
        "nonce": "string"
      },
      "senderRS": "string",
      "subtype": 0,
      "amountNQT": "string",
      "sender": "string",
      "ecBlockHeight": 0,
      "deadline": 0,
      "transaction": "string",
      "timestamp": 0,
      "height": 0
    },
    "broadcasted": true,
    "requestProcessingTime": 0,
    "transactionBytes": "string",
    "fullHash": "string",
    "transaction": "string"
  }
}

currencyReserveClaim

Claim currency reserve

POST

https://ardr.nownodes.io/nxt

Body

application/json

jsonrpcstringrequired

methodstringrequired

paramsobjectrequired

Show child attributes

requestTypestring

chaininteger

The chain related to the operation

currencystring

The currency ID

unitsQNTstring

The amount (in QNT) of reserve currency to claim

idintegerrequired

Response

200OK

Currency reserve claim created successfully

400Bad Request

Bad Request

401Unauthorized

Unauthorized — Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Claim currency reserve

curl -X POST 'https://ardr.nownodes.io/nxt' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "currencyReserveClaim",
    "params": {
      "requestType": "currencyReserveClaim",
      "chain": 0,
      "currency": "string",
      "unitsQNT": "string"
    },
    "id": 1
  }'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "currencyReserveClaim",
      "params": {
        "requestType": "currencyReserveClaim",
        "chain": 0,
        "currency": "string",
        "unitsQNT": "string"
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "currencyReserveClaim",
  "params": {
    "requestType": "currencyReserveClaim",
    "chain": 0,
    "currency": "string",
    "unitsQNT": "string"
  },
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "currencyReserveClaim",
  "params": {
    "requestType": "currencyReserveClaim",
    "chain": 0,
    "currency": "string",
    "unitsQNT": "string"
  },
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "signatureHash": "string",
    "unsignedTransactionBytes": "string",
    "transactionJSON": {
      "senderPublicKey": "string",
      "chain": 0,
      "signature": "string",
      "feeNQT": "string",
      "type": 0,
      "fullHash": "string",
      "version": 0,
      "ecBlockId": "string",
      "signatureHash": "string",
      "attachment": {
        "version.ReserveClaim": 0,
        "currency": "string",
        "unitsQNT": "string"
      },
      "senderRS": "string",
      "subtype": 0,
      "amountNQT": "string",
      "sender": "string",
      "ecBlockHeight": 0,
      "deadline": 0,
      "transaction": "string",
      "timestamp": 0,
      "height": 0
    },
    "broadcasted": true,
    "requestProcessingTime": 0,
    "transactionBytes": "string",
    "fullHash": "string",
    "transaction": "string"
  }
}

currencyReserveIncrease

Increase the currency reserve of an unissued reservable currency

POST

https://ardr.nownodes.io/nxt

Body

application/json

jsonrpcstringrequired

methodstringrequired

paramsobjectrequired

Show child attributes

requestTypestring

chaininteger

The chain related to the operation

currencystring

The currency ID

amountPerUnitNQTstring

The additional amount (in NQT per QNT of reserveSupply) to reserve

idintegerrequired

Response

200OK

Currency reserve increase created successfully

400Bad Request

Bad Request

401Unauthorized

Unauthorized — Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Increase the currency reserve of an unissued reservable currency

curl -X POST 'https://ardr.nownodes.io/nxt' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "currencyReserveIncrease",
    "params": {
      "requestType": "currencyReserveIncrease",
      "chain": 0,
      "currency": "string",
      "amountPerUnitNQT": "string"
    },
    "id": 1
  }'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "currencyReserveIncrease",
      "params": {
        "requestType": "currencyReserveIncrease",
        "chain": 0,
        "currency": "string",
        "amountPerUnitNQT": "string"
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "currencyReserveIncrease",
  "params": {
    "requestType": "currencyReserveIncrease",
    "chain": 0,
    "currency": "string",
    "amountPerUnitNQT": "string"
  },
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "currencyReserveIncrease",
  "params": {
    "requestType": "currencyReserveIncrease",
    "chain": 0,
    "currency": "string",
    "amountPerUnitNQT": "string"
  },
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "signatureHash": "string",
    "unsignedTransactionBytes": "string",
    "transactionJSON": {
      "senderPublicKey": "string",
      "chain": 0,
      "signature": "string",
      "feeNQT": "string",
      "type": 0,
      "fullHash": "string",
      "version": 0,
      "ecBlockId": "string",
      "signatureHash": "string",
      "attachment": {
        "amountPerUnitNQT": "string",
        "currency": "string",
        "version.ReserveIncrease": 0
      },
      "senderRS": "string",
      "subtype": 0,
      "amountNQT": "string",
      "sender": "string",
      "ecBlockHeight": 0,
      "deadline": 0,
      "transaction": "string",
      "timestamp": 0,
      "height": 0
    },
    "broadcasted": true,
    "requestProcessingTime": 0,
    "transactionBytes": "string",
    "fullHash": "string",
    "transaction": "string"
  }
}

currencySell

Make an exchange request to sell an exchangeable currency

POST

https://ardr.nownodes.io/nxt

Body

application/json

jsonrpcstringrequired

methodstringrequired

paramsobjectrequired

Show child attributes

requestTypestring

chaininteger

The chain related to the operation

currencystring

The currency ID

rateNQTPerUnitstring

The exchange rate (in NQT per unit)

unitsQNTstring

The amount of the currency to sell (in QNT)

idintegerrequired

Response

200OK

Currency sell request created successfully

400Bad Request

Bad Request

401Unauthorized

Unauthorized — Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Make an exchange request to sell an exchangeable currency

curl -X POST 'https://ardr.nownodes.io/nxt' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "currencySell",
    "params": {
      "requestType": "currencySell",
      "chain": 0,
      "currency": "string",
      "rateNQTPerUnit": "string",
      "unitsQNT": "string"
    },
    "id": 1
  }'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "currencySell",
      "params": {
        "requestType": "currencySell",
        "chain": 0,
        "currency": "string",
        "rateNQTPerUnit": "string",
        "unitsQNT": "string"
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "currencySell",
  "params": {
    "requestType": "currencySell",
    "chain": 0,
    "currency": "string",
    "rateNQTPerUnit": "string",
    "unitsQNT": "string"
  },
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "currencySell",
  "params": {
    "requestType": "currencySell",
    "chain": 0,
    "currency": "string",
    "rateNQTPerUnit": "string",
    "unitsQNT": "string"
  },
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "signatureHash": "string",
    "unsignedTransactionBytes": "string",
    "transactionJSON": {
      "senderPublicKey": "string",
      "chain": 0,
      "signature": "string",
      "feeNQT": "string",
      "type": 0,
      "fullHash": "string",
      "version": 0,
      "fxtTransaction": "string",
      "phased": true,
      "ecBlockId": "string",
      "signatureHash": "string",
      "attachment": {
        "currency": "string",
        "version.ExchangeSell": 0,
        "unitsQNT": "string",
        "rateNQTPerUnit": "string"
      },
      "senderRS": "string",
      "subtype": 0,
      "amountNQT": "string",
      "sender": "string",
      "ecBlockHeight": 0,
      "deadline": 0,
      "transaction": "string",
      "timestamp": 0,
      "height": 0
    },
    "broadcasted": true,
    "requestProcessingTime": 0,
    "transactionBytes": "string",
    "fullHash": "string",
    "transaction": "string",
    "bundlerRateNQTPerFXT": "string"
  }
}

deleteCurrency

Delete a deletable currency

POST

https://ardr.nownodes.io/nxt

Body

application/json

jsonrpcstringrequired

methodstringrequired

paramsobjectrequired

Show child attributes

requestTypestring

chaininteger

The chain related to the operation

currencystring

The currency ID

idintegerrequired

Response

200OK

Currency deletion request created successfully

400Bad Request

Bad Request

401Unauthorized

Unauthorized — Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Delete a deletable currency

curl -X POST 'https://ardr.nownodes.io/nxt' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "deleteCurrency",
    "params": {
      "requestType": "deleteCurrency",
      "chain": 0,
      "currency": "string"
    },
    "id": 1
  }'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "deleteCurrency",
      "params": {
        "requestType": "deleteCurrency",
        "chain": 0,
        "currency": "string"
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "deleteCurrency",
  "params": {
    "requestType": "deleteCurrency",
    "chain": 0,
    "currency": "string"
  },
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "deleteCurrency",
  "params": {
    "requestType": "deleteCurrency",
    "chain": 0,
    "currency": "string"
  },
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "signatureHash": "string",
    "unsignedTransactionBytes": "string",
    "transactionJSON": {
      "senderPublicKey": "string",
      "chain": 0,
      "signature": "string",
      "feeNQT": "string",
      "type": 0,
      "fullHash": "string",
      "version": 0,
      "ecBlockId": "string",
      "signatureHash": "string",
      "attachment": {
        "version.CurrencyDeletion": 0,
        "currency": "string"
      },
      "senderRS": "string",
      "subtype": 0,
      "amountNQT": "string",
      "sender": "string",
      "ecBlockHeight": 0,
      "deadline": 0,
      "transaction": "string",
      "timestamp": 0,
      "height": 0
    },
    "broadcasted": true,
    "requestProcessingTime": 0,
    "transactionBytes": "string",
    "fullHash": "string",
    "transaction": "string"
  }
}

getAccountCurrencies

Get the currencies issued by a given account

POST

https://ardr.nownodes.io/nxt

Body

application/json

jsonrpcstringrequired

methodstringrequired

paramsobjectrequired

Show child attributes

requestTypestring

accountstring

The account ID

currencystring

A currency ID filter

heightinteger

The blockchain height at which the response applies

includeCurrencyInfoboolean

True if several currency information properties is to be included

requireBlockstring

The block ID of a block that must be present in the blockchain during execution

requireLastBlockstring

The block ID of a block that must be last in the blockchain during execution

idintegerrequired

Response

200OK

Account currencies retrieved successfully

400Bad Request

Bad Request

401Unauthorized

Unauthorized — Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Get the currencies issued by a given account

curl -X POST 'https://ardr.nownodes.io/nxt' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "getAccountCurrencies",
    "params": {
      "requestType": "getAccountCurrencies",
      "account": "string",
      "currency": "string",
      "height": 0,
      "includeCurrencyInfo": true,
      "requireBlock": "string",
      "requireLastBlock": "string"
    },
    "id": 1
  }'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "getAccountCurrencies",
      "params": {
        "requestType": "getAccountCurrencies",
        "account": "string",
        "currency": "string",
        "height": 0,
        "includeCurrencyInfo": true,
        "requireBlock": "string",
        "requireLastBlock": "string"
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "getAccountCurrencies",
  "params": {
    "requestType": "getAccountCurrencies",
    "account": "string",
    "currency": "string",
    "height": 0,
    "includeCurrencyInfo": True,
    "requireBlock": "string",
    "requireLastBlock": "string"
  },
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "getAccountCurrencies",
  "params": {
    "requestType": "getAccountCurrencies",
    "account": "string",
    "currency": "string",
    "height": 0,
    "includeCurrencyInfo": true,
    "requireBlock": "string",
    "requireLastBlock": "string"
  },
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "accountCurrencies": [
      {
        "code": "string",
        "unconfirmedUnits": "string",
        "decimals": 0,
        "name": "string",
        "currency": "string",
        "units": "string",
        "issuanceHeight": 0,
        "type": 0,
        "issuerAccountRS": "string",
        "issuerAccount": "string"
      }
    ],
    "lastBlock": "string",
    "requestProcessingTime": 0
  }
}

getAccountCurrencyCount

Get the number of currencies issued by a given account

POST

https://ardr.nownodes.io/nxt

Body

application/json

jsonrpcstringrequired

methodstringrequired

paramsobjectrequired

Show child attributes

requestTypestring

accountstring

The account ID

heightinteger

The blockchain height at which the response applies

requireBlockstring

The block ID of a block that must be present in the blockchain during execution

requireLastBlockstring

The block ID of a block that must be last in the blockchain during execution

idintegerrequired

Response

200OK

Account currency count retrieved successfully

400Bad Request

Bad Request

401Unauthorized

Unauthorized — Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Get the number of currencies issued by a given account

curl -X POST 'https://ardr.nownodes.io/nxt' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "getAccountCurrencyCount",
    "params": {
      "requestType": "getAccountCurrencyCount",
      "account": "string",
      "height": 0,
      "requireBlock": "string",
      "requireLastBlock": "string"
    },
    "id": 1
  }'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "getAccountCurrencyCount",
      "params": {
        "requestType": "getAccountCurrencyCount",
        "account": "string",
        "height": 0,
        "requireBlock": "string",
        "requireLastBlock": "string"
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "getAccountCurrencyCount",
  "params": {
    "requestType": "getAccountCurrencyCount",
    "account": "string",
    "height": 0,
    "requireBlock": "string",
    "requireLastBlock": "string"
  },
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "getAccountCurrencyCount",
  "params": {
    "requestType": "getAccountCurrencyCount",
    "account": "string",
    "height": 0,
    "requireBlock": "string",
    "requireLastBlock": "string"
  },
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "numberOfCurrencies": 0,
    "lastBlock": "string",
    "requestProcessingTime": 0
  }
}

getAccountExchangeRequests

Get the exchange requests associated with a given account and/or currency in reverse chronological order

POST

https://ardr.nownodes.io/nxt

Body

application/json

jsonrpcstringrequired

methodstringrequired

paramsobjectrequired

Show child attributes

requestTypestring

chaininteger

The chain related to the operation

accountstring

The account ID

currencystring

The currency ID

firstIndexinteger

A zero-based index to the first request to retrieve

lastIndexinteger

A zero-based index to the last request to retrieve

requireBlockstring

The block ID of a block that must be present in the blockchain during execution

requireLastBlockstring

The block ID of a block that must be last in the blockchain during execution

idintegerrequired

Response

200OK

Account exchange requests retrieved successfully

400Bad Request

Bad Request

401Unauthorized

Unauthorized — Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Get the exchange requests associated with a given account and/or currency in reverse chronological order

curl -X POST 'https://ardr.nownodes.io/nxt' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "getAccountExchangeRequests",
    "params": {
      "requestType": "getAccountExchangeRequests",
      "chain": 0,
      "account": "string",
      "currency": "string",
      "firstIndex": 0,
      "lastIndex": 0,
      "requireBlock": "string",
      "requireLastBlock": "string"
    },
    "id": 1
  }'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "getAccountExchangeRequests",
      "params": {
        "requestType": "getAccountExchangeRequests",
        "chain": 0,
        "account": "string",
        "currency": "string",
        "firstIndex": 0,
        "lastIndex": 0,
        "requireBlock": "string",
        "requireLastBlock": "string"
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "getAccountExchangeRequests",
  "params": {
    "requestType": "getAccountExchangeRequests",
    "chain": 0,
    "account": "string",
    "currency": "string",
    "firstIndex": 0,
    "lastIndex": 0,
    "requireBlock": "string",
    "requireLastBlock": "string"
  },
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "getAccountExchangeRequests",
  "params": {
    "requestType": "getAccountExchangeRequests",
    "chain": 0,
    "account": "string",
    "currency": "string",
    "firstIndex": 0,
    "lastIndex": 0,
    "requireBlock": "string",
    "requireLastBlock": "string"
  },
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "exchangeRequests": [
      {
        "code": "string",
        "subtype": 0,
        "decimals": 0,
        "name": "string",
        "units": "string",
        "issuanceHeight": 0,
        "type": 0,
        "transaction": "string",
        "timestamp": 0,
        "rateNQTPerUnit": "string",
        "issuerAccountRS": "string",
        "issuerAccount": "string"
      }
    ],
    "lastBlock": "string",
    "requestProcessingTime": 0
  }
}

getAllCurrencies

Get all currencies in reverse creation order

POST

https://ardr.nownodes.io/nxt

Body

application/json

jsonrpcstringrequired

methodstringrequired

paramsobjectrequired

Show child attributes

requestTypestring

firstIndexinteger

A zero-based index to the first currency to retrieve

lastIndexinteger

A zero-based index to the last currency to retrieve

includeCountsboolean

True to include numberOf... fields

requireBlockstring

The block ID of a block that must be present in the blockchain during execution

requireLastBlockstring

The block ID of a block that must be last in the blockchain during execution

idintegerrequired

Response

200OK

All currencies retrieved successfully

400Bad Request

Bad Request

401Unauthorized

Unauthorized — Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Get all currencies in reverse creation order

curl -X POST 'https://ardr.nownodes.io/nxt' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "getAllCurrencies",
    "params": {
      "requestType": "getAllCurrencies",
      "firstIndex": 0,
      "lastIndex": 0,
      "includeCounts": true,
      "requireBlock": "string",
      "requireLastBlock": "string"
    },
    "id": 1
  }'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "getAllCurrencies",
      "params": {
        "requestType": "getAllCurrencies",
        "firstIndex": 0,
        "lastIndex": 0,
        "includeCounts": true,
        "requireBlock": "string",
        "requireLastBlock": "string"
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "getAllCurrencies",
  "params": {
    "requestType": "getAllCurrencies",
    "firstIndex": 0,
    "lastIndex": 0,
    "includeCounts": True,
    "requireBlock": "string",
    "requireLastBlock": "string"
  },
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "getAllCurrencies",
  "params": {
    "requestType": "getAllCurrencies",
    "firstIndex": 0,
    "lastIndex": 0,
    "includeCounts": true,
    "requireBlock": "string",
    "requireLastBlock": "string"
  },
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "currencies": [
      {
        "initialSupply": "string",
        "chain": 0,
        "currentReservePerUnitNQT": "string",
        "types": [
          "string"
        ],
        "code": "string",
        "creationHeight": 0,
        "minDifficulty": 0,
        "numberOfTransfers": 0,
        "description": "string",
        "minReservePerUnitNQT": "string",
        "initialSupplyQNT": "string",
        "issuanceHeight": 0,
        "type": 0,
        "reserveSupplyQNT": "string",
        "maxDifficulty": 0,
        "accountRS": "string",
        "decimals": 0,
        "name": "string",
        "numberOfExchanges": 0,
        "currency": "string",
        "maxSupplyQNT": "string",
        "account": "string",
        "algorithm": 0
      }
    ],
    "lastBlock": "string",
    "requestProcessingTime": 0
  }
}

getAllExchanges

Get all currency exchanges in reverse chronological order

POST

https://ardr.nownodes.io/nxt

Body

application/json

jsonrpcstringrequired

methodstringrequired

paramsobjectrequired

Show child attributes

requestTypestring

chaininteger

The chain related to the operation

timestampinteger

The earliest timestamp to retrieve

firstIndexinteger

A zero-based index to the first exchange to retrieve

lastIndexinteger

A zero-based index to the last exchange to retrieve

includeCurrencyInfoboolean

True to include some currency details

requireBlockstring

The block ID of a block that must be present in the blockchain during execution

requireLastBlockstring

The block ID of a block that must be last in the blockchain during execution

idintegerrequired

Response

200OK

All exchanges retrieved successfully

400Bad Request

Bad Request

401Unauthorized

Unauthorized — Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Get all currency exchanges in reverse chronological order

curl -X POST 'https://ardr.nownodes.io/nxt' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "getAllExchanges",
    "params": {
      "requestType": "getAllExchanges",
      "chain": 0,
      "timestamp": 0,
      "firstIndex": 0,
      "lastIndex": 0,
      "includeCurrencyInfo": true,
      "requireBlock": "string",
      "requireLastBlock": "string"
    },
    "id": 1
  }'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "getAllExchanges",
      "params": {
        "requestType": "getAllExchanges",
        "chain": 0,
        "timestamp": 0,
        "firstIndex": 0,
        "lastIndex": 0,
        "includeCurrencyInfo": true,
        "requireBlock": "string",
        "requireLastBlock": "string"
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "getAllExchanges",
  "params": {
    "requestType": "getAllExchanges",
    "chain": 0,
    "timestamp": 0,
    "firstIndex": 0,
    "lastIndex": 0,
    "includeCurrencyInfo": True,
    "requireBlock": "string",
    "requireLastBlock": "string"
  },
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "getAllExchanges",
  "params": {
    "requestType": "getAllExchanges",
    "chain": 0,
    "timestamp": 0,
    "firstIndex": 0,
    "lastIndex": 0,
    "includeCurrencyInfo": true,
    "requireBlock": "string",
    "requireLastBlock": "string"
  },
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "exchanges": [
      {
        "issuerAccountRS": "string",
        "seller": "string",
        "code": "string",
        "sellerRS": "string",
        "unitsQNT": "string",
        "issuanceHeight": 0,
        "type": 0,
        "rateNQTPerUnit": "string",
        "buyer": "string",
        "offer": "string",
        "buyerRS": "string",
        "decimals": 0,
        "name": "string",
        "currency": "string",
        "block": "string",
        "transaction": "string",
        "timestamp": 0,
        "height": 0,
        "issuerAccount": "string"
      }
    ],
    "lastBlock": "string",
    "requestProcessingTime": 0
  }
}

getAvailableToBuy

Calculates the rate required in order to completely fill an exchange request

POST

https://ardr.nownodes.io/nxt

Body

application/json

jsonrpcstringrequired

methodstringrequired

paramsobjectrequired

Show child attributes

requestTypestring

chaininteger

The chain related to the operation

currencystring

The currency ID

unitsstring

The number of units to buy

requireBlockstring

The block ID of a block that must be present in the blockchain during execution

requireLastBlockstring

The block ID of a block that must be last in the blockchain during execution

idintegerrequired

Response

200OK

Available to buy calculation result

400Bad Request

Bad Request

401Unauthorized

Unauthorized — Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Calculates the rate required in order to completely fill an exchange request

curl -X POST 'https://ardr.nownodes.io/nxt' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "getAvailableToBuy",
    "params": {
      "requestType": "getAvailableToBuy",
      "chain": 0,
      "currency": "string",
      "units": "string",
      "requireBlock": "string",
      "requireLastBlock": "string"
    },
    "id": 1
  }'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "getAvailableToBuy",
      "params": {
        "requestType": "getAvailableToBuy",
        "chain": 0,
        "currency": "string",
        "units": "string",
        "requireBlock": "string",
        "requireLastBlock": "string"
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "getAvailableToBuy",
  "params": {
    "requestType": "getAvailableToBuy",
    "chain": 0,
    "currency": "string",
    "units": "string",
    "requireBlock": "string",
    "requireLastBlock": "string"
  },
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "getAvailableToBuy",
  "params": {
    "requestType": "getAvailableToBuy",
    "chain": 0,
    "currency": "string",
    "units": "string",
    "requireBlock": "string",
    "requireLastBlock": "string"
  },
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "amountNQT": "string",
    "units": "string",
    "rateNQTperShare": "string",
    "requestProcessingTime": 0
  }
}

getAvailableToSell

Calculates the rate required in order to completely fill an exchange request

POST

https://ardr.nownodes.io/nxt

Body

application/json

jsonrpcstringrequired

methodstringrequired

paramsobjectrequired

Show child attributes

requestTypestring

chaininteger

The chain related to the operation

currencystring

The currency ID

unitsstring

The number of units to sell

requireBlockstring

The block ID of a block that must be present in the blockchain during execution

requireLastBlockstring

The block ID of a block that must be last in the blockchain during execution

idintegerrequired

Response

200OK

Available to sell calculation result

400Bad Request

Bad Request

401Unauthorized

Unauthorized — Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Calculates the rate required in order to completely fill an exchange request

curl -X POST 'https://ardr.nownodes.io/nxt' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "getAvailableToSell",
    "params": {
      "requestType": "getAvailableToSell",
      "chain": 0,
      "currency": "string",
      "units": "string",
      "requireBlock": "string",
      "requireLastBlock": "string"
    },
    "id": 1
  }'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "getAvailableToSell",
      "params": {
        "requestType": "getAvailableToSell",
        "chain": 0,
        "currency": "string",
        "units": "string",
        "requireBlock": "string",
        "requireLastBlock": "string"
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "getAvailableToSell",
  "params": {
    "requestType": "getAvailableToSell",
    "chain": 0,
    "currency": "string",
    "units": "string",
    "requireBlock": "string",
    "requireLastBlock": "string"
  },
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "getAvailableToSell",
  "params": {
    "requestType": "getAvailableToSell",
    "chain": 0,
    "currency": "string",
    "units": "string",
    "requireBlock": "string",
    "requireLastBlock": "string"
  },
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "amountNQT": "string",
    "units": "string",
    "rateNQTperShare": "string",
    "requestProcessingTime": 0
  }
}

getBuyOffers

Get currency buy offers given a currency ID and/or an account ID

POST

https://ardr.nownodes.io/nxt

Body

application/json

jsonrpcstringrequired

methodstringrequired

paramsobjectrequired

Show child attributes

requestTypestring

chaininteger

The chain related to the operation

currencystring

The currency ID

accountstring

The account ID

availableOnlyboolean

True to include only offers with non-zero supply and limit

firstIndexinteger

A zero-based index to the first offer to retrieve

lastIndexinteger

A zero-based index to the last offer to retrieve

requireBlockstring

The block ID of a block that must be present in the blockchain during execution

requireLastBlockstring

The block ID of a block that must be last in the blockchain during execution

idintegerrequired

Response

200OK

Buy offers retrieved successfully

400Bad Request

Bad Request

401Unauthorized

Unauthorized — Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Get currency buy offers given a currency ID and/or an account ID

curl -X POST 'https://ardr.nownodes.io/nxt' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "getBuyOffers",
    "params": {
      "requestType": "getBuyOffers",
      "chain": 0,
      "currency": "string",
      "account": "string",
      "availableOnly": true,
      "firstIndex": 0,
      "lastIndex": 0,
      "requireBlock": "string",
      "requireLastBlock": "string"
    },
    "id": 1
  }'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "getBuyOffers",
      "params": {
        "requestType": "getBuyOffers",
        "chain": 0,
        "currency": "string",
        "account": "string",
        "availableOnly": true,
        "firstIndex": 0,
        "lastIndex": 0,
        "requireBlock": "string",
        "requireLastBlock": "string"
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "getBuyOffers",
  "params": {
    "requestType": "getBuyOffers",
    "chain": 0,
    "currency": "string",
    "account": "string",
    "availableOnly": True,
    "firstIndex": 0,
    "lastIndex": 0,
    "requireBlock": "string",
    "requireLastBlock": "string"
  },
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "getBuyOffers",
  "params": {
    "requestType": "getBuyOffers",
    "chain": 0,
    "currency": "string",
    "account": "string",
    "availableOnly": true,
    "firstIndex": 0,
    "lastIndex": 0,
    "requireBlock": "string",
    "requireLastBlock": "string"
  },
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "offers": [
      {
        "offer": "string",
        "supplyQNT": "string",
        "expirationHeight": 0,
        "accountRS": "string",
        "rateNQTPerUnit": "string",
        "limitQNT": "string",
        "currency": "string",
        "offerFullHash": "string",
        "account": "string",
        "height": 0
      }
    ],
    "lastBlock": "string",
    "requestProcessingTime": 0
  }
}

getCurrencies

Get currencies given multiple currency IDs

POST

https://ardr.nownodes.io/nxt

Body

application/json

jsonrpcstringrequired

methodstringrequired

paramsobjectrequired

Show child attributes

requestTypestring

currenciesArray<string>

Multiple currency IDs

includeCountsboolean

True to include numberOf... fields

requireBlockstring

The block ID of a block that must be present in the blockchain during execution

requireLastBlockstring

The block ID of a block that must be last in the blockchain during execution

idintegerrequired

Response

200OK

Currencies retrieved successfully

400Bad Request

Bad Request

401Unauthorized

Unauthorized — Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Get currencies given multiple currency IDs

curl -X POST 'https://ardr.nownodes.io/nxt' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "getCurrencies",
    "params": {
      "requestType": "getCurrencies",
      "currencies": [
        "string"
      ],
      "includeCounts": true,
      "requireBlock": "string",
      "requireLastBlock": "string"
    },
    "id": 1
  }'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "getCurrencies",
      "params": {
        "requestType": "getCurrencies",
        "currencies": [
          "string"
        ],
        "includeCounts": true,
        "requireBlock": "string",
        "requireLastBlock": "string"
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "getCurrencies",
  "params": {
    "requestType": "getCurrencies",
    "currencies": [
      "string"
    ],
    "includeCounts": True,
    "requireBlock": "string",
    "requireLastBlock": "string"
  },
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "getCurrencies",
  "params": {
    "requestType": "getCurrencies",
    "currencies": [
      "string"
    ],
    "includeCounts": true,
    "requireBlock": "string",
    "requireLastBlock": "string"
  },
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "currencies": [
      {
        "initialSupply": "string",
        "currentReservePerUnitNQT": "string",
        "types": [
          "string"
        ],
        "code": "string",
        "currentSupplyQNT": "string",
        "creationHeight": 0,
        "minDifficulty": 0,
        "description": "string",
        "minReservePerUnitNQT": "string",
        "initialSupplyQNT": "string",
        "issuanceHeight": 0,
        "type": 0,
        "maxSupplyQNT": "string",
        "maxDifficulty": 0,
        "accountRS": "string",
        "decimals": 0,
        "name": "string",
        "reserveSupplyQNT": "string",
        "currency": "string",
        "account": "string",
        "algorithm": 0
      }
    ],
    "lastBlock": "string",
    "requestProcessingTime": 0
  }
}

getCurrenciesByIssuer

Get currencies issued by multiple accounts in reverse creation order

POST

https://ardr.nownodes.io/nxt

Body

application/json

jsonrpcstringrequired

methodstringrequired

paramsobjectrequired

Show child attributes

requestTypestring

accountArray<string>

Multiple account IDs

firstIndexinteger

A zero-based index to the first currency to retrieve

lastIndexinteger

A zero-based index to the last currency to retrieve

includeCountsboolean

True if numberOf... fields are to be included

adminPasswordstring

The administrator password

requireBlockstring

The block ID of a block that must be present in the blockchain during execution

requireLastBlockstring

The block ID of a block that must be last in the blockchain during execution

idintegerrequired

Response

200OK

Currencies by issuer retrieved successfully

400Bad Request

Bad Request

401Unauthorized

Unauthorized — Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Get currencies issued by multiple accounts in reverse creation order

curl -X POST 'https://ardr.nownodes.io/nxt' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "getCurrenciesByIssuer",
    "params": {
      "requestType": "getCurrenciesByIssuer",
      "account": [
        "string"
      ],
      "firstIndex": 0,
      "lastIndex": 0,
      "includeCounts": true,
      "adminPassword": "string",
      "requireBlock": "string",
      "requireLastBlock": "string"
    },
    "id": 1
  }'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "getCurrenciesByIssuer",
      "params": {
        "requestType": "getCurrenciesByIssuer",
        "account": [
          "string"
        ],
        "firstIndex": 0,
        "lastIndex": 0,
        "includeCounts": true,
        "adminPassword": "string",
        "requireBlock": "string",
        "requireLastBlock": "string"
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "getCurrenciesByIssuer",
  "params": {
    "requestType": "getCurrenciesByIssuer",
    "account": [
      "string"
    ],
    "firstIndex": 0,
    "lastIndex": 0,
    "includeCounts": True,
    "adminPassword": "string",
    "requireBlock": "string",
    "requireLastBlock": "string"
  },
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "getCurrenciesByIssuer",
  "params": {
    "requestType": "getCurrenciesByIssuer",
    "account": [
      "string"
    ],
    "firstIndex": 0,
    "lastIndex": 0,
    "includeCounts": true,
    "adminPassword": "string",
    "requireBlock": "string",
    "requireLastBlock": "string"
  },
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "currencies": [
      [
        {
          "initialSupply": "string",
          "currentReservePerUnitNQT": "string",
          "chain": 0,
          "types": [
            "string"
          ],
          "code": "string",
          "currentSupplyQNT": "string",
          "creationHeight": 0,
          "minDifficulty": 0,
          "description": "string",
          "minReservePerUnitNQT": "string",
          "initialSupplyQNT": "string",
          "issuanceHeight": 0,
          "type": 0,
          "maxSupplyQNT": "string",
          "maxDifficulty": 0,
          "accountRS": "string",
          "decimals": 0,
          "name": "string",
          "reserveSupplyQNT": "string",
          "currency": "string",
          "account": "string",
          "algorithm": 0
        }
      ]
    ],
    "lastBlock": "string",
    "requestProcessingTime": 0
  }
}

getCurrencyAccountCount

Get the number of accounts that hold a given currency

POST

https://ardr.nownodes.io/nxt

Body

application/json

jsonrpcstringrequired

methodstringrequired

paramsobjectrequired

Show child attributes

requestTypestring

currencystring

The currency ID

heightinteger

The blockchain height at which the response applies

requireBlockstring

The block ID of a block that must be present in the blockchain during execution

requireLastBlockstring

The block ID of a block that must be last in the blockchain during execution

idintegerrequired

Response

200OK

Currency account count retrieved successfully

400Bad Request

Bad Request

401Unauthorized

Unauthorized — Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Get the number of accounts that hold a given currency

curl -X POST 'https://ardr.nownodes.io/nxt' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "getCurrencyAccountCount",
    "params": {
      "requestType": "getCurrencyAccountCount",
      "currency": "string",
      "height": 0,
      "requireBlock": "string",
      "requireLastBlock": "string"
    },
    "id": 1
  }'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "getCurrencyAccountCount",
      "params": {
        "requestType": "getCurrencyAccountCount",
        "currency": "string",
        "height": 0,
        "requireBlock": "string",
        "requireLastBlock": "string"
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "getCurrencyAccountCount",
  "params": {
    "requestType": "getCurrencyAccountCount",
    "currency": "string",
    "height": 0,
    "requireBlock": "string",
    "requireLastBlock": "string"
  },
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "getCurrencyAccountCount",
  "params": {
    "requestType": "getCurrencyAccountCount",
    "currency": "string",
    "height": 0,
    "requireBlock": "string",
    "requireLastBlock": "string"
  },
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "numberOfAccounts": 0,
    "lastBlock": "string",
    "requestProcessingTime": 0
  }
}

getCurrencyAccounts

Get the accounts that hold a given currency in reverse units order

POST

https://ardr.nownodes.io/nxt

Body

application/json

jsonrpcstringrequired

methodstringrequired

paramsobjectrequired

Show child attributes

requestTypestring

currencystring

The currency ID

heightinteger

The blockchain height at which the response applies

firstIndexinteger

A zero-based index to the first account to retrieve

lastIndexinteger

A zero-based index to the last account to retrieve

requireBlockstring

The block ID of a block that must be present in the blockchain during execution

requireLastBlockstring

The block ID of a block that must be last in the blockchain during execution

idintegerrequired

Response

200OK

Currency accounts retrieved successfully

400Bad Request

Bad Request

401Unauthorized

Unauthorized — Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Get the accounts that hold a given currency in reverse units order

curl -X POST 'https://ardr.nownodes.io/nxt' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "getCurrencyAccounts",
    "params": {
      "requestType": "getCurrencyAccounts",
      "currency": "string",
      "height": 0,
      "firstIndex": 0,
      "lastIndex": 0,
      "requireBlock": "string",
      "requireLastBlock": "string"
    },
    "id": 1
  }'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "getCurrencyAccounts",
      "params": {
        "requestType": "getCurrencyAccounts",
        "currency": "string",
        "height": 0,
        "firstIndex": 0,
        "lastIndex": 0,
        "requireBlock": "string",
        "requireLastBlock": "string"
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "getCurrencyAccounts",
  "params": {
    "requestType": "getCurrencyAccounts",
    "currency": "string",
    "height": 0,
    "firstIndex": 0,
    "lastIndex": 0,
    "requireBlock": "string",
    "requireLastBlock": "string"
  },
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "getCurrencyAccounts",
  "params": {
    "requestType": "getCurrencyAccounts",
    "currency": "string",
    "height": 0,
    "firstIndex": 0,
    "lastIndex": 0,
    "requireBlock": "string",
    "requireLastBlock": "string"
  },
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "accountCurrencies": [
      {
        "unconfirmedUnits": "string",
        "accountRS": "string",
        "currency": "string",
        "units": "string",
        "account": "string"
      }
    ],
    "lastBlock": "string",
    "requestProcessingTime": 0
  }
}

getCurrencyFounders

Get a reservable currency's founders

POST

https://ardr.nownodes.io/nxt

Body

application/json

jsonrpcstringrequired

methodstringrequired

paramsobjectrequired

Show child attributes

requestTypestring

chaininteger

The chain related to the operation

currencystring

The currency ID

accountstring

An account ID

firstIndexinteger

A zero-based index to the first founder to retrieve

lastIndexinteger

A zero-based index to the last founder to retrieve

requireBlockstring

The block ID of a block that must be present in the blockchain during execution

requireLastBlockstring

The block ID of a block that must be last in the blockchain during execution

idintegerrequired

Response

200OK

Currency founders retrieved successfully

400Bad Request

Bad Request

401Unauthorized

Unauthorized — Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Get a reservable currency's founders

curl -X POST 'https://ardr.nownodes.io/nxt' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "getCurrencyFounders",
    "params": {
      "requestType": "getCurrencyFounders",
      "chain": 0,
      "currency": "string",
      "account": "string",
      "firstIndex": 0,
      "lastIndex": 0,
      "requireBlock": "string",
      "requireLastBlock": "string"
    },
    "id": 1
  }'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "getCurrencyFounders",
      "params": {
        "requestType": "getCurrencyFounders",
        "chain": 0,
        "currency": "string",
        "account": "string",
        "firstIndex": 0,
        "lastIndex": 0,
        "requireBlock": "string",
        "requireLastBlock": "string"
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "getCurrencyFounders",
  "params": {
    "requestType": "getCurrencyFounders",
    "chain": 0,
    "currency": "string",
    "account": "string",
    "firstIndex": 0,
    "lastIndex": 0,
    "requireBlock": "string",
    "requireLastBlock": "string"
  },
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "getCurrencyFounders",
  "params": {
    "requestType": "getCurrencyFounders",
    "chain": 0,
    "currency": "string",
    "account": "string",
    "firstIndex": 0,
    "lastIndex": 0,
    "requireBlock": "string",
    "requireLastBlock": "string"
  },
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "founders": [
      {
        "accountRS": "string",
        "amountPerUnitNQT": "string",
        "currency": "string",
        "account": "string"
      }
    ],
    "lastBlock": "string",
    "requestProcessingTime": 0
  }
}

getCurrencyIds

Get all currency IDs in reverse chronological creation order

POST

https://ardr.nownodes.io/nxt

Body

application/json

jsonrpcstringrequired

methodstringrequired

paramsobjectrequired

Show child attributes

requestTypestring

firstIndexinteger

A zero-based index to the first currency to retrieve

lastIndexinteger

A zero-based index to the last currency to retrieve

requireBlockstring

The block ID of a block that must be present in the blockchain during execution

requireLastBlockstring

The block ID of a block that must be last in the blockchain during execution

idintegerrequired

Response

200OK

Currency IDs retrieved successfully

400Bad Request

Bad Request

401Unauthorized

Unauthorized — Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Get all currency IDs in reverse chronological creation order

curl -X POST 'https://ardr.nownodes.io/nxt' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "getCurrencyIds",
    "params": {
      "requestType": "getCurrencyIds",
      "firstIndex": 0,
      "lastIndex": 0,
      "requireBlock": "string",
      "requireLastBlock": "string"
    },
    "id": 1
  }'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "getCurrencyIds",
      "params": {
        "requestType": "getCurrencyIds",
        "firstIndex": 0,
        "lastIndex": 0,
        "requireBlock": "string",
        "requireLastBlock": "string"
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "getCurrencyIds",
  "params": {
    "requestType": "getCurrencyIds",
    "firstIndex": 0,
    "lastIndex": 0,
    "requireBlock": "string",
    "requireLastBlock": "string"
  },
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "getCurrencyIds",
  "params": {
    "requestType": "getCurrencyIds",
    "firstIndex": 0,
    "lastIndex": 0,
    "requireBlock": "string",
    "requireLastBlock": "string"
  },
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "currencyIds": [
      "string"
    ],
    "lastBlock": "string",
    "requestProcessingTime": 0
  }
}

getCurrencyTransfers

Get currency transfers given a currency ID and/or an account ID in reverse block height order

POST

https://ardr.nownodes.io/nxt

Body

application/json

jsonrpcstringrequired

methodstringrequired

paramsobjectrequired

Show child attributes

requestTypestring

currencystring

The currency ID

accountstring

The account ID

timestampinteger

The earliest transfer (in seconds since the genesis block) to retrieve

firstIndexinteger

A zero-based index to the first transfer to retrieve

lastIndexinteger

A zero-based index to the last transfer to retrieve

includeCurrencyInfoboolean

True to include some currency fields

requireBlockstring

The block ID of a block that must be present in the blockchain during execution

requireLastBlockstring

The block ID of a block that must be last in the blockchain during execution

idintegerrequired

Response

200OK

Currency transfers retrieved successfully

400Bad Request

Bad Request

401Unauthorized

Unauthorized — Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Get currency transfers given a currency ID and/or an account ID in reverse block height order

curl -X POST 'https://ardr.nownodes.io/nxt' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "getCurrencyTransfers",
    "params": {
      "requestType": "getCurrencyTransfers",
      "currency": "string",
      "account": "string",
      "timestamp": 0,
      "firstIndex": 0,
      "lastIndex": 0,
      "includeCurrencyInfo": true,
      "requireBlock": "string",
      "requireLastBlock": "string"
    },
    "id": 1
  }'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "getCurrencyTransfers",
      "params": {
        "requestType": "getCurrencyTransfers",
        "currency": "string",
        "account": "string",
        "timestamp": 0,
        "firstIndex": 0,
        "lastIndex": 0,
        "includeCurrencyInfo": true,
        "requireBlock": "string",
        "requireLastBlock": "string"
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "getCurrencyTransfers",
  "params": {
    "requestType": "getCurrencyTransfers",
    "currency": "string",
    "account": "string",
    "timestamp": 0,
    "firstIndex": 0,
    "lastIndex": 0,
    "includeCurrencyInfo": True,
    "requireBlock": "string",
    "requireLastBlock": "string"
  },
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "getCurrencyTransfers",
  "params": {
    "requestType": "getCurrencyTransfers",
    "currency": "string",
    "account": "string",
    "timestamp": 0,
    "firstIndex": 0,
    "lastIndex": 0,
    "includeCurrencyInfo": true,
    "requireBlock": "string",
    "requireLastBlock": "string"
  },
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "transfers": [
      {
        "code": "string",
        "units": "string",
        "issuanceHeight": 0,
        "type": 0,
        "issuerAccountRS": "string",
        "transfer": "string",
        "senderRS": "string",
        "sender": "string",
        "recipientRS": "string",
        "decimals": 0,
        "recipient": "string",
        "name": "string",
        "currency": "string",
        "issuerAccount": "string",
        "height": 0,
        "timestamp": 0
      }
    ],
    "lastBlock": "string",
    "requestProcessingTime": 0
  }
}

getExchanges

Get currency exchanges given a currency and/or an account in reverse chronological order

POST

https://ardr.nownodes.io/nxt

Body

application/json

jsonrpcstringrequired

methodstringrequired

paramsobjectrequired

Show child attributes

requestTypestring

chaininteger

The chain related to the operation

currencystring

A currency ID

accountstring

An account ID

firstIndexinteger

A zero-based index to the first currency exchange to retrieve

lastIndexinteger

A zero-based index to the last currency exchange to retrieve

timestampinteger

The earliest block (in seconds since the genesis block) to retrieve

includeCurrencyInfoboolean

True to include several currency-related fields

requireBlockstring

The block ID of a block that must be present in the blockchain during execution

requireLastBlockstring

The block ID of a block that must be last in the blockchain during execution

idintegerrequired

Response

200OK

Exchanges retrieved successfully

400Bad Request

Bad Request

401Unauthorized

Unauthorized — Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Get currency exchanges given a currency and/or an account in reverse chronological order

curl -X POST 'https://ardr.nownodes.io/nxt' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "getExchanges",
    "params": {
      "requestType": "getExchanges",
      "chain": 0,
      "currency": "string",
      "account": "string",
      "firstIndex": 0,
      "lastIndex": 0,
      "timestamp": 0,
      "includeCurrencyInfo": true,
      "requireBlock": "string",
      "requireLastBlock": "string"
    },
    "id": 1
  }'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "getExchanges",
      "params": {
        "requestType": "getExchanges",
        "chain": 0,
        "currency": "string",
        "account": "string",
        "firstIndex": 0,
        "lastIndex": 0,
        "timestamp": 0,
        "includeCurrencyInfo": true,
        "requireBlock": "string",
        "requireLastBlock": "string"
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "getExchanges",
  "params": {
    "requestType": "getExchanges",
    "chain": 0,
    "currency": "string",
    "account": "string",
    "firstIndex": 0,
    "lastIndex": 0,
    "timestamp": 0,
    "includeCurrencyInfo": True,
    "requireBlock": "string",
    "requireLastBlock": "string"
  },
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "getExchanges",
  "params": {
    "requestType": "getExchanges",
    "chain": 0,
    "currency": "string",
    "account": "string",
    "firstIndex": 0,
    "lastIndex": 0,
    "timestamp": 0,
    "includeCurrencyInfo": true,
    "requireBlock": "string",
    "requireLastBlock": "string"
  },
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "exchanges": [
      {
        "seller": "string",
        "code": "string",
        "sellerRS": "string",
        "unitsQNT": "string",
        "issuanceHeight": 0,
        "type": 0,
        "rateNQTPerUnit": "string",
        "buyer": "string",
        "offer": "string",
        "buyerRS": "string",
        "decimals": 0,
        "name": "string",
        "currency": "string",
        "block": "string",
        "transaction": "string",
        "timestamp": 0,
        "height": 0,
        "issuerAccountRS": "string",
        "issuerAccount": "string"
      }
    ],
    "lastBlock": "string",
    "requestProcessingTime": 0
  }
}

getExchangesByExchangeRequest

Get currency exchanges given an exchange request transaction ID in reverse chronological order

POST

https://ardr.nownodes.io/nxt

Body

application/json

jsonrpcstringrequired

methodstringrequired

paramsobjectrequired

Show child attributes

requestTypestring

chaininteger

The chain related to the operation

transactionstring

The transaction ID of the exchange request

includeCurrencyInfoboolean

True to include several currency-related fields

requireBlockstring

The block ID of a block that must be present in the blockchain during execution

requireLastBlockstring

The block ID of a block that must be last in the blockchain during execution

idintegerrequired

Response

200OK

Exchanges by exchange request retrieved successfully

400Bad Request

Bad Request

401Unauthorized

Unauthorized — Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Get currency exchanges given an exchange request transaction ID in reverse chronological order

curl -X POST 'https://ardr.nownodes.io/nxt' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "getExchangesByExchangeRequest",
    "params": {
      "requestType": "getExchangesByExchangeRequest",
      "chain": 0,
      "transaction": "string",
      "includeCurrencyInfo": true,
      "requireBlock": "string",
      "requireLastBlock": "string"
    },
    "id": 1
  }'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "getExchangesByExchangeRequest",
      "params": {
        "requestType": "getExchangesByExchangeRequest",
        "chain": 0,
        "transaction": "string",
        "includeCurrencyInfo": true,
        "requireBlock": "string",
        "requireLastBlock": "string"
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "getExchangesByExchangeRequest",
  "params": {
    "requestType": "getExchangesByExchangeRequest",
    "chain": 0,
    "transaction": "string",
    "includeCurrencyInfo": True,
    "requireBlock": "string",
    "requireLastBlock": "string"
  },
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "getExchangesByExchangeRequest",
  "params": {
    "requestType": "getExchangesByExchangeRequest",
    "chain": 0,
    "transaction": "string",
    "includeCurrencyInfo": true,
    "requireBlock": "string",
    "requireLastBlock": "string"
  },
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "exchanges": [
      {
        "seller": "string",
        "code": "string",
        "sellerRS": "string",
        "unitsQNT": "string",
        "issuanceHeight": 0,
        "type": 0,
        "rateNQTPerUnit": "string",
        "buyer": "string",
        "offer": "string",
        "buyerRS": "string",
        "decimals": 0,
        "name": "string",
        "currency": "string",
        "block": "string",
        "transaction": "string",
        "timestamp": 0,
        "height": 0,
        "issuerAccountRS": "string",
        "issuerAccount": "string"
      }
    ],
    "lastBlock": "string",
    "requestProcessingTime": 0
  }
}

getExchangesByOffer

Get currency exchanges given a currency offer ID in reverse chronological order

POST

https://ardr.nownodes.io/nxt

Body

application/json

jsonrpcstringrequired

methodstringrequired

paramsobjectrequired

Show child attributes

requestTypestring

chaininteger

The chain related to the operation

offerstring

A currency offer ID

includeCurrencyInfoboolean

True to include several currency-related fields

firstIndexinteger

A zero-based index to the first currency exchange to retrieve

lastIndexinteger

A zero-based index to the last currency exchange to retrieve

requireBlockstring

The block ID of a block that must be present in the blockchain during execution

requireLastBlockstring

The block ID of a block that must be last in the blockchain during execution

idintegerrequired

Response

200OK

Exchanges by offer retrieved successfully

400Bad Request

Bad Request

401Unauthorized

Unauthorized — Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Get currency exchanges given a currency offer ID in reverse chronological order

curl -X POST 'https://ardr.nownodes.io/nxt' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "getExchangesByOffer",
    "params": {
      "requestType": "getExchangesByOffer",
      "chain": 0,
      "offer": "string",
      "includeCurrencyInfo": true,
      "firstIndex": 0,
      "lastIndex": 0,
      "requireBlock": "string",
      "requireLastBlock": "string"
    },
    "id": 1
  }'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "getExchangesByOffer",
      "params": {
        "requestType": "getExchangesByOffer",
        "chain": 0,
        "offer": "string",
        "includeCurrencyInfo": true,
        "firstIndex": 0,
        "lastIndex": 0,
        "requireBlock": "string",
        "requireLastBlock": "string"
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "getExchangesByOffer",
  "params": {
    "requestType": "getExchangesByOffer",
    "chain": 0,
    "offer": "string",
    "includeCurrencyInfo": True,
    "firstIndex": 0,
    "lastIndex": 0,
    "requireBlock": "string",
    "requireLastBlock": "string"
  },
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "getExchangesByOffer",
  "params": {
    "requestType": "getExchangesByOffer",
    "chain": 0,
    "offer": "string",
    "includeCurrencyInfo": true,
    "firstIndex": 0,
    "lastIndex": 0,
    "requireBlock": "string",
    "requireLastBlock": "string"
  },
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "exchanges": [
      {
        "seller": "string",
        "code": "string",
        "sellerRS": "string",
        "unitsQNT": "string",
        "issuanceHeight": 0,
        "type": 0,
        "rateNQTPerUnit": "string",
        "buyer": "string",
        "offer": "string",
        "buyerRS": "string",
        "decimals": 0,
        "name": "string",
        "currency": "string",
        "block": "string",
        "transaction": "string",
        "timestamp": 0,
        "height": 0,
        "issuerAccountRS": "string",
        "issuerAccount": "string"
      }
    ],
    "lastBlock": "string",
    "requestProcessingTime": 0
  }
}

getExpectedBuyOffers

Get expected buy offers from the unconfirmed transactions pool or phased transactions

POST

https://ardr.nownodes.io/nxt

Body

application/json

jsonrpcstringrequired

methodstringrequired

paramsobjectrequired

Show child attributes

requestTypestring

chaininteger

The chain related to the operation

currencystring

The currency ID

accountstring

The account ID

sortByRateboolean

True to sort by rate

requireBlockstring

The block ID of a block that must be present in the blockchain during execution

requireLastBlockstring

The block ID of a block that must be last in the blockchain during execution

idintegerrequired

Response

200OK

Expected buy offers retrieved successfully

400Bad Request

Bad Request

401Unauthorized

Unauthorized — Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Get expected buy offers from the unconfirmed transactions pool or phased transactions

curl -X POST 'https://ardr.nownodes.io/nxt' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "getExpectedBuyOffers",
    "params": {
      "requestType": "getExpectedBuyOffers",
      "chain": 0,
      "currency": "string",
      "account": "string",
      "sortByRate": true,
      "requireBlock": "string",
      "requireLastBlock": "string"
    },
    "id": 1
  }'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "getExpectedBuyOffers",
      "params": {
        "requestType": "getExpectedBuyOffers",
        "chain": 0,
        "currency": "string",
        "account": "string",
        "sortByRate": true,
        "requireBlock": "string",
        "requireLastBlock": "string"
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "getExpectedBuyOffers",
  "params": {
    "requestType": "getExpectedBuyOffers",
    "chain": 0,
    "currency": "string",
    "account": "string",
    "sortByRate": True,
    "requireBlock": "string",
    "requireLastBlock": "string"
  },
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "getExpectedBuyOffers",
  "params": {
    "requestType": "getExpectedBuyOffers",
    "chain": 0,
    "currency": "string",
    "account": "string",
    "sortByRate": true,
    "requireBlock": "string",
    "requireLastBlock": "string"
  },
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "offers": [
      {
        "offer": "string",
        "supplyQNT": "string",
        "expirationHeight": 0,
        "accountRS": "string",
        "rateNQTPerUnit": "string",
        "limitQNT": "string",
        "currency": "string",
        "offerFullHash": "string",
        "account": "string",
        "height": 0
      }
    ],
    "lastBlock": "string",
    "requestProcessingTime": 0
  }
}

getExpectedCurrencyTransfers

Get expected currency transfers from the unconfirmed transactions pool or phased transactions

POST

https://ardr.nownodes.io/nxt

Body

application/json

jsonrpcstringrequired

methodstringrequired

paramsobjectrequired

Show child attributes

requestTypestring

currencystring

The currency ID

accountstring

The account ID

requireBlockstring

The block ID of a block that must be present in the blockchain during execution

requireLastBlockstring

The block ID of a block that must be last in the blockchain during execution

idintegerrequired

Response

200OK

Expected currency transfers retrieved successfully

400Bad Request

Bad Request

401Unauthorized

Unauthorized — Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Get expected currency transfers from the unconfirmed transactions pool or phased transactions

curl -X POST 'https://ardr.nownodes.io/nxt' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "getExpectedCurrencyTransfers",
    "params": {
      "requestType": "getExpectedCurrencyTransfers",
      "currency": "string",
      "account": "string",
      "requireBlock": "string",
      "requireLastBlock": "string"
    },
    "id": 1
  }'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "getExpectedCurrencyTransfers",
      "params": {
        "requestType": "getExpectedCurrencyTransfers",
        "currency": "string",
        "account": "string",
        "requireBlock": "string",
        "requireLastBlock": "string"
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "getExpectedCurrencyTransfers",
  "params": {
    "requestType": "getExpectedCurrencyTransfers",
    "currency": "string",
    "account": "string",
    "requireBlock": "string",
    "requireLastBlock": "string"
  },
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "getExpectedCurrencyTransfers",
  "params": {
    "requestType": "getExpectedCurrencyTransfers",
    "currency": "string",
    "account": "string",
    "requireBlock": "string",
    "requireLastBlock": "string"
  },
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "transfers": [
      {
        "code": "string",
        "units": "string",
        "issuanceHeight": 0,
        "type": 0,
        "issuerAccountRS": "string",
        "transfer": "string",
        "senderRS": "string",
        "sender": "string",
        "recipientRS": "string",
        "decimals": 0,
        "recipient": "string",
        "name": "string",
        "currency": "string",
        "issuerAccount": "string",
        "height": 0,
        "phased": true
      }
    ],
    "lastBlock": "string",
    "requestProcessingTime": 0
  }
}

getExpectedExchangeRequests

Get expected exchange requests from the unconfirmed transactions pool or phased transactions scheduled to finish in the next block

POST

https://ardr.nownodes.io/nxt

Body

application/json

jsonrpcstringrequired

methodstringrequired

paramsobjectrequired

Show child attributes

requestTypestring

chaininteger

The chain related to the operation

accountstring

The account ID

currencystring

The currency ID

includeCurrencyInfoboolean

True to include the response fields code, decimals, name, issuanceHeight, type, timestamp, issuerAccountRS and issuerAccount

requireBlockstring

The block ID of a block that must be present in the blockchain during execution

requireLastBlockstring

The block ID of a block that must be last in the blockchain during execution

idintegerrequired

Response

200OK

Expected exchange requests retrieved successfully

400Bad Request

Bad Request

401Unauthorized

Unauthorized — Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Get expected exchange requests from the unconfirmed transactions pool or phased transactions scheduled to finish in the next block

curl -X POST 'https://ardr.nownodes.io/nxt' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "getExpectedExchangeRequests",
    "params": {
      "requestType": "getExpectedExchangeRequests",
      "chain": 0,
      "account": "string",
      "currency": "string",
      "includeCurrencyInfo": true,
      "requireBlock": "string",
      "requireLastBlock": "string"
    },
    "id": 1
  }'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "getExpectedExchangeRequests",
      "params": {
        "requestType": "getExpectedExchangeRequests",
        "chain": 0,
        "account": "string",
        "currency": "string",
        "includeCurrencyInfo": true,
        "requireBlock": "string",
        "requireLastBlock": "string"
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "getExpectedExchangeRequests",
  "params": {
    "requestType": "getExpectedExchangeRequests",
    "chain": 0,
    "account": "string",
    "currency": "string",
    "includeCurrencyInfo": True,
    "requireBlock": "string",
    "requireLastBlock": "string"
  },
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "getExpectedExchangeRequests",
  "params": {
    "requestType": "getExpectedExchangeRequests",
    "chain": 0,
    "account": "string",
    "currency": "string",
    "includeCurrencyInfo": true,
    "requireBlock": "string",
    "requireLastBlock": "string"
  },
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "exchangeRequests": [
      {
        "code": "string",
        "subtype": 0,
        "decimals": 0,
        "name": "string",
        "units": "string",
        "issuanceHeight": 0,
        "type": 0,
        "transaction": "string",
        "timestamp": 0,
        "rateNQTPerUnit": "string",
        "issuerAccountRS": "string",
        "issuerAccount": "string",
        "phased": true
      }
    ],
    "lastBlock": "string",
    "requestProcessingTime": 0
  }
}

getExpectedSellOffers

Get expected sell offers from the unconfirmed transactions pool or phased transactions

POST

https://ardr.nownodes.io/nxt

Body

application/json

jsonrpcstringrequired

methodstringrequired

paramsobjectrequired

Show child attributes

requestTypestring

chaininteger

The chain related to the operation

currencystring

The currency ID

accountstring

The account ID

sortByRateboolean

True to sort by rate

requireBlockstring

The block ID of a block that must be present in the blockchain during execution

requireLastBlockstring

The block ID of a block that must be last in the blockchain during execution

idintegerrequired

Response

200OK

Expected sell offers retrieved successfully

400Bad Request

Bad Request

401Unauthorized

Unauthorized — Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Get expected sell offers from the unconfirmed transactions pool or phased transactions

curl -X POST 'https://ardr.nownodes.io/nxt' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "getExpectedSellOffers",
    "params": {
      "requestType": "getExpectedSellOffers",
      "chain": 0,
      "currency": "string",
      "account": "string",
      "sortByRate": true,
      "requireBlock": "string",
      "requireLastBlock": "string"
    },
    "id": 1
  }'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "getExpectedSellOffers",
      "params": {
        "requestType": "getExpectedSellOffers",
        "chain": 0,
        "currency": "string",
        "account": "string",
        "sortByRate": true,
        "requireBlock": "string",
        "requireLastBlock": "string"
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "getExpectedSellOffers",
  "params": {
    "requestType": "getExpectedSellOffers",
    "chain": 0,
    "currency": "string",
    "account": "string",
    "sortByRate": True,
    "requireBlock": "string",
    "requireLastBlock": "string"
  },
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "getExpectedSellOffers",
  "params": {
    "requestType": "getExpectedSellOffers",
    "chain": 0,
    "currency": "string",
    "account": "string",
    "sortByRate": true,
    "requireBlock": "string",
    "requireLastBlock": "string"
  },
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "offers": [
      {
        "offer": "string",
        "supplyQNT": "string",
        "expirationHeight": 0,
        "accountRS": "string",
        "rateNQTPerUnit": "string",
        "limitQNT": "string",
        "currency": "string",
        "offerFullHash": "string",
        "account": "string",
        "height": 0
      }
    ],
    "lastBlock": "string",
    "requestProcessingTime": 0
  }
}

getLastExchanges

Get the last exchange of each of multiple currencies

POST

https://ardr.nownodes.io/nxt

Body

application/json

jsonrpcstringrequired

methodstringrequired

paramsobjectrequired

Show child attributes

requestTypestring

chaininteger

The chain related to the operation

currenciesArray<string>

Multiple currency IDs

requireBlockstring

The block ID of a block that must be present in the blockchain during execution

requireLastBlockstring

The block ID of a block that must be last in the blockchain during execution

idintegerrequired

Response

200OK

Last exchanges retrieved successfully

400Bad Request

Bad Request

401Unauthorized

Unauthorized — Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Get the last exchange of each of multiple currencies

curl -X POST 'https://ardr.nownodes.io/nxt' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "getLastExchanges",
    "params": {
      "requestType": "getLastExchanges",
      "chain": 0,
      "currencies": [
        "string"
      ],
      "requireBlock": "string",
      "requireLastBlock": "string"
    },
    "id": 1
  }'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "getLastExchanges",
      "params": {
        "requestType": "getLastExchanges",
        "chain": 0,
        "currencies": [
          "string"
        ],
        "requireBlock": "string",
        "requireLastBlock": "string"
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "getLastExchanges",
  "params": {
    "requestType": "getLastExchanges",
    "chain": 0,
    "currencies": [
      "string"
    ],
    "requireBlock": "string",
    "requireLastBlock": "string"
  },
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "getLastExchanges",
  "params": {
    "requestType": "getLastExchanges",
    "chain": 0,
    "currencies": [
      "string"
    ],
    "requireBlock": "string",
    "requireLastBlock": "string"
  },
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "exchanges": [
      {
        "offer": "string",
        "seller": "string",
        "buyerRS": "string",
        "sellerRS": "string",
        "currency": "string",
        "block": "string",
        "unitsQNT": "string",
        "transaction": "string",
        "timestamp": 0,
        "rateNQTPerUnit": "string",
        "buyer": "string",
        "height": 0
      }
    ],
    "requestProcessingTime": 0
  }
}

getMintingTarget

Get the current minting target of a mintable currency

POST

https://ardr.nownodes.io/nxt

Body

application/json

jsonrpcstringrequired

methodstringrequired

paramsobjectrequired

Show child attributes

requestTypestring

currencystring

The mintable currency ID

accountstring

The minting account ID

unitsQNTstring

The amount (in QNT) of currency to mint

requireBlockstring

The block ID of a block that must be present in the blockchain during execution

requireLastBlockstring

The block ID of a block that must be last in the blockchain during execution

idintegerrequired

Response

200OK

Minting target retrieved successfully

400Bad Request

Bad Request

401Unauthorized

Unauthorized — Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Get the current minting target of a mintable currency

curl -X POST 'https://ardr.nownodes.io/nxt' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "getMintingTarget",
    "params": {
      "requestType": "getMintingTarget",
      "currency": "string",
      "account": "string",
      "unitsQNT": "string",
      "requireBlock": "string",
      "requireLastBlock": "string"
    },
    "id": 1
  }'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "getMintingTarget",
      "params": {
        "requestType": "getMintingTarget",
        "currency": "string",
        "account": "string",
        "unitsQNT": "string",
        "requireBlock": "string",
        "requireLastBlock": "string"
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "getMintingTarget",
  "params": {
    "requestType": "getMintingTarget",
    "currency": "string",
    "account": "string",
    "unitsQNT": "string",
    "requireBlock": "string",
    "requireLastBlock": "string"
  },
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "getMintingTarget",
  "params": {
    "requestType": "getMintingTarget",
    "currency": "string",
    "account": "string",
    "unitsQNT": "string",
    "requireBlock": "string",
    "requireLastBlock": "string"
  },
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "difficulty": "string",
    "targetBytes": "string",
    "currency": "string",
    "counter": 0,
    "lastBlock": "string",
    "requestProcessingTime": 0
  }
}

getOffer

Get offer details given an offer ID

POST

https://ardr.nownodes.io/nxt

Body

application/json

jsonrpcstringrequired

methodstringrequired

paramsobjectrequired

Show child attributes

requestTypestring

chaininteger

The chain related to the operation

offerstring

The offer ID

requireBlockstring

The block ID of a block that must be present in the blockchain during execution

requireLastBlockstring

The block ID of a block that must be last in the blockchain during execution

idintegerrequired

Response

200OK

Offer details retrieved successfully

400Bad Request

Bad Request

401Unauthorized

Unauthorized — Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Get offer details given an offer ID

curl -X POST 'https://ardr.nownodes.io/nxt' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "getOffer",
    "params": {
      "requestType": "getOffer",
      "chain": 0,
      "offer": "string",
      "requireBlock": "string",
      "requireLastBlock": "string"
    },
    "id": 1
  }'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "getOffer",
      "params": {
        "requestType": "getOffer",
        "chain": 0,
        "offer": "string",
        "requireBlock": "string",
        "requireLastBlock": "string"
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "getOffer",
  "params": {
    "requestType": "getOffer",
    "chain": 0,
    "offer": "string",
    "requireBlock": "string",
    "requireLastBlock": "string"
  },
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "getOffer",
  "params": {
    "requestType": "getOffer",
    "chain": 0,
    "offer": "string",
    "requireBlock": "string",
    "requireLastBlock": "string"
  },
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "sellOffer": {
      "offer": "string",
      "supplyQNT": "string",
      "expirationHeight": 0,
      "accountRS": "string",
      "rateNQTPerUnit": "string",
      "limitQNT": "string",
      "currency": "string",
      "offerFullHash": "string",
      "account": "string",
      "height": 0
    },
    "buyOffer": {
      "offer": "string",
      "supplyQNT": "string",
      "expirationHeight": 0,
      "accountRS": "string",
      "rateNQTPerUnit": "string",
      "limitQNT": "string",
      "currency": "string",
      "offerFullHash": "string",
      "account": "string",
      "height": 0
    },
    "lastBlock": "string",
    "requestProcessingTime": 0
  }
}

getSellOffers

Get currency sell offers given a currency ID and/or an account ID

POST

https://ardr.nownodes.io/nxt

Body

application/json

jsonrpcstringrequired

methodstringrequired

paramsobjectrequired

Show child attributes

requestTypestring

chaininteger

The chain related to the operation

currencystring

The currency ID

accountstring

The account ID

availableOnlyboolean

True to include only offers with non-zero supply and limit

firstIndexinteger

A zero-based index to the first offer to retrieve

lastIndexinteger

A zero-based index to the last offer to retrieve

requireBlockstring

The block ID of a block that must be present in the blockchain during execution

requireLastBlockstring

The block ID of a block that must be last in the blockchain during execution

idintegerrequired

Response

200OK

Sell offers retrieved successfully

400Bad Request

Bad Request

401Unauthorized

Unauthorized — Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Get currency sell offers given a currency ID and/or an account ID

curl -X POST 'https://ardr.nownodes.io/nxt' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "getSellOffers",
    "params": {
      "requestType": "getSellOffers",
      "chain": 0,
      "currency": "string",
      "account": "string",
      "availableOnly": true,
      "firstIndex": 0,
      "lastIndex": 0,
      "requireBlock": "string",
      "requireLastBlock": "string"
    },
    "id": 1
  }'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "getSellOffers",
      "params": {
        "requestType": "getSellOffers",
        "chain": 0,
        "currency": "string",
        "account": "string",
        "availableOnly": true,
        "firstIndex": 0,
        "lastIndex": 0,
        "requireBlock": "string",
        "requireLastBlock": "string"
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "getSellOffers",
  "params": {
    "requestType": "getSellOffers",
    "chain": 0,
    "currency": "string",
    "account": "string",
    "availableOnly": True,
    "firstIndex": 0,
    "lastIndex": 0,
    "requireBlock": "string",
    "requireLastBlock": "string"
  },
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "getSellOffers",
  "params": {
    "requestType": "getSellOffers",
    "chain": 0,
    "currency": "string",
    "account": "string",
    "availableOnly": true,
    "firstIndex": 0,
    "lastIndex": 0,
    "requireBlock": "string",
    "requireLastBlock": "string"
  },
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "offers": [
      {
        "offer": "string",
        "supplyQNT": "string",
        "expirationHeight": 0,
        "accountRS": "string",
        "rateNQTPerUnit": "string",
        "limitQNT": "string",
        "currency": "string",
        "offerFullHash": "string",
        "account": "string",
        "height": 0
      }
    ],
    "lastBlock": "string",
    "requestProcessingTime": 0
  }
}

issueCurrency

Issue a new currency or re-issue an existing currency with different properties

POST

https://ardr.nownodes.io/nxt

Body

application/json

jsonrpcstringrequired

methodstringrequired

paramsobjectrequired

Show child attributes

requestTypestring

chaininteger

The chain related to the operation

namestring

The currency name, 3 to 10 characters and longer than the currency code

codestring

The uppercase currency code

descriptionstring

The currency description

typeinteger

The currency type bitmask

initialSupplyQNTstring

The initial currency supply (in QNT)

reserveSupplyQNTstring

The reserve currency supply (in QNT)

maxSupplyQNTstring

The maximum currency supply (in QNT)

issuanceHeightinteger

The blockchain height at which a reservable currency is issued

minReservePerUnitNQTstring

The minimum currency reserve (in NQT per QNT of reserveSupply) for issuance

minDifficultyinteger

The minimum difficulty for a mintable currency

maxDifficultyinteger

The maximum difficulty for a mintable currency

rulesetinteger

For future use, always set to zero

algorithminteger

An algorithm code for a mintable currency

decimalsinteger

The number of decimal places used by the currency

idintegerrequired

Response

200OK

Currency issued successfully

400Bad Request

Bad Request

401Unauthorized

Unauthorized — Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Issue a new currency or re-issue an existing currency with different properties

curl -X POST 'https://ardr.nownodes.io/nxt' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "issueCurrency",
    "params": {
      "requestType": "issueCurrency",
      "chain": 0,
      "name": "string",
      "code": "string",
      "description": "string",
      "type": 0,
      "initialSupplyQNT": "string",
      "reserveSupplyQNT": "string",
      "maxSupplyQNT": "string",
      "issuanceHeight": 0,
      "minReservePerUnitNQT": "string",
      "minDifficulty": 0,
      "maxDifficulty": 0,
      "ruleset": 0,
      "algorithm": 0,
      "decimals": 0
    },
    "id": 1
  }'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "issueCurrency",
      "params": {
        "requestType": "issueCurrency",
        "chain": 0,
        "name": "string",
        "code": "string",
        "description": "string",
        "type": 0,
        "initialSupplyQNT": "string",
        "reserveSupplyQNT": "string",
        "maxSupplyQNT": "string",
        "issuanceHeight": 0,
        "minReservePerUnitNQT": "string",
        "minDifficulty": 0,
        "maxDifficulty": 0,
        "ruleset": 0,
        "algorithm": 0,
        "decimals": 0
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "issueCurrency",
  "params": {
    "requestType": "issueCurrency",
    "chain": 0,
    "name": "string",
    "code": "string",
    "description": "string",
    "type": 0,
    "initialSupplyQNT": "string",
    "reserveSupplyQNT": "string",
    "maxSupplyQNT": "string",
    "issuanceHeight": 0,
    "minReservePerUnitNQT": "string",
    "minDifficulty": 0,
    "maxDifficulty": 0,
    "ruleset": 0,
    "algorithm": 0,
    "decimals": 0
  },
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "issueCurrency",
  "params": {
    "requestType": "issueCurrency",
    "chain": 0,
    "name": "string",
    "code": "string",
    "description": "string",
    "type": 0,
    "initialSupplyQNT": "string",
    "reserveSupplyQNT": "string",
    "maxSupplyQNT": "string",
    "issuanceHeight": 0,
    "minReservePerUnitNQT": "string",
    "minDifficulty": 0,
    "maxDifficulty": 0,
    "ruleset": 0,
    "algorithm": 0,
    "decimals": 0
  },
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "signatureHash": "string",
    "unsignedTransactionBytes": "string",
    "transactionJSON": {
      "senderPublicKey": "string",
      "chain": 0,
      "signature": "string",
      "feeNQT": "string",
      "type": 0,
      "fullHash": "string",
      "version": 0,
      "ecBlockId": "string",
      "signatureHash": "string",
      "attachment": {
        "initialSupply": "string",
        "code": "string",
        "minDifficulty": 0,
        "ruleset": 0,
        "description": "string",
        "minReservePerUnitNQT": "string",
        "issuanceHeight": 0,
        "type": 0,
        "reserveSupply": "string",
        "version.CurrencyIssuance": 0,
        "maxDifficulty": 0,
        "decimals": 0,
        "name": "string",
        "maxSupply": "string",
        "algorithm": 0
      },
      "senderRS": "string",
      "subtype": 0,
      "amountNQT": "string",
      "sender": "string",
      "ecBlockHeight": 0,
      "deadline": 0,
      "transaction": "string",
      "timestamp": 0,
      "height": 0
    },
    "broadcasted": true,
    "requestProcessingTime": 0,
    "transactionBytes": "string",
    "fullHash": "string",
    "transaction": "string"
  }
}

publishExchangeOffer

Publish an exchange offer for an exchangeable currency

POST

https://ardr.nownodes.io/nxt

Body

application/json

jsonrpcstringrequired

methodstringrequired

paramsobjectrequired

Show child attributes

requestTypestring

chaininteger

The chain related to the operation

currencystring

The currency ID

buyRateNQTPerUnitstring

The offered buy rate (in NQT per QNT)

sellRateNQTPerUnitstring

The offered sell rate (in NQT per QNT)

totalBuyLimitQNTstring

The cumulative limit (in QNT) of currency buys

totalSellLimitQNTstring

The cumulative limit (in QNT) of currency sells

initialBuySupplyQNTstring

The initial amount (in QNT) of currency offered to buy

initialSellSupplyQNTstring

The initial amount (in QNT) of currency offered to sell

expirationHeightinteger

The blockchain height for expiration of the offer

idintegerrequired

Response

200OK

Exchange offer published successfully

400Bad Request

Bad Request

401Unauthorized

Unauthorized — Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Publish an exchange offer for an exchangeable currency

curl -X POST 'https://ardr.nownodes.io/nxt' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "publishExchangeOffer",
    "params": {
      "requestType": "publishExchangeOffer",
      "chain": 0,
      "currency": "string",
      "buyRateNQTPerUnit": "string",
      "sellRateNQTPerUnit": "string",
      "totalBuyLimitQNT": "string",
      "totalSellLimitQNT": "string",
      "initialBuySupplyQNT": "string",
      "initialSellSupplyQNT": "string",
      "expirationHeight": 0
    },
    "id": 1
  }'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "publishExchangeOffer",
      "params": {
        "requestType": "publishExchangeOffer",
        "chain": 0,
        "currency": "string",
        "buyRateNQTPerUnit": "string",
        "sellRateNQTPerUnit": "string",
        "totalBuyLimitQNT": "string",
        "totalSellLimitQNT": "string",
        "initialBuySupplyQNT": "string",
        "initialSellSupplyQNT": "string",
        "expirationHeight": 0
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "publishExchangeOffer",
  "params": {
    "requestType": "publishExchangeOffer",
    "chain": 0,
    "currency": "string",
    "buyRateNQTPerUnit": "string",
    "sellRateNQTPerUnit": "string",
    "totalBuyLimitQNT": "string",
    "totalSellLimitQNT": "string",
    "initialBuySupplyQNT": "string",
    "initialSellSupplyQNT": "string",
    "expirationHeight": 0
  },
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "publishExchangeOffer",
  "params": {
    "requestType": "publishExchangeOffer",
    "chain": 0,
    "currency": "string",
    "buyRateNQTPerUnit": "string",
    "sellRateNQTPerUnit": "string",
    "totalBuyLimitQNT": "string",
    "totalSellLimitQNT": "string",
    "initialBuySupplyQNT": "string",
    "initialSellSupplyQNT": "string",
    "expirationHeight": 0
  },
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "signatureHash": "string",
    "unsignedTransactionBytes": "string",
    "transactionJSON": {
      "senderPublicKey": "string",
      "chain": 0,
      "signature": "string",
      "feeNQT": "string",
      "type": 0,
      "fullHash": "string",
      "version": 0,
      "ecBlockId": "string",
      "signatureHash": "string",
      "attachment": {
        "totalSellLimit": "string",
        "buyRateNQTPerUnit": "string",
        "initialSellSupplyQNT": "string",
        "totalBuyLimitQNT": "string",
        "expirationHeight": 0,
        "sellRateNQTPerUnit": "string",
        "version.PublishExchangeOffer": 0,
        "currency": "string",
        "initialBuySupplyQNT": "string"
      },
      "senderRS": "string",
      "subtype": 0,
      "amountNQT": "string",
      "sender": "string",
      "ecBlockHeight": 0,
      "deadline": 0,
      "transaction": "string",
      "timestamp": 0,
      "height": 0
    },
    "broadcasted": true,
    "requestProcessingTime": 0,
    "transactionBytes": "string",
    "transaction": "string"
  }
}

searchCurrencies

Get currencies having a code that matches a given query in reverse relevance order

POST

https://ardr.nownodes.io/nxt

Body

application/json

jsonrpcstringrequired

methodstringrequired

paramsobjectrequired

Show child attributes

requestTypestring

querystring

A full text query on the currency field code in the standard Lucene syntax

firstIndexinteger

A zero-based index to the first currency to retrieve

lastIndexinteger

A zero-based index to the last currency to retrieve

includeCountsboolean

True if the fields beginning with numberOf... are to be included

requireBlockstring

The block ID of a block that must be present in the blockchain during execution

requireLastBlockstring

The block ID of a block that must be last in the blockchain during execution

idintegerrequired

Response

200OK

Currencies search results

400Bad Request

Bad Request

401Unauthorized

Unauthorized — Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Get currencies having a code that matches a given query in reverse relevance order

curl -X POST 'https://ardr.nownodes.io/nxt' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "searchCurrencies",
    "params": {
      "requestType": "searchCurrencies",
      "query": "string",
      "firstIndex": 0,
      "lastIndex": 0,
      "includeCounts": true,
      "requireBlock": "string",
      "requireLastBlock": "string"
    },
    "id": 1
  }'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "searchCurrencies",
      "params": {
        "requestType": "searchCurrencies",
        "query": "string",
        "firstIndex": 0,
        "lastIndex": 0,
        "includeCounts": true,
        "requireBlock": "string",
        "requireLastBlock": "string"
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "searchCurrencies",
  "params": {
    "requestType": "searchCurrencies",
    "query": "string",
    "firstIndex": 0,
    "lastIndex": 0,
    "includeCounts": True,
    "requireBlock": "string",
    "requireLastBlock": "string"
  },
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "searchCurrencies",
  "params": {
    "requestType": "searchCurrencies",
    "query": "string",
    "firstIndex": 0,
    "lastIndex": 0,
    "includeCounts": true,
    "requireBlock": "string",
    "requireLastBlock": "string"
  },
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "currencies": [
      {
        "currentReservePerUnitNQT": "string",
        "chain": 0,
        "types": [
          "string"
        ],
        "code": "string",
        "currentSupplyQNT": "string",
        "creationHeight": 0,
        "minDifficulty": 0,
        "description": "string",
        "minReservePerUnitNQT": "string",
        "initialSupplyQNT": "string",
        "issuanceHeight": 0,
        "type": 0,
        "maxSupplyQNT": "string",
        "maxDifficulty": 0,
        "accountRS": "string",
        "decimals": 0,
        "name": "string",
        "reserveSupplyQNT": "string",
        "currency": "string",
        "account": "string",
        "algorithm": 0
      }
    ],
    "lastBlock": "string",
    "requestProcessingTime": 0
  }
}

transferCurrency

Transfer currency to a given recipient

POST

https://ardr.nownodes.io/nxt

Body

application/json

jsonrpcstringrequired

methodstringrequired

paramsobjectrequired

Show child attributes

requestTypestring

chaininteger

The chain related to the operation

recipientstring

The account ID of the transfer recipient

currencystring

The currency ID

unitsQNTstring

The amount (in QNT) of the transfer

idintegerrequired

Response

200OK

Currency transfer created successfully

400Bad Request

Bad Request

401Unauthorized

Unauthorized — Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Transfer currency to a given recipient

curl -X POST 'https://ardr.nownodes.io/nxt' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "transferCurrency",
    "params": {
      "requestType": "transferCurrency",
      "chain": 0,
      "recipient": "string",
      "currency": "string",
      "unitsQNT": "string"
    },
    "id": 1
  }'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "transferCurrency",
      "params": {
        "requestType": "transferCurrency",
        "chain": 0,
        "recipient": "string",
        "currency": "string",
        "unitsQNT": "string"
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "transferCurrency",
  "params": {
    "requestType": "transferCurrency",
    "chain": 0,
    "recipient": "string",
    "currency": "string",
    "unitsQNT": "string"
  },
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "transferCurrency",
  "params": {
    "requestType": "transferCurrency",
    "chain": 0,
    "recipient": "string",
    "currency": "string",
    "unitsQNT": "string"
  },
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "minimumFeeFQT": "string",
    "signatureHash": "string",
    "transactionJSON": {
      "senderPublicKey": "string",
      "chain": 0,
      "signature": "string",
      "feeNQT": "string",
      "type": 0,
      "fullHash": "string",
      "version": 0,
      "fxtTransaction": "string",
      "phased": true,
      "ecBlockId": "string",
      "signatureHash": "string",
      "attachment": {
        "currency": "string",
        "version.CurrencyTransfer": 0,
        "unitsQNT": "string"
      },
      "senderRS": "string",
      "subtype": 0,
      "amountNQT": "string",
      "sender": "string",
      "recipientRS": "string",
      "recipient": "string",
      "ecBlockHeight": 0,
      "deadline": 0,
      "timestamp": 0,
      "height": 0
    },
    "unsignedTransactionBytes": "string",
    "broadcasted": true,
    "requestProcessingTime": 0,
    "transactionBytes": "string",
    "fullHash": "string",
    "bundlerRateNQTPerFXT": "string"
  }
}

Search

searchCurrencies

Search currencies by query

GET

https://ardr.nownodes.io/nxt

Parameters

requestTypestringrequiredquery

querystringrequiredquery

Response

200OK

Currencies matching the search query

400Bad Request

Bad Request

500Internal Server Error

Internal Server Error

Search currencies by query

curl -X GET 'https://ardr.nownodes.io/nxt'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ardr.nownodes.io/nxt')
data = response.json()

200

{
  "requestProcessingTime": 27,
  "currencies": [
    {}
  ]
}

searchPolls

Search polls by query

GET

https://ardr.nownodes.io/nxt

Parameters

requestTypestringrequiredquery

chainintegerrequiredquery

querystringrequiredquery

includeFinishedbooleanquery

Response

200OK

Polls matching the search query

400Bad Request

Bad Request

500Internal Server Error

Internal Server Error

Search polls by query

curl -X GET 'https://ardr.nownodes.io/nxt'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ardr.nownodes.io/nxt')
data = response.json()

200

{
  "requestProcessingTime": 19,
  "polls": [
    {
      "minRangeValue": 0,
      "votingModel": 0,
      "description": "HELLO WORLD",
      "finished": true,
      "poll": "15782508803332293630",
      "minNumberOfOptions": 1,
      "holding": "13666697367314031635",
      "minBalance": "1",
      "accountRS": "ARDOR-D7VC-BSEV-SPKC-DJZ39",
      "name": "Best Fruit",
      "options": [
        "Apple",
        "Banana",
        "Pear",
        "Orange",
        "Strawberry",
        "Watermelon"
      ],
      "finishHeight": 297467,
      "maxNumberOfOptions": 1,
      "minBalanceModel": 2,
      "account": "12936572672874485610",
      "maxRangeValue": 1,
      "timestamp": 17651519
    }
  ]
}

Phasing

approveTransaction

Approve (vote for) a phased transaction

POST

https://ardr.nownodes.io/nxt

Body

application/json

jsonrpcstringrequired

methodstringrequired

paramsobjectrequired

Show child attributes

requestTypestring

chaininteger

The chain related to the operation

phasedTransactionArray<string>

The full hash of the transaction to be approved (may be used up to 10 times per API request)

revealedSecretstring

The secret phrase (required only for phasingVotingModel 5)

revealedSecretIsTextboolean

A way of specifying whether revealedSecret is text or binary

idintegerrequired

Response

200OK

Transaction approved successfully

400Bad Request

Bad Request

401Unauthorized

Unauthorized — Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Approve (vote for) a phased transaction

curl -X POST 'https://ardr.nownodes.io/nxt' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "approveTransaction",
    "params": {
      "requestType": "approveTransaction",
      "chain": 0,
      "phasedTransaction": [
        "string"
      ],
      "revealedSecret": "string",
      "revealedSecretIsText": true
    },
    "id": 1
  }'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "approveTransaction",
      "params": {
        "requestType": "approveTransaction",
        "chain": 0,
        "phasedTransaction": [
          "string"
        ],
        "revealedSecret": "string",
        "revealedSecretIsText": true
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "approveTransaction",
  "params": {
    "requestType": "approveTransaction",
    "chain": 0,
    "phasedTransaction": [
      "string"
    ],
    "revealedSecret": "string",
    "revealedSecretIsText": True
  },
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "approveTransaction",
  "params": {
    "requestType": "approveTransaction",
    "chain": 0,
    "phasedTransaction": [
      "string"
    ],
    "revealedSecret": "string",
    "revealedSecretIsText": true
  },
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "minimumFeeFQT": "string",
    "signatureHash": "string",
    "transactionJSON": {
      "senderPublicKey": "string",
      "chain": 0,
      "signature": "string",
      "feeNQT": "string",
      "type": 0,
      "fullHash": "string",
      "version": 0,
      "fxtTransaction": "string",
      "phased": true,
      "ecBlockId": "string",
      "signatureHash": "string",
      "attachment": {
        "phasedTransactions": [
          {
            "chain": 0,
            "transactionFullHash": "string"
          }
        ],
        "version.PhasingVoteCasting": 0
      },
      "senderRS": "string",
      "subtype": 0,
      "amountNQT": "string",
      "sender": "string",
      "ecBlockHeight": 0,
      "deadline": 0,
      "timestamp": 0,
      "height": 0
    },
    "unsignedTransactionBytes": "string",
    "broadcasted": true,
    "requestProcessingTime": 0,
    "transactionBytes": "string",
    "fullHash": "string",
    "bundlerRateNQTPerFXT": "string"
  }
}

createPhasedTransaction

Create a phased transaction with conditional deferred execution

POST

https://ardr.nownodes.io/nxt

Body

application/json

jsonrpcstringrequired

methodstringrequired

paramsobjectrequired

Show child attributes

requestTypestring

chaininteger

The chain related to the operation

phasedboolean

True to create a phased transaction

phasingFinishHeightinteger

The block height at which the poll will finish

phasingVotingModelinteger

An integer code for the method of approval

phasingQuorumstring

The number of votes needed for transaction approval

phasingMinBalancestring

The minimum balance required for voting

phasingMinBalanceModelinteger

The minimum balance model

phasingHoldingstring

The asset or currency ID

phasingWhitelistedArray<string>

Account ID of an account allowed to vote

phasingLinkedFullHashArray<string>

Full hash of a transaction that must be in the blockchain

phasingHashedSecretstring

The hash of a secret phrase required for approval

phasingHashedSecretAlgorithminteger

The hash function used

idintegerrequired

Response

200OK

Phased transaction created successfully

400Bad Request

Bad Request

401Unauthorized

Unauthorized — Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Create a phased transaction with conditional deferred execution

curl -X POST 'https://ardr.nownodes.io/nxt' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "createPhasedTransaction",
    "params": {
      "requestType": "sendMoney",
      "chain": 0,
      "phased": true,
      "phasingFinishHeight": 0,
      "phasingVotingModel": 0,
      "phasingQuorum": "string",
      "phasingMinBalance": "string",
      "phasingMinBalanceModel": 0,
      "phasingHolding": "string",
      "phasingWhitelisted": [
        "string"
      ],
      "phasingLinkedFullHash": [
        "string"
      ],
      "phasingHashedSecret": "string",
      "phasingHashedSecretAlgorithm": 0
    },
    "id": 1
  }'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "createPhasedTransaction",
      "params": {
        "requestType": "sendMoney",
        "chain": 0,
        "phased": true,
        "phasingFinishHeight": 0,
        "phasingVotingModel": 0,
        "phasingQuorum": "string",
        "phasingMinBalance": "string",
        "phasingMinBalanceModel": 0,
        "phasingHolding": "string",
        "phasingWhitelisted": [
          "string"
        ],
        "phasingLinkedFullHash": [
          "string"
        ],
        "phasingHashedSecret": "string",
        "phasingHashedSecretAlgorithm": 0
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "createPhasedTransaction",
  "params": {
    "requestType": "sendMoney",
    "chain": 0,
    "phased": True,
    "phasingFinishHeight": 0,
    "phasingVotingModel": 0,
    "phasingQuorum": "string",
    "phasingMinBalance": "string",
    "phasingMinBalanceModel": 0,
    "phasingHolding": "string",
    "phasingWhitelisted": [
      "string"
    ],
    "phasingLinkedFullHash": [
      "string"
    ],
    "phasingHashedSecret": "string",
    "phasingHashedSecretAlgorithm": 0
  },
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "createPhasedTransaction",
  "params": {
    "requestType": "sendMoney",
    "chain": 0,
    "phased": true,
    "phasingFinishHeight": 0,
    "phasingVotingModel": 0,
    "phasingQuorum": "string",
    "phasingMinBalance": "string",
    "phasingMinBalanceModel": 0,
    "phasingHolding": "string",
    "phasingWhitelisted": [
      "string"
    ],
    "phasingLinkedFullHash": [
      "string"
    ],
    "phasingHashedSecret": "string",
    "phasingHashedSecretAlgorithm": 0
  },
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "signatureHash": "string",
    "unsignedTransactionBytes": "string",
    "transactionJSON": {
      "senderPublicKey": "string",
      "chain": 0,
      "signature": "string",
      "feeNQT": "string",
      "type": 0,
      "fullHash": "string",
      "version": 0,
      "phased": true,
      "ecBlockId": "string",
      "signatureHash": "string",
      "attachment": {
        "phasingFinishHeight": 0,
        "phasingHolding": "string",
        "phasingQuorum": "string",
        "version.Phasing": 0,
        "phasingMinBalance": "string",
        "phasingMinBalanceModel": 0,
        "version.OrdinaryPayment": 0,
        "phasingVotingModel": 0
      },
      "senderRS": "string",
      "subtype": 0,
      "amountNQT": "string",
      "sender": "string",
      "recipientRS": "string",
      "recipient": "string",
      "ecBlockHeight": 0,
      "deadline": 0,
      "transaction": "string",
      "timestamp": 0,
      "height": 0
    },
    "broadcasted": true,
    "requestProcessingTime": 0,
    "transactionBytes": "string",
    "fullHash": "string",
    "transaction": "string",
    "bundlerRateNQTPerFXT": "string"
  }
}

getAccountPhasedTransactionCount

Get the number of pending phased transactions associated with an account

POST

https://ardr.nownodes.io/nxt

Body

application/json

jsonrpcstringrequired

methodstringrequired

paramsobjectrequired

Show child attributes

requestTypestring

chaininteger

The chain related to the operation

accountstring

The account ID

requireBlockstring

The block ID of a block that must be present in the blockchain during execution

requireLastBlockstring

The block ID of a block that must be last in the blockchain during execution

idintegerrequired

Response

200OK

Account phased transaction count retrieved successfully

400Bad Request

Bad Request

401Unauthorized

Unauthorized — Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Get the number of pending phased transactions associated with an account

curl -X POST 'https://ardr.nownodes.io/nxt' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "getAccountPhasedTransactionCount",
    "params": {
      "requestType": "getAccountPhasedTransactionCount",
      "chain": 0,
      "account": "string",
      "requireBlock": "string",
      "requireLastBlock": "string"
    },
    "id": 1
  }'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "getAccountPhasedTransactionCount",
      "params": {
        "requestType": "getAccountPhasedTransactionCount",
        "chain": 0,
        "account": "string",
        "requireBlock": "string",
        "requireLastBlock": "string"
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "getAccountPhasedTransactionCount",
  "params": {
    "requestType": "getAccountPhasedTransactionCount",
    "chain": 0,
    "account": "string",
    "requireBlock": "string",
    "requireLastBlock": "string"
  },
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "getAccountPhasedTransactionCount",
  "params": {
    "requestType": "getAccountPhasedTransactionCount",
    "chain": 0,
    "account": "string",
    "requireBlock": "string",
    "requireLastBlock": "string"
  },
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "numberOfPhasedTransactions": 0,
    "lastBlock": "string",
    "requestProcessingTime": 0
  }
}

getAccountPhasedTransactions

Get pending phased transactions associated with an account

POST

https://ardr.nownodes.io/nxt

Body

application/json

jsonrpcstringrequired

methodstringrequired

paramsobjectrequired

Show child attributes

requestTypestring

chaininteger

The chain related to the operation

accountstring

The account ID

firstIndexinteger

A zero-based index to the first phased transaction to retrieve

lastIndexinteger

A zero-based index to the last phased transaction to retrieve

requireBlockstring

The block ID of a block that must be present in the blockchain during execution

requireLastBlockstring

The block ID of a block that must be last in the blockchain during execution

idintegerrequired

Response

200OK

Account phased transactions retrieved successfully

400Bad Request

Bad Request

401Unauthorized

Unauthorized — Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Get pending phased transactions associated with an account

curl -X POST 'https://ardr.nownodes.io/nxt' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "getAccountPhasedTransactions",
    "params": {
      "requestType": "getAccountPhasedTransactions",
      "chain": 0,
      "account": "string",
      "firstIndex": 0,
      "lastIndex": 0,
      "requireBlock": "string",
      "requireLastBlock": "string"
    },
    "id": 1
  }'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "getAccountPhasedTransactions",
      "params": {
        "requestType": "getAccountPhasedTransactions",
        "chain": 0,
        "account": "string",
        "firstIndex": 0,
        "lastIndex": 0,
        "requireBlock": "string",
        "requireLastBlock": "string"
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "getAccountPhasedTransactions",
  "params": {
    "requestType": "getAccountPhasedTransactions",
    "chain": 0,
    "account": "string",
    "firstIndex": 0,
    "lastIndex": 0,
    "requireBlock": "string",
    "requireLastBlock": "string"
  },
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "getAccountPhasedTransactions",
  "params": {
    "requestType": "getAccountPhasedTransactions",
    "chain": 0,
    "account": "string",
    "firstIndex": 0,
    "lastIndex": 0,
    "requireBlock": "string",
    "requireLastBlock": "string"
  },
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "transactions": [
      {
        "signature": "string",
        "transactionIndex": 0,
        "type": 0,
        "fxtTransaction": "string",
        "phased": true,
        "ecBlockId": "string",
        "signatureHash": "string",
        "attachment": {},
        "senderRS": "string",
        "subtype": 0,
        "amountNQT": "string",
        "recipientRS": "string",
        "block": "string",
        "blockTimestamp": 0,
        "timestamp": 0,
        "deadline": 0,
        "height": 0,
        "senderPublicKey": "string",
        "chain": 0,
        "feeNQT": "string",
        "confirmations": 0,
        "fullHash": "string",
        "version": 0,
        "sender": "string",
        "recipient": "string",
        "ecBlockHeight": 0
      }
    ],
    "requestProcessingTime": 0
  }
}

getAssetPhasedTransactions

Get pending phased transactions based on an asset

POST

https://ardr.nownodes.io/nxt

Body

application/json

jsonrpcstringrequired

methodstringrequired

paramsobjectrequired

Show child attributes

requestTypestring

chaininteger

The chain related to the operation

assetstring

The asset ID

accountstring

An account ID of the account that created the phased transactions

withoutWhitelistboolean

True to omit phased transactions that include a whitelist

firstIndexinteger

A zero-based index to the first phased transaction to retrieve

lastIndexinteger

A zero-based index to the last phased transaction to retrieve

requireBlockstring

The block ID of a block that must be present in the blockchain during execution

requireLastBlockstring

The block ID of a block that must be last in the blockchain during execution

idintegerrequired

Response

200OK

Asset phased transactions retrieved successfully

400Bad Request

Bad Request

401Unauthorized

Unauthorized — Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Get pending phased transactions based on an asset

curl -X POST 'https://ardr.nownodes.io/nxt' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "getAssetPhasedTransactions",
    "params": {
      "requestType": "getAssetPhasedTransactions",
      "chain": 0,
      "asset": "string",
      "account": "string",
      "withoutWhitelist": true,
      "firstIndex": 0,
      "lastIndex": 0,
      "requireBlock": "string",
      "requireLastBlock": "string"
    },
    "id": 1
  }'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "getAssetPhasedTransactions",
      "params": {
        "requestType": "getAssetPhasedTransactions",
        "chain": 0,
        "asset": "string",
        "account": "string",
        "withoutWhitelist": true,
        "firstIndex": 0,
        "lastIndex": 0,
        "requireBlock": "string",
        "requireLastBlock": "string"
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "getAssetPhasedTransactions",
  "params": {
    "requestType": "getAssetPhasedTransactions",
    "chain": 0,
    "asset": "string",
    "account": "string",
    "withoutWhitelist": True,
    "firstIndex": 0,
    "lastIndex": 0,
    "requireBlock": "string",
    "requireLastBlock": "string"
  },
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "getAssetPhasedTransactions",
  "params": {
    "requestType": "getAssetPhasedTransactions",
    "chain": 0,
    "asset": "string",
    "account": "string",
    "withoutWhitelist": true,
    "firstIndex": 0,
    "lastIndex": 0,
    "requireBlock": "string",
    "requireLastBlock": "string"
  },
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "transactions": [
      {
        "signature": "string",
        "transactionIndex": 0,
        "type": 0,
        "phased": true,
        "ecBlockId": "string",
        "signatureHash": "string",
        "attachment": {},
        "senderRS": "string",
        "subtype": 0,
        "amountNQT": "string",
        "recipientRS": "string",
        "block": "string",
        "blockTimestamp": 0,
        "deadline": 0,
        "timestamp": 0,
        "height": 0,
        "senderPublicKey": "string",
        "chain": 0,
        "feeNQT": "string",
        "confirmations": 0,
        "fullHash": "string",
        "version": 0,
        "sender": "string",
        "recipient": "string",
        "ecBlockHeight": 0,
        "transaction": "string"
      }
    ],
    "requestProcessingTime": 0
  }
}

getCurrencyPhasedTransactions

Get pending phased transactions based on a currency

POST

https://ardr.nownodes.io/nxt

Body

application/json

jsonrpcstringrequired

methodstringrequired

paramsobjectrequired

Show child attributes

requestTypestring

chaininteger

The chain related to the operation

currencystring

The currency ID

accountstring

An account ID of the account that created the phased transactions

withoutWhitelistboolean

True to omit phased transactions that include a whitelist

firstIndexinteger

A zero-based index to the first phased transaction to retrieve

lastIndexinteger

A zero-based index to the last phased transaction to retrieve

requireBlockstring

The block ID of a block that must be present in the blockchain during execution

requireLastBlockstring

The block ID of a block that must be last in the blockchain during execution

idintegerrequired

Response

200OK

Currency phased transactions retrieved successfully

400Bad Request

Bad Request

401Unauthorized

Unauthorized — Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Get pending phased transactions based on a currency

curl -X POST 'https://ardr.nownodes.io/nxt' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "getCurrencyPhasedTransactions",
    "params": {
      "requestType": "getCurrencyPhasedTransactions",
      "chain": 0,
      "currency": "string",
      "account": "string",
      "withoutWhitelist": true,
      "firstIndex": 0,
      "lastIndex": 0,
      "requireBlock": "string",
      "requireLastBlock": "string"
    },
    "id": 1
  }'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "getCurrencyPhasedTransactions",
      "params": {
        "requestType": "getCurrencyPhasedTransactions",
        "chain": 0,
        "currency": "string",
        "account": "string",
        "withoutWhitelist": true,
        "firstIndex": 0,
        "lastIndex": 0,
        "requireBlock": "string",
        "requireLastBlock": "string"
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "getCurrencyPhasedTransactions",
  "params": {
    "requestType": "getCurrencyPhasedTransactions",
    "chain": 0,
    "currency": "string",
    "account": "string",
    "withoutWhitelist": True,
    "firstIndex": 0,
    "lastIndex": 0,
    "requireBlock": "string",
    "requireLastBlock": "string"
  },
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "getCurrencyPhasedTransactions",
  "params": {
    "requestType": "getCurrencyPhasedTransactions",
    "chain": 0,
    "currency": "string",
    "account": "string",
    "withoutWhitelist": true,
    "firstIndex": 0,
    "lastIndex": 0,
    "requireBlock": "string",
    "requireLastBlock": "string"
  },
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "transactions": [
      {
        "signature": "string",
        "transactionIndex": 0,
        "type": 0,
        "phased": true,
        "ecBlockId": "string",
        "signatureHash": "string",
        "attachment": {},
        "senderRS": "string",
        "subtype": 0,
        "amountNQT": "string",
        "recipientRS": "string",
        "block": "string",
        "blockTimestamp": 0,
        "deadline": 0,
        "timestamp": 0,
        "height": 0,
        "senderPublicKey": "string",
        "chain": 0,
        "feeNQT": "string",
        "confirmations": 0,
        "fullHash": "string",
        "version": 0,
        "sender": "string",
        "recipient": "string",
        "ecBlockHeight": 0,
        "transaction": "string"
      }
    ],
    "requestProcessingTime": 0
  }
}

getHashedSecretPhasedTransactions

Returns a list of phased by hash transactions

POST

https://ardr.nownodes.io/nxt

Body

application/json

jsonrpcstringrequired

methodstringrequired

paramsobjectrequired

Show child attributes

requestTypestring

phasingHashedSecretstring

The hash of a secret phrase required for approval

phasingHashedSecretAlgorithminteger

The hash function used

requireBlockstring

The block ID of a block that must be present in the blockchain during execution

requireLastBlockstring

The block ID of a block that must be last in the blockchain during execution

idintegerrequired

Response

200OK

Hashed secret phased transactions retrieved successfully

400Bad Request

Bad Request

401Unauthorized

Unauthorized — Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Returns a list of phased by hash transactions

curl -X POST 'https://ardr.nownodes.io/nxt' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "getHashedSecretPhasedTransactions",
    "params": {
      "requestType": "getHashedSecretPhasedTransactions",
      "phasingHashedSecret": "string",
      "phasingHashedSecretAlgorithm": 0,
      "requireBlock": "string",
      "requireLastBlock": "string"
    },
    "id": 1
  }'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "getHashedSecretPhasedTransactions",
      "params": {
        "requestType": "getHashedSecretPhasedTransactions",
        "phasingHashedSecret": "string",
        "phasingHashedSecretAlgorithm": 0,
        "requireBlock": "string",
        "requireLastBlock": "string"
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "getHashedSecretPhasedTransactions",
  "params": {
    "requestType": "getHashedSecretPhasedTransactions",
    "phasingHashedSecret": "string",
    "phasingHashedSecretAlgorithm": 0,
    "requireBlock": "string",
    "requireLastBlock": "string"
  },
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "getHashedSecretPhasedTransactions",
  "params": {
    "requestType": "getHashedSecretPhasedTransactions",
    "phasingHashedSecret": "string",
    "phasingHashedSecretAlgorithm": 0,
    "requireBlock": "string",
    "requireLastBlock": "string"
  },
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "transactions": [
      {
        "signature": "string",
        "transactionIndex": 0,
        "type": 0,
        "fxtTransaction": "string",
        "phased": true,
        "ecBlockId": "string",
        "signatureHash": "string",
        "attachment": {},
        "senderRS": "string",
        "subtype": 0,
        "amountNQT": "string",
        "recipientRS": "string",
        "block": "string",
        "blockTimestamp": 0,
        "deadline": 0,
        "timestamp": 0,
        "height": 0,
        "senderPublicKey": "string",
        "chain": 0,
        "feeNQT": "string",
        "confirmations": 0,
        "fullHash": "string",
        "version": 0,
        "sender": "string",
        "recipient": "string",
        "ecBlockHeight": 0
      }
    ],
    "requestProcessingTime": 0
  }
}

null

Gets the phased transactions with by-transaction voting model

POST

https://ardr.nownodes.io/nxt

Body

application/json

jsonrpcstringrequired

methodstringrequired

paramsobjectrequired

Show child attributes

requestTypestring

linkedFullHashstring

The full hash of the transaction

requireBlockstring

The block ID of a block that must be present in the blockchain during execution

requireLastBlockstring

The block ID of a block that must be last in the blockchain during execution

idintegerrequired

Response

200OK

Linked phased transactions retrieved successfully

400Bad Request

Bad Request

401Unauthorized

Unauthorized — Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Gets the phased transactions with by-transaction voting model

curl -X POST 'https://ardr.nownodes.io/nxt' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "getLinkedPhasedTransactions",
    "params": {
      "requestType": "getLinkedPhasedTransactions",
      "linkedFullHash": "string",
      "requireBlock": "string",
      "requireLastBlock": "string"
    },
    "id": 1
  }'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "getLinkedPhasedTransactions",
      "params": {
        "requestType": "getLinkedPhasedTransactions",
        "linkedFullHash": "string",
        "requireBlock": "string",
        "requireLastBlock": "string"
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "getLinkedPhasedTransactions",
  "params": {
    "requestType": "getLinkedPhasedTransactions",
    "linkedFullHash": "string",
    "requireBlock": "string",
    "requireLastBlock": "string"
  },
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "getLinkedPhasedTransactions",
  "params": {
    "requestType": "getLinkedPhasedTransactions",
    "linkedFullHash": "string",
    "requireBlock": "string",
    "requireLastBlock": "string"
  },
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "transactions": [
      {
        "signature": "string",
        "transactionIndex": 0,
        "type": 0,
        "phased": true,
        "ecBlockId": "string",
        "signatureHash": "string",
        "attachment": {},
        "senderRS": "string",
        "subtype": 0,
        "amountNQT": "string",
        "recipientRS": "string",
        "block": "string",
        "blockTimestamp": 0,
        "deadline": 0,
        "timestamp": 0,
        "height": 0,
        "senderPublicKey": "string",
        "chain": 0,
        "feeNQT": "string",
        "confirmations": 0,
        "fullHash": "string",
        "version": 0,
        "sender": "string",
        "recipient": "string",
        "ecBlockHeight": 0,
        "transaction": "string"
      }
    ],
    "requestProcessingTime": 0
  }
}

getPhasingPoll

Get the details of a phasing poll

POST

https://ardr.nownodes.io/nxt

Body

application/json

jsonrpcstringrequired

methodstringrequired

paramsobjectrequired

Show child attributes

requestTypestring

chaininteger

The chain related to the operation

transactionstring

The transaction ID of the phasing poll

countVotesboolean

True to compute the poll result while the votes are still available

requireBlockstring

The block ID of a block that must be present in the blockchain during execution

requireLastBlockstring

The block ID of a block that must be last in the blockchain during execution

idintegerrequired

Response

200OK

Phasing poll details retrieved successfully

400Bad Request

Bad Request

401Unauthorized

Unauthorized — Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Get the details of a phasing poll

curl -X POST 'https://ardr.nownodes.io/nxt' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "getPhasingPoll",
    "params": {
      "requestType": "getPhasingPoll",
      "chain": 0,
      "transaction": "string",
      "countVotes": true,
      "requireBlock": "string",
      "requireLastBlock": "string"
    },
    "id": 1
  }'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "getPhasingPoll",
      "params": {
        "requestType": "getPhasingPoll",
        "chain": 0,
        "transaction": "string",
        "countVotes": true,
        "requireBlock": "string",
        "requireLastBlock": "string"
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "getPhasingPoll",
  "params": {
    "requestType": "getPhasingPoll",
    "chain": 0,
    "transaction": "string",
    "countVotes": True,
    "requireBlock": "string",
    "requireLastBlock": "string"
  },
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "getPhasingPoll",
  "params": {
    "requestType": "getPhasingPoll",
    "chain": 0,
    "transaction": "string",
    "countVotes": true,
    "requireBlock": "string",
    "requireLastBlock": "string"
  },
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "transaction": "string",
    "account": "string",
    "accountRS": "string",
    "finishHeight": 0,
    "votingModel": 0,
    "quorum": "string",
    "transactionFullHash": "string",
    "finished": true,
    "result": "string",
    "approved": true,
    "minBalance": "string",
    "minBalanceModel": 0,
    "hashedSecret": "string",
    "linkedFullHashes": [
      "string"
    ],
    "whitelist": [
      {
        "whitelisted": "string",
        "whitelistedRS": "string"
      }
    ],
    "lastBlock": "string",
    "requestProcessingTime": 0
  }
}

getPhasingPollVote

Get a cast phasing poll vote

POST

https://ardr.nownodes.io/nxt

Body

application/json

jsonrpcstringrequired

methodstringrequired

paramsobjectrequired

Show child attributes

requestTypestring

chaininteger

The chain related to the operation

transactionFullHashstring

The phased transaction ID

accountstring

The account ID of a voter in the poll

requireBlockstring

The block ID of a block that must be present in the blockchain during execution

requireLastBlockstring

The block ID of a block that must be last in the blockchain during execution

idintegerrequired

Response

200OK

Phasing poll vote retrieved successfully

400Bad Request

Bad Request

401Unauthorized

Unauthorized — Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Get a cast phasing poll vote

curl -X POST 'https://ardr.nownodes.io/nxt' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "getPhasingPollVote",
    "params": {
      "requestType": "getPhasingPollVote",
      "chain": 0,
      "transactionFullHash": "string",
      "account": "string",
      "requireBlock": "string",
      "requireLastBlock": "string"
    },
    "id": 1
  }'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "getPhasingPollVote",
      "params": {
        "requestType": "getPhasingPollVote",
        "chain": 0,
        "transactionFullHash": "string",
        "account": "string",
        "requireBlock": "string",
        "requireLastBlock": "string"
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "getPhasingPollVote",
  "params": {
    "requestType": "getPhasingPollVote",
    "chain": 0,
    "transactionFullHash": "string",
    "account": "string",
    "requireBlock": "string",
    "requireLastBlock": "string"
  },
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "getPhasingPollVote",
  "params": {
    "requestType": "getPhasingPollVote",
    "chain": 0,
    "transactionFullHash": "string",
    "account": "string",
    "requireBlock": "string",
    "requireLastBlock": "string"
  },
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "voter": "string",
    "voterRS": "string",
    "transaction": "string",
    "lastBlock": "string",
    "requestProcessingTime": 0
  }
}

getPhasingPollVotes

Get all cast phasing poll votes in a phasing poll

POST

https://ardr.nownodes.io/nxt

Body

application/json

jsonrpcstringrequired

methodstringrequired

paramsobjectrequired

Show child attributes

requestTypestring

chaininteger

The chain related to the operation

transactionFullHashstring

The phased transaction ID

firstIndexinteger

A zero-based index to the first vote to retrieve

lastIndexinteger

A zero-based index to the last vote to retrieve

requireBlockstring

The block ID of a block that must be present in the blockchain during execution

requireLastBlockstring

The block ID of a block that must be last in the blockchain during execution

idintegerrequired

Response

200OK

Phasing poll votes retrieved successfully

400Bad Request

Bad Request

401Unauthorized

Unauthorized — Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Get all cast phasing poll votes in a phasing poll

curl -X POST 'https://ardr.nownodes.io/nxt' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "getPhasingPollVotes",
    "params": {
      "requestType": "getPhasingPollVotes",
      "chain": 0,
      "transactionFullHash": "string",
      "firstIndex": 0,
      "lastIndex": 0,
      "requireBlock": "string",
      "requireLastBlock": "string"
    },
    "id": 1
  }'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "getPhasingPollVotes",
      "params": {
        "requestType": "getPhasingPollVotes",
        "chain": 0,
        "transactionFullHash": "string",
        "firstIndex": 0,
        "lastIndex": 0,
        "requireBlock": "string",
        "requireLastBlock": "string"
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "getPhasingPollVotes",
  "params": {
    "requestType": "getPhasingPollVotes",
    "chain": 0,
    "transactionFullHash": "string",
    "firstIndex": 0,
    "lastIndex": 0,
    "requireBlock": "string",
    "requireLastBlock": "string"
  },
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "getPhasingPollVotes",
  "params": {
    "requestType": "getPhasingPollVotes",
    "chain": 0,
    "transactionFullHash": "string",
    "firstIndex": 0,
    "lastIndex": 0,
    "requireBlock": "string",
    "requireLastBlock": "string"
  },
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "votes": [
      {
        "voter": "string",
        "voterRS": "string",
        "transaction": "string"
      }
    ],
    "requestProcessingTime": 0
  }
}

getVoterPhasedTransactions

Get pending phased transactions which include a whitelist

POST

https://ardr.nownodes.io/nxt

Body

application/json

jsonrpcstringrequired

methodstringrequired

paramsobjectrequired

Show child attributes

requestTypestring

chaininteger

The chain related to the operation

accountstring

A whitelisted account ID included in the phased transactions

firstIndexinteger

A zero-based index to the first phased transaction to retrieve

lastIndexinteger

A zero-based index to the last phased transaction to retrieve

requireBlockstring

The block ID of a block that must be present in the blockchain during execution

requireLastBlockstring

The block ID of a block that must be last in the blockchain during execution

idintegerrequired

Response

200OK

Voter phased transactions retrieved successfully

400Bad Request

Bad Request

401Unauthorized

Unauthorized — Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Get pending phased transactions which include a whitelist

curl -X POST 'https://ardr.nownodes.io/nxt' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "getVoterPhasedTransactions",
    "params": {
      "requestType": "getVoterPhasedTransactions",
      "chain": 0,
      "account": "string",
      "firstIndex": 0,
      "lastIndex": 0,
      "requireBlock": "string",
      "requireLastBlock": "string"
    },
    "id": 1
  }'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "getVoterPhasedTransactions",
      "params": {
        "requestType": "getVoterPhasedTransactions",
        "chain": 0,
        "account": "string",
        "firstIndex": 0,
        "lastIndex": 0,
        "requireBlock": "string",
        "requireLastBlock": "string"
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "getVoterPhasedTransactions",
  "params": {
    "requestType": "getVoterPhasedTransactions",
    "chain": 0,
    "account": "string",
    "firstIndex": 0,
    "lastIndex": 0,
    "requireBlock": "string",
    "requireLastBlock": "string"
  },
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "getVoterPhasedTransactions",
  "params": {
    "requestType": "getVoterPhasedTransactions",
    "chain": 0,
    "account": "string",
    "firstIndex": 0,
    "lastIndex": 0,
    "requireBlock": "string",
    "requireLastBlock": "string"
  },
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "transactions": [
      {
        "signature": "string",
        "transactionIndex": 0,
        "type": 0,
        "fxtTransaction": "string",
        "phased": true,
        "ecBlockId": "string",
        "signatureHash": "string",
        "attachment": {},
        "senderRS": "string",
        "subtype": 0,
        "amountNQT": "string",
        "recipientRS": "string",
        "block": "string",
        "blockTimestamp": 0,
        "deadline": 0,
        "timestamp": 0,
        "height": 0,
        "senderPublicKey": "string",
        "chain": 0,
        "feeNQT": "string",
        "confirmations": 0,
        "fullHash": "string",
        "version": 0,
        "sender": "string",
        "recipient": "string",
        "ecBlockHeight": 0,
        "transaction": "string"
      }
    ],
    "requestProcessingTime": 0
  }
}

parsePhasingParams

Parse phasing parameters

POST

https://ardr.nownodes.io/nxt

Body

application/json

jsonrpcstringrequired

methodstringrequired

paramsobjectrequired

Show child attributes

requestTypestring

phasingVotingModelinteger

An integer code for the method of approval

phasingQuorumstring

The number of votes needed for transaction approval

phasingMinBalancestring

The minimum balance required for voting

phasingMinBalanceModelinteger

The minimum balance model

phasingHoldingstring

The asset or currency ID

phasingWhitelistedArray<string>

Account ID of an account allowed to vote

chaininteger

The chain related to the operation

phasingLinkedTransactionstring

Full hash of the linked transaction in the format chainId:fullHash

phasingHashedSecretstring

The hash of a secret phrase required for approval

phasingHashedSecretAlgorithminteger

The hash function used

phasingExpressionstring

A boolean expression that sets the phasing

phasingSenderPropertySetterstring

The by-property that sets the phasing condition

phasingSenderPropertyNamestring

The by-property property name that sets the phasing condition

phasingSenderPropertyValuestring

The by-property phasing value that sets the condition

idintegerrequired

Response

200OK

Phasing parameters parsed successfully

400Bad Request

Bad Request

401Unauthorized

Unauthorized — Missing or invalid API key

500Internal Server Error

Internal Server Error

Authorization

ApiKeyAuthapiKey in header

Parse phasing parameters

curl -X POST 'https://ardr.nownodes.io/nxt' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "parsePhasingParams",
    "params": {
      "requestType": "parsePhasingParams",
      "phasingVotingModel": 0,
      "phasingQuorum": "string",
      "phasingMinBalance": "string",
      "phasingMinBalanceModel": 0,
      "phasingHolding": "string",
      "phasingWhitelisted": [
        "string"
      ],
      "chain": 0,
      "phasingLinkedTransaction": "string",
      "phasingHashedSecret": "string",
      "phasingHashedSecretAlgorithm": 0,
      "phasingExpression": "string",
      "phasingSenderPropertySetter": "string",
      "phasingSenderPropertyName": "string",
      "phasingSenderPropertyValue": "string"
    },
    "id": 1
  }'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "method": "parsePhasingParams",
      "params": {
        "requestType": "parsePhasingParams",
        "phasingVotingModel": 0,
        "phasingQuorum": "string",
        "phasingMinBalance": "string",
        "phasingMinBalanceModel": 0,
        "phasingHolding": "string",
        "phasingWhitelisted": [
          "string"
        ],
        "chain": 0,
        "phasingLinkedTransaction": "string",
        "phasingHashedSecret": "string",
        "phasingHashedSecretAlgorithm": 0,
        "phasingExpression": "string",
        "phasingSenderPropertySetter": "string",
        "phasingSenderPropertyName": "string",
        "phasingSenderPropertyValue": "string"
      },
      "id": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "method": "parsePhasingParams",
  "params": {
    "requestType": "parsePhasingParams",
    "phasingVotingModel": 0,
    "phasingQuorum": "string",
    "phasingMinBalance": "string",
    "phasingMinBalanceModel": 0,
    "phasingHolding": "string",
    "phasingWhitelisted": [
      "string"
    ],
    "chain": 0,
    "phasingLinkedTransaction": "string",
    "phasingHashedSecret": "string",
    "phasingHashedSecretAlgorithm": 0,
    "phasingExpression": "string",
    "phasingSenderPropertySetter": "string",
    "phasingSenderPropertyName": "string",
    "phasingSenderPropertyValue": "string"
  },
  "id": 1
}

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

Request Body

{
  "jsonrpc": "2.0",
  "method": "parsePhasingParams",
  "params": {
    "requestType": "parsePhasingParams",
    "phasingVotingModel": 0,
    "phasingQuorum": "string",
    "phasingMinBalance": "string",
    "phasingMinBalanceModel": 0,
    "phasingHolding": "string",
    "phasingWhitelisted": [
      "string"
    ],
    "chain": 0,
    "phasingLinkedTransaction": "string",
    "phasingHashedSecret": "string",
    "phasingHashedSecretAlgorithm": 0,
    "phasingExpression": "string",
    "phasingSenderPropertySetter": "string",
    "phasingSenderPropertyName": "string",
    "phasingSenderPropertyValue": "string"
  },
  "id": 1
}

200

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "phasingHolding": "string",
    "phasingQuorum": "string",
    "phasingMinBalance": "string",
    "phasingMinBalanceModel": 0,
    "phasingVotingModel": 0,
    "requestProcessingTime": 0
  }
}

Server info

eventRegister

Register event listener

POST

https://ardr.nownodes.io/nxt

Body

application/json

object

Parameters

requestTypestringrequiredquery

Response

200OK

Event registration status

400Bad Request

Bad Request

500Internal Server Error

Internal Server Error

curl -X POST 'https://ardr.nownodes.io/nxt' \
  -H 'Content-Type: application/json' \
  -d '{}'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({}),
});

const data = await response.json();

import requests

payload = {}

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

Request Body

{}

200

{
  "registered": true,
  "requestProcessingTime": 13,
  "token": "1"
}

eventWait

Wait for registered events

POST

https://ardr.nownodes.io/nxt

Body

application/json

object

Parameters

requestTypestringrequiredquery

tokenstringrequiredquery

Response

200OK

Events response

400Bad Request

Bad Request

500Internal Server Error

Internal Server Error

Wait for registered events

curl -X POST 'https://ardr.nownodes.io/nxt' \
  -H 'Content-Type: application/json' \
  -d '{}'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({}),
});

const data = await response.json();

import requests

payload = {}

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

Request Body

{}

200

{
  "errorDescription": "No events registered",
  "errorCode": 8,
  "requestProcessingTime": 0
}

getBundlingOptions

Get bundling options

GET

https://ardr.nownodes.io/nxt

Parameters

requestTypestringrequiredquery

Response

200OK

Available bundling options and filters

400Bad Request

Bad Request

500Internal Server Error

Internal Server Error

Get bundling options

curl -X GET 'https://ardr.nownodes.io/nxt'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ardr.nownodes.io/nxt')
data = response.json()

200

{
  "availableFilters": [
    {
      "name": "PersonalBundler",
      "description": "Only bundle the transactions of the bundler account"
    }
  ],
  "availableFeeCalculators": [
    "MIN_FEE",
    "PROPORTIONAL_FEE"
  ]
}

getConstants

Get system constants

GET

https://ardr.nownodes.io/nxt

Parameters

requestTypestringrequiredquery

Response

200OK

System constants and configuration

400Bad Request

Bad Request

500Internal Server Error

Internal Server Error

Get system constants

curl -X GET 'https://ardr.nownodes.io/nxt'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ardr.nownodes.io/nxt')
data = response.json()

200

{
  "maxNumberOfFxtTransactions": 10,
  "lastKnownBlock": {
    "id": "12430465704212719921",
    "height": 2351000
  },
  "transactionSubTypes": {}
}

getPlugins

Get installed plugins

GET

https://ardr.nownodes.io/nxt

Parameters

requestTypestringrequiredquery

Response

200OK

List of installed plugins

400Bad Request

Bad Request

500Internal Server Error

Internal Server Error

Get installed plugins

curl -X GET 'https://ardr.nownodes.io/nxt'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ardr.nownodes.io/nxt')
data = response.json()

200

{
  "plugins": [
    "hello_world"
  ],
  "requestProcessingTime": 13
}

getState

Get node state

GET

https://ardr.nownodes.io/nxt

Parameters

requestTypestringrequiredquery

Response

200OK

Node and network state information

400Bad Request

Bad Request

500Internal Server Error

Internal Server Error

Get node state

curl -X GET 'https://ardr.nownodes.io/nxt'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ardr.nownodes.io/nxt')
data = response.json()

200

{
  "numberOfPeers": 2000,
  "correctInvalidFees": false,
  "numberOfUnlockedAccounts": 0,
  "ledgerTrimKeep": 30000,
  "maxAPIRecords": 100,
  "blockchainState": "UP_TO_DATE",
  "includeExpiredPrunable": true,
  "numberOfConnectedPeers": 8,
  "maxMemory": 16844324864,
  "maxRollback": 800,
  "isScanning": false,
  "isDownloading": false,
  "cumulativeDifficulty": "239787687123477970",
  "freeMemory": 725381920,
  "peerPort": 27874,
  "apiProxy": false,
  "availableProcessors": 16,
  "needsAdminPassword": true,
  "currentMinRollbackHeight": 3343653,
  "numberOfBlocks": 3345064,
  "isTestnet": false,
  "isLightClient": false,
  "services": [
    "API",
    "CORS"
  ],
  "requestProcessingTime": 2,
  "version": "2.4.2",
  "lastBlock": "18224502269305159846",
  "totalMemory": 1006632960,
  "application": "Ardor",
  "lastBlockchainFeederHeight": 3344845,
  "maxPrunableLifetime": 7776000,
  "isOffline": false,
  "time": 197531893,
  "customLoginWarning": "string",
  "lastBlockchainFeeder": "ardor03.jelurida.com"
}

getTime

Get current time

GET

https://ardr.nownodes.io/nxt

Parameters

requestTypestringrequiredquery

Response

200OK

Current time information

400Bad Request

Bad Request

500Internal Server Error

Internal Server Error

Get current time

curl -X GET 'https://ardr.nownodes.io/nxt'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ardr.nownodes.io/nxt')
data = response.json()

200

{
  "unixtime": 1712296763,
  "time": 197531964,
  "requestProcessingTime": 6
}

Shuffling

getAccountShufflings

Get account shufflings

GET

https://ardr.nownodes.io/nxt

Parameters

requestTypestringrequiredquery

chainintegerrequiredquery

accountstringrequiredquery

Response

200OK

Account shufflings information

400Bad Request

Bad Request

500Internal Server Error

Internal Server Error

Get account shufflings

curl -X GET 'https://ardr.nownodes.io/nxt'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ardr.nownodes.io/nxt')
data = response.json()

200

{
  "requestProcessingTime": 5,
  "shufflings": [
    {}
  ]
}

getAllShufflings

Get all shufflings

GET

https://ardr.nownodes.io/nxt

Parameters

requestTypestringrequiredquery

chainintegerrequiredquery

Response

200OK

All shufflings information

400Bad Request

Bad Request

500Internal Server Error

Internal Server Error

Get all shufflings

curl -X GET 'https://ardr.nownodes.io/nxt'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ardr.nownodes.io/nxt')
data = response.json()

200

{
  "requestProcessingTime": 5,
  "shufflings": [
    {}
  ]
}

getAssignedShufflings

Get assigned shufflings

GET

https://ardr.nownodes.io/nxt

Parameters

requestTypestringrequiredquery

chainintegerrequiredquery

accountstringrequiredquery

Response

200OK

Assigned shufflings information

400Bad Request

Bad Request

500Internal Server Error

Internal Server Error

Get assigned shufflings

curl -X GET 'https://ardr.nownodes.io/nxt'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ardr.nownodes.io/nxt')
data = response.json()

200

{
  "requestProcessingTime": 1,
  "shufflings": [
    {}
  ]
}

getHoldingShufflings

Get holding shufflings

GET

https://ardr.nownodes.io/nxt

Parameters

requestTypestringrequiredquery

chainintegerrequiredquery

holdingstringrequiredquery

includeFinishedbooleanquery

Response

200OK

Holding shufflings information

400Bad Request

Bad Request

500Internal Server Error

Internal Server Error

Get holding shufflings

curl -X GET 'https://ardr.nownodes.io/nxt'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ardr.nownodes.io/nxt')
data = response.json()

200

{
  "requestProcessingTime": 0,
  "shufflings": [
    {}
  ]
}

getShufflers

Get active shufflers

GET

https://ardr.nownodes.io/nxt

Parameters

requestTypestringrequiredquery

adminPasswordstringrequiredquery

Response

200OK

Active shufflers information

400Bad Request

Bad Request

500Internal Server Error

Internal Server Error

Get active shufflers

curl -X GET 'https://ardr.nownodes.io/nxt'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ardr.nownodes.io/nxt')
data = response.json()

200

{
  "errorDescription": "Incorrect \"adminPassword\" (the specified password does not match nxt.adminPassword)",
  "errorCode": 4
}

getShuffling

Get shuffling info

GET

https://ardr.nownodes.io/nxt

Parameters

requestTypestringrequiredquery

chainintegerrequiredquery

shufflingstringrequiredquery

Response

200OK

Shuffling information

400Bad Request

Bad Request

500Internal Server Error

Internal Server Error

Get shuffling info

curl -X GET 'https://ardr.nownodes.io/nxt'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ardr.nownodes.io/nxt')
data = response.json()

200

{
  "errorDescription": "\"shufflingFullHash\" not specified",
  "errorCode": 3
}

getShufflingParticipants

Get shuffling participants

GET

https://ardr.nownodes.io/nxt

Parameters

requestTypestringrequiredquery

chainintegerrequiredquery

shufflingstringrequiredquery

Response

200OK

Shuffling participants information

400Bad Request

Bad Request

500Internal Server Error

Internal Server Error

Get shuffling participants

curl -X GET 'https://ardr.nownodes.io/nxt'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ardr.nownodes.io/nxt')
data = response.json()

200

{
  "errorDescription": "\"shufflingFullHash\" not specified",
  "errorCode": 3
}

shufflingCreate

Create shuffling

POST

https://ardr.nownodes.io/nxt

Body

application/x-www-form-urlencoded

secretPhrasestring

chaininteger

participantCountinteger

registrationPeriodinteger

feeNQTstring

deadlineinteger

Parameters

requestTypestringrequiredquery

Response

200OK

Shuffling creation result

400Bad Request

Bad Request

500Internal Server Error

Internal Server Error

Create shuffling

curl -X POST 'https://ardr.nownodes.io/nxt' \
  -H 'Content-Type: application/x-www-form-urlencoded' \
  -d '{
    "secretPhrase": "IWontTellYou",
    "chain": 2,
    "participantCount": 7,
    "registrationPeriod": 9757,
    "feeNQT": "100000000",
    "deadline": 1440
  }'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/x-www-form-urlencoded',
  },
  body: JSON.stringify({
      "secretPhrase": "IWontTellYou",
      "chain": 2,
      "participantCount": 7,
      "registrationPeriod": 9757,
      "feeNQT": "100000000",
      "deadline": 1440
    }),
});

const data = await response.json();

import requests

payload = {
  "secretPhrase": "IWontTellYou",
  "chain": 2,
  "participantCount": 7,
  "registrationPeriod": 9757,
  "feeNQT": "100000000",
  "deadline": 1440
}

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

Request Body

{
  "secretPhrase": "IWontTellYou",
  "chain": 2,
  "participantCount": 7,
  "registrationPeriod": 9757,
  "feeNQT": "100000000",
  "deadline": 1440
}

200

{
  "errorDescription": "Unknown account",
  "errorCode": 5
}

shufflingProcess

Process shuffling

POST

https://ardr.nownodes.io/nxt

Body

application/x-www-form-urlencoded

secretPhrasestring

chaininteger

feeNQTstring

deadlineinteger

Parameters

requestTypestringrequiredquery

Response

200OK

Shuffling processing result

400Bad Request

Bad Request

500Internal Server Error

Internal Server Error

Process shuffling

curl -X POST 'https://ardr.nownodes.io/nxt' \
  -H 'Content-Type: application/x-www-form-urlencoded' \
  -d '{
    "secretPhrase": "IWontTellYou",
    "chain": 2,
    "feeNQT": "100000000",
    "deadline": 1440
  }'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/x-www-form-urlencoded',
  },
  body: JSON.stringify({
      "secretPhrase": "IWontTellYou",
      "chain": 2,
      "feeNQT": "100000000",
      "deadline": 1440
    }),
});

const data = await response.json();

import requests

payload = {
  "secretPhrase": "IWontTellYou",
  "chain": 2,
  "feeNQT": "100000000",
  "deadline": 1440
}

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

Request Body

{
  "secretPhrase": "IWontTellYou",
  "chain": 2,
  "feeNQT": "100000000",
  "deadline": 1440
}

200

{
  "errorDescription": "\"shufflingFullHash\" not specified",
  "errorCode": 3
}

shufflingRegister

Register to shuffling

POST

https://ardr.nownodes.io/nxt

Body

application/x-www-form-urlencoded

secretPhrasestring

shufflingFullHashstring

chaininteger

feeNQTstring

deadlineinteger

Parameters

requestTypestringrequiredquery

Response

200OK

Shuffling registration result

400Bad Request

Bad Request

500Internal Server Error

Internal Server Error

curl -X POST 'https://ardr.nownodes.io/nxt' \
  -H 'Content-Type: application/x-www-form-urlencoded' \
  -d '{
    "secretPhrase": "IWontTellYou",
    "shufflingFullHash": "2d10f4e18f808aa8d0de06d5cddcd77828eb6e7548f62e48de83f58fdf0629d5",
    "chain": 2,
    "feeNQT": "100000000",
    "deadline": 1440
  }'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/x-www-form-urlencoded',
  },
  body: JSON.stringify({
      "secretPhrase": "IWontTellYou",
      "shufflingFullHash": "2d10f4e18f808aa8d0de06d5cddcd77828eb6e7548f62e48de83f58fdf0629d5",
      "chain": 2,
      "feeNQT": "100000000",
      "deadline": 1440
    }),
});

const data = await response.json();

import requests

payload = {
  "secretPhrase": "IWontTellYou",
  "shufflingFullHash": "2d10f4e18f808aa8d0de06d5cddcd77828eb6e7548f62e48de83f58fdf0629d5",
  "chain": 2,
  "feeNQT": "100000000",
  "deadline": 1440
}

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

Request Body

{
  "secretPhrase": "IWontTellYou",
  "shufflingFullHash": "2d10f4e18f808aa8d0de06d5cddcd77828eb6e7548f62e48de83f58fdf0629d5",
  "chain": 2,
  "feeNQT": "100000000",
  "deadline": 1440
}

200

{
  "errorDescription": "Unknown account",
  "errorCode": 5
}

shufflingVerify

Verify shuffling

POST

https://ardr.nownodes.io/nxt

Body

application/x-www-form-urlencoded

secretPhrasestring

shufflingFullHashstring

shufflingStateHashstring

chaininteger

feeNQTstring

deadlineinteger

Parameters

requestTypestringrequiredquery

Response

200OK

Shuffling verification result

400Bad Request

Bad Request

500Internal Server Error

Internal Server Error

Verify shuffling

curl -X POST 'https://ardr.nownodes.io/nxt' \
  -H 'Content-Type: application/x-www-form-urlencoded' \
  -d '{
    "secretPhrase": "IWontTellYou",
    "shufflingFullHash": "2d10f4e18f808aa8d0de06d5cddcd77828eb6e7548f62e48de83f58fdf0629d5",
    "shufflingStateHash": "90832470918374087102938470198234",
    "chain": 2,
    "feeNQT": "100000000",
    "deadline": 1440
  }'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/x-www-form-urlencoded',
  },
  body: JSON.stringify({
      "secretPhrase": "IWontTellYou",
      "shufflingFullHash": "2d10f4e18f808aa8d0de06d5cddcd77828eb6e7548f62e48de83f58fdf0629d5",
      "shufflingStateHash": "90832470918374087102938470198234",
      "chain": 2,
      "feeNQT": "100000000",
      "deadline": 1440
    }),
});

const data = await response.json();

import requests

payload = {
  "secretPhrase": "IWontTellYou",
  "shufflingFullHash": "2d10f4e18f808aa8d0de06d5cddcd77828eb6e7548f62e48de83f58fdf0629d5",
  "shufflingStateHash": "90832470918374087102938470198234",
  "chain": 2,
  "feeNQT": "100000000",
  "deadline": 1440
}

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

Request Body

{
  "secretPhrase": "IWontTellYou",
  "shufflingFullHash": "2d10f4e18f808aa8d0de06d5cddcd77828eb6e7548f62e48de83f58fdf0629d5",
  "shufflingStateHash": "90832470918374087102938470198234",
  "chain": 2,
  "feeNQT": "100000000",
  "deadline": 1440
}

200

{
  "errorDescription": "Unknown shuffling",
  "errorCode": 5
}

startShuffler

Start automated shuffler

POST

https://ardr.nownodes.io/nxt

Body

application/x-www-form-urlencoded

secretPhrasestring

shufflingFullHashstring

recipientSecretPhrasestring

chaininteger

feeRateNQTPerFXTstring

Parameters

requestTypestringrequiredquery

Response

200OK

Shuffler start result

400Bad Request

Bad Request

500Internal Server Error

Internal Server Error

Start automated shuffler

curl -X POST 'https://ardr.nownodes.io/nxt' \
  -H 'Content-Type: application/x-www-form-urlencoded' \
  -d '{
    "secretPhrase": "IWontTellYou",
    "shufflingFullHash": "2d10f4e18f808aa8d0de06d5cddcd77828eb6e7548f62e48de83f58fdf0629d5",
    "recipientSecretPhrase": "IWontTellYou",
    "chain": 2,
    "feeRateNQTPerFXT": "100000000"
  }'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/x-www-form-urlencoded',
  },
  body: JSON.stringify({
      "secretPhrase": "IWontTellYou",
      "shufflingFullHash": "2d10f4e18f808aa8d0de06d5cddcd77828eb6e7548f62e48de83f58fdf0629d5",
      "recipientSecretPhrase": "IWontTellYou",
      "chain": 2,
      "feeRateNQTPerFXT": "100000000"
    }),
});

const data = await response.json();

import requests

payload = {
  "secretPhrase": "IWontTellYou",
  "shufflingFullHash": "2d10f4e18f808aa8d0de06d5cddcd77828eb6e7548f62e48de83f58fdf0629d5",
  "recipientSecretPhrase": "IWontTellYou",
  "chain": 2,
  "feeRateNQTPerFXT": "100000000"
}

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

Request Body

{
  "secretPhrase": "IWontTellYou",
  "shufflingFullHash": "2d10f4e18f808aa8d0de06d5cddcd77828eb6e7548f62e48de83f58fdf0629d5",
  "recipientSecretPhrase": "IWontTellYou",
  "chain": 2,
  "feeRateNQTPerFXT": "100000000"
}

200

{
  "errorDescription": "Incorrect \"recipientPublicKey\" Existing account cannot be used as shuffling recipient",
  "errorCode": 4
}

stopShuffler

Stop automated shuffler

POST

https://ardr.nownodes.io/nxt

Body

application/x-www-form-urlencoded

secretPhrasestring

shufflingFullHashstring

Parameters

requestTypestringrequiredquery

Response

200OK

Shuffler stop result

400Bad Request

Bad Request

500Internal Server Error

Internal Server Error

Stop automated shuffler

curl -X POST 'https://ardr.nownodes.io/nxt' \
  -H 'Content-Type: application/x-www-form-urlencoded' \
  -d '{
    "secretPhrase": "IWontTellYou",
    "shufflingFullHash": "2d10f4e18f808aa8d0de06d5cddcd77828eb6e7548f62e48de83f58fdf0629d5"
  }'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/x-www-form-urlencoded',
  },
  body: JSON.stringify({
      "secretPhrase": "IWontTellYou",
      "shufflingFullHash": "2d10f4e18f808aa8d0de06d5cddcd77828eb6e7548f62e48de83f58fdf0629d5"
    }),
});

const data = await response.json();

import requests

payload = {
  "secretPhrase": "IWontTellYou",
  "shufflingFullHash": "2d10f4e18f808aa8d0de06d5cddcd77828eb6e7548f62e48de83f58fdf0629d5"
}

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

Request Body

{
  "secretPhrase": "IWontTellYou",
  "shufflingFullHash": "2d10f4e18f808aa8d0de06d5cddcd77828eb6e7548f62e48de83f58fdf0629d5"
}

200

{
  "requestProcessingTime": 1,
  "stoppedShuffler": false
}

Tagged Data

detectMimeType

Detect MIME type

POST

https://ardr.nownodes.io/nxt

Body

application/x-www-form-urlencoded

datastring

isTextboolean

Parameters

requestTypestringrequiredquery

Response

200OK

MIME type detection result

400Bad Request

Bad Request

500Internal Server Error

Internal Server Error

Detect MIME type

curl -X POST 'https://ardr.nownodes.io/nxt' \
  -H 'Content-Type: application/x-www-form-urlencoded' \
  -d '{
    "data": "/9j/4AAQSkZJRgABAgAAAQABAAD/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRo...",
    "isText": false
  }'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/x-www-form-urlencoded',
  },
  body: JSON.stringify({
      "data": "/9j/4AAQSkZJRgABAgAAAQABAAD/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRo...",
      "isText": false
    }),
});

const data = await response.json();

import requests

payload = {
  "data": "/9j/4AAQSkZJRgABAgAAAQABAAD/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRo...",
  "isText": False
}

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

Request Body

{
  "data": "/9j/4AAQSkZJRgABAgAAAQABAAD/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRo...",
  "isText": false
}

200

{
  "errorDescription": "Invalid hex number: /9j/4AAQSkZJRgABAgAAAQABAAD/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRo...",
  "errorCode": 4,
  "error": "java.lang.NumberFormatException: Invalid hex number: /9j/4AAQSkZJRgABAgAAAQABAAD/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRo..."
}

downloadTaggedData

Download tagged data

GET

https://ardr.nownodes.io/nxt

Parameters

requestTypestringrequiredquery

chainintegerrequiredquery

transactionFullHashstringrequiredquery

Response

200OK

Tagged data download result

400Bad Request

Bad Request

500Internal Server Error

Internal Server Error

Download tagged data

curl -X GET 'https://ardr.nownodes.io/nxt'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ardr.nownodes.io/nxt')
data = response.json()

200

{
  "errorDescription": "Incorrect \"transaction\" Tagged data not found",
  "errorCode": 4
}

getAccountTaggedData

Get account tagged data

GET

https://ardr.nownodes.io/nxt

Parameters

requestTypestringrequiredquery

chainintegerrequiredquery

accountstringrequiredquery

lastIndexintegerquery

Response

200OK

Account tagged data

400Bad Request

Bad Request

500Internal Server Error

Internal Server Error

Get account tagged data

curl -X GET 'https://ardr.nownodes.io/nxt'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ardr.nownodes.io/nxt')
data = response.json()

200

{
  "data": [
    {}
  ],
  "requestProcessingTime": 0
}

getAllTaggedData

Get all tagged data

GET

https://ardr.nownodes.io/nxt

Parameters

requestTypestringrequiredquery

chainintegerrequiredquery

lastIndexintegerquery

Response

200OK

All tagged data

400Bad Request

Bad Request

500Internal Server Error

Internal Server Error

Get all tagged data

curl -X GET 'https://ardr.nownodes.io/nxt'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ardr.nownodes.io/nxt')
data = response.json()

200

{
  "data": [
    {
      "channel": "contracts",
      "description": "{}",
      "transactionFullHash": "be208706bfa3c074ddcda31506fd6884af6da48b3d0453dba9eb0bc923e77fdf",
      "type": "application/java-archive",
      "parsedTags": [
        "string"
      ],
      "transactionTimestamp": 196182899,
      "tags": "",
      "filename": "SellMachineGiftzAsset.jar",
      "accountRS": "ARDOR-ARQZ-MDV2-EX9E-4NEGZ",
      "name": "com.tarasca.ardor.contracts.SellMachineGiftzAsset",
      "blockTimestamp": 196182911,
      "account": "3438943183747440351",
      "isText": false
    }
  ],
  "requestProcessingTime": 26
}

getChannelTaggedData

Get channel tagged data

GET

https://ardr.nownodes.io/nxt

Parameters

requestTypestringrequiredquery

chainintegerrequiredquery

channelstringrequiredquery

lastIndexintegerquery

Response

200OK

Channel tagged data

400Bad Request

Bad Request

500Internal Server Error

Internal Server Error

Get channel tagged data

curl -X GET 'https://ardr.nownodes.io/nxt'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ardr.nownodes.io/nxt')
data = response.json()

200

{
  "data": [
    {}
  ],
  "requestProcessingTime": 0
}

getDataTagCount

Get data tag count

GET

https://ardr.nownodes.io/nxt

Parameters

requestTypestringrequiredquery

chainintegerrequiredquery

Response

200OK

Data tag count

400Bad Request

Bad Request

500Internal Server Error

Internal Server Error

Get data tag count

curl -X GET 'https://ardr.nownodes.io/nxt'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ardr.nownodes.io/nxt')
data = response.json()

200

{
  "numberOfDataTags": 5,
  "requestProcessingTime": 0
}

getDataTags

Get data tags

GET

https://ardr.nownodes.io/nxt

Parameters

requestTypestringrequiredquery

chainintegerrequiredquery

Response

200OK

Data tags

400Bad Request

Bad Request

500Internal Server Error

Internal Server Error

Get data tags

curl -X GET 'https://ardr.nownodes.io/nxt'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ardr.nownodes.io/nxt')
data = response.json()

200

{
  "requestProcessingTime": 0,
  "tags": [
    {
      "count": 33,
      "tag": "art"
    }
  ]
}

getDataTagsLike

Search data tags by prefix

GET

https://ardr.nownodes.io/nxt

Parameters

requestTypestringrequiredquery

chainintegerrequiredquery

tagPrefixstringrequiredquery

Response

200OK

Matching data tags

400Bad Request

Bad Request

500Internal Server Error

Internal Server Error

Search data tags by prefix

curl -X GET 'https://ardr.nownodes.io/nxt'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ardr.nownodes.io/nxt')
data = response.json()

200

{
  "requestProcessingTime": 4,
  "tags": [
    {}
  ]
}

getTaggedData

Get tagged data by transaction hash

GET

https://ardr.nownodes.io/nxt

Parameters

requestTypestringrequiredquery

transactionFullHashstringrequiredquery

chainintegerrequiredquery

Response

200OK

Tagged data

400Bad Request

Bad Request

500Internal Server Error

Internal Server Error

Get tagged data by transaction hash

curl -X GET 'https://ardr.nownodes.io/nxt'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ardr.nownodes.io/nxt')
data = response.json()

200

{}

searchTaggedData

Search tagged data

GET

https://ardr.nownodes.io/nxt

Parameters

requestTypestringrequiredquery

chainintegerrequiredquery

querystringrequiredquery

lastIndexintegerquery

Response

200OK

Search results

400Bad Request

Bad Request

500Internal Server Error

Internal Server Error

Search tagged data

curl -X GET 'https://ardr.nownodes.io/nxt'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ardr.nownodes.io/nxt')
data = response.json()

200

{
  "data": [
    {}
  ],
  "requestProcessingTime": 17
}

uploadTaggedData

Upload tagged data

POST

https://ardr.nownodes.io/nxt

Body

application/x-www-form-urlencoded

chaininteger

namestring

descriptionstring

tagsstring

channelstring

datastring

secretPhrasestring

feeNQTstring

deadlineinteger

Parameters

requestTypestringrequiredquery

Response

200OK

Upload result

400Bad Request

Bad Request

500Internal Server Error

Internal Server Error

Upload tagged data

curl -X POST 'https://ardr.nownodes.io/nxt' \
  -H 'Content-Type: application/x-www-form-urlencoded' \
  -d '{
    "chain": 2,
    "name": "Stargate SG1 full series",
    "description": "Hash of the torrent.",
    "tags": "video, scifi, torrent",
    "channel": "torrent",
    "data": "d4f167249340d6d746f49441b8ccdb1bd3521feb",
    "secretPhrase": "xxx",
    "feeNQT": "100000000",
    "deadline": 60
  }'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/x-www-form-urlencoded',
  },
  body: JSON.stringify({
      "chain": 2,
      "name": "Stargate SG1 full series",
      "description": "Hash of the torrent.",
      "tags": "video, scifi, torrent",
      "channel": "torrent",
      "data": "d4f167249340d6d746f49441b8ccdb1bd3521feb",
      "secretPhrase": "xxx",
      "feeNQT": "100000000",
      "deadline": 60
    }),
});

const data = await response.json();

import requests

payload = {
  "chain": 2,
  "name": "Stargate SG1 full series",
  "description": "Hash of the torrent.",
  "tags": "video, scifi, torrent",
  "channel": "torrent",
  "data": "d4f167249340d6d746f49441b8ccdb1bd3521feb",
  "secretPhrase": "xxx",
  "feeNQT": "100000000",
  "deadline": 60
}

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

Request Body

{
  "chain": 2,
  "name": "Stargate SG1 full series",
  "description": "Hash of the torrent.",
  "tags": "video, scifi, torrent",
  "channel": "torrent",
  "data": "d4f167249340d6d746f49441b8ccdb1bd3521feb",
  "secretPhrase": "xxx",
  "feeNQT": "100000000",
  "deadline": 60
}

200

{
  "errorDescription": "Unknown account",
  "errorCode": 5
}

verifyTaggedData

Verify tagged data

GET

https://ardr.nownodes.io/nxt

Parameters

requestTypestringrequiredquery

chainintegerrequiredquery

transactionFullHashstringrequiredquery

datastringrequiredquery

namestringrequiredquery

descriptionstringrequiredquery

tagsstringrequiredquery

channelstringrequiredquery

Response

200OK

Verification result

400Bad Request

Bad Request

500Internal Server Error

Internal Server Error

Verify tagged data

curl -X GET 'https://ardr.nownodes.io/nxt'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ardr.nownodes.io/nxt')
data = response.json()

200

{
  "errorDescription": "Unknown transaction",
  "errorCode": 5
}

Tokens

decodeFileToken

Decode file token

POST

https://ardr.nownodes.io/nxt

Body

application/x-www-form-urlencoded

tokenstring

Parameters

requestTypestringrequiredquery

Response

200OK

File token decoding result

400Bad Request

Bad Request

500Internal Server Error

Internal Server Error

Decode file token

curl -X POST 'https://ardr.nownodes.io/nxt' \
  -H 'Content-Type: application/x-www-form-urlencoded' \
  -d '{
    "token": "omoihgb7dludrhljfabms8nqcse4lksmbhsnh80buoen0sj6fpfa4j3lljm0cu82quiktk1ipehcf0fgrk6g1vcjbso50eip66njsqq0s3ng4eghap75082dmenmmmuccesc0i0fdc0bd7g3l64h204fiqq8b7s1"
  }'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/x-www-form-urlencoded',
  },
  body: JSON.stringify({
      "token": "omoihgb7dludrhljfabms8nqcse4lksmbhsnh80buoen0sj6fpfa4j3lljm0cu82quiktk1ipehcf0fgrk6g1vcjbso50eip66njsqq0s3ng4eghap75082dmenmmmuccesc0i0fdc0bd7g3l64h204fiqq8b7s1"
    }),
});

const data = await response.json();

import requests

payload = {
  "token": "omoihgb7dludrhljfabms8nqcse4lksmbhsnh80buoen0sj6fpfa4j3lljm0cu82quiktk1ipehcf0fgrk6g1vcjbso50eip66njsqq0s3ng4eghap75082dmenmmmuccesc0i0fdc0bd7g3l64h204fiqq8b7s1"
}

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

Request Body

{
  "token": "omoihgb7dludrhljfabms8nqcse4lksmbhsnh80buoen0sj6fpfa4j3lljm0cu82quiktk1ipehcf0fgrk6g1vcjbso50eip66njsqq0s3ng4eghap75082dmenmmmuccesc0i0fdc0bd7g3l64h204fiqq8b7s1"
}

200

{
  "errorDescription": "Incorrect \"file\" cannot read file data",
  "errorCode": 4
}

decodeToken

Decode token

GET

https://ardr.nownodes.io/nxt

Parameters

requestTypestringrequiredquery

websitestringrequiredquery

tokenstringrequiredquery

Response

200OK

Token decoding result

400Bad Request

Bad Request

500Internal Server Error

Internal Server Error

Decode token

curl -X GET 'https://ardr.nownodes.io/nxt'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ardr.nownodes.io/nxt')
data = response.json()

200

{
  "valid": true,
  "accountRS": "ARDOR-QBXE-E8V8-7975-HP7N4",
  "requestProcessingTime": 3,
  "account": "17388597592554416044",
  "timestamp": 41836011
}

generateFileToken

Generate file token

POST

https://ardr.nownodes.io/nxt

Body

application/x-www-form-urlencoded

tokenstring

Parameters

requestTypestringrequiredquery

Response

200OK

File token generation result

400Bad Request

Bad Request

500Internal Server Error

Internal Server Error

Generate file token

curl -X POST 'https://ardr.nownodes.io/nxt' \
  -H 'Content-Type: application/x-www-form-urlencoded' \
  -d '{
    "token": "omoihgb7dludrhljfabms8nqcse4lksmbhsnh80buoen0sj6fpfa4j3lljm0cu82quiktk1ipehcf0fgrk6g1vcjbso50eip66njsqq0s3ng4eghap75082dmenmmmuccesc0i0fdc0bd7g3l64h204fiqq8b7s1"
  }'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/x-www-form-urlencoded',
  },
  body: JSON.stringify({
      "token": "omoihgb7dludrhljfabms8nqcse4lksmbhsnh80buoen0sj6fpfa4j3lljm0cu82quiktk1ipehcf0fgrk6g1vcjbso50eip66njsqq0s3ng4eghap75082dmenmmmuccesc0i0fdc0bd7g3l64h204fiqq8b7s1"
    }),
});

const data = await response.json();

import requests

payload = {
  "token": "omoihgb7dludrhljfabms8nqcse4lksmbhsnh80buoen0sj6fpfa4j3lljm0cu82quiktk1ipehcf0fgrk6g1vcjbso50eip66njsqq0s3ng4eghap75082dmenmmmuccesc0i0fdc0bd7g3l64h204fiqq8b7s1"
}

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

Request Body

{
  "token": "omoihgb7dludrhljfabms8nqcse4lksmbhsnh80buoen0sj6fpfa4j3lljm0cu82quiktk1ipehcf0fgrk6g1vcjbso50eip66njsqq0s3ng4eghap75082dmenmmmuccesc0i0fdc0bd7g3l64h204fiqq8b7s1"
}

200

{
  "errorDescription": "Incorrect \"file\" cannot read file data",
  "errorCode": 4
}

generateToken

Generate token

POST

https://ardr.nownodes.io/nxt

Body

application/x-www-form-urlencoded

secretPhrasestring

websitestring

Parameters

requestTypestringrequiredquery

Response

200OK

Token generation result

400Bad Request

Bad Request

500Internal Server Error

Internal Server Error

Generate token

curl -X POST 'https://ardr.nownodes.io/nxt' \
  -H 'Content-Type: application/x-www-form-urlencoded' \
  -d '{
    "secretPhrase": "xxx",
    "website": "xxx"
  }'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/x-www-form-urlencoded',
  },
  body: JSON.stringify({
      "secretPhrase": "xxx",
      "website": "xxx"
    }),
});

const data = await response.json();

import requests

payload = {
  "secretPhrase": "xxx",
  "website": "xxx"
}

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

Request Body

{
  "secretPhrase": "xxx",
  "website": "xxx"
}

200

{
  "valid": true,
  "accountRS": "ARDOR-LHBC-J6TQ-6N9X-5XCGQ",
  "requestProcessingTime": 3,
  "account": "4267544931404954922",
  "timestamp": 197552382,
  "token": "q9kfbdfqkhnmpq7l6utl36a3kmoradksi230bu367osndbklopkfsfop9bdhai8blu41q4ipl2cbjp7ing07fu8258vqcfsa12e20ta1idd0nh1v5r7943qg035mvn89oqf50v0pdggha4d2c2ur055d49gjlqjk"
}

Transactions

broadcastTransaction

Broadcast transaction

POST

https://ardr.nownodes.io/nxt

Body

application/x-www-form-urlencoded

transactionBytesstring

Parameters

requestTypestringrequiredquery

Response

200OK

Transaction broadcast result

400Bad Request

Bad Request

500Internal Server Error

Internal Server Error

Broadcast transaction

curl -X POST 'https://ardr.nownodes.io/nxt' \
  -H 'Content-Type: application/x-www-form-urlencoded' \
  -d '{
    "transactionBytes": "02000000000001e0217e022800df21142bd38c04bd5c5c342c6ca36802f9de89b75b2a0a8cbd32d29dca481e5c0069c38ab5c7abe500e40b540200000040420f000000000058cda06a138b59b46b19c5e5d06d65334ed338d0e48d9694ae5c119913d2a00c9b4871989dd367442d1dbd94d22336515135cc3bf35e7c952c244e9d1b6a5c9810851a0069fb1adac03af20c40000000017ac01a000001000000000000000000000000000000016059eed721ae4ad4000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
  }'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/x-www-form-urlencoded',
  },
  body: JSON.stringify({
      "transactionBytes": "02000000000001e0217e022800df21142bd38c04bd5c5c342c6ca36802f9de89b75b2a0a8cbd32d29dca481e5c0069c38ab5c7abe500e40b540200000040420f000000000058cda06a138b59b46b19c5e5d06d65334ed338d0e48d9694ae5c119913d2a00c9b4871989dd367442d1dbd94d22336515135cc3bf35e7c952c244e9d1b6a5c9810851a0069fb1adac03af20c40000000017ac01a000001000000000000000000000000000000016059eed721ae4ad4000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
    }),
});

const data = await response.json();

import requests

payload = {
  "transactionBytes": "02000000000001e0217e022800df21142bd38c04bd5c5c342c6ca36802f9de89b75b2a0a8cbd32d29dca481e5c0069c38ab5c7abe500e40b540200000040420f000000000058cda06a138b59b46b19c5e5d06d65334ed338d0e48d9694ae5c119913d2a00c9b4871989dd367442d1dbd94d22336515135cc3bf35e7c952c244e9d1b6a5c9810851a0069fb1adac03af20c40000000017ac01a000001000000000000000000000000000000016059eed721ae4ad4000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
}

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

Request Body

{
  "transactionBytes": "02000000000001e0217e022800df21142bd38c04bd5c5c342c6ca36802f9de89b75b2a0a8cbd32d29dca481e5c0069c38ab5c7abe500e40b540200000040420f000000000058cda06a138b59b46b19c5e5d06d65334ed338d0e48d9694ae5c119913d2a00c9b4871989dd367442d1dbd94d22336515135cc3bf35e7c952c244e9d1b6a5c9810851a0069fb1adac03af20c40000000017ac01a000001000000000000000000000000000000016059eed721ae4ad4000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
}

200

{
  "errorDescription": "Failed to broadcast transaction: Invalid finish height 1753210",
  "errorCode": 4,
  "requestProcessingTime": 2,
  "error": "nxt.NxtException$NotCurrentlyValidException: Invalid finish height 1753210"
}

calculateFee

Calculate transaction fee

GET

https://ardr.nownodes.io/nxt

Parameters

requestTypestringrequiredquery

transactionBytesstringrequiredquery

Response

200OK

Fee calculation result

400Bad Request

Bad Request

500Internal Server Error

Internal Server Error

Calculate transaction fee

curl -X GET 'https://ardr.nownodes.io/nxt'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ardr.nownodes.io/nxt')
data = response.json()

200

{
  "minimumFeeFQT": "202000000",
  "feeNQT": "5029800000",
  "requestProcessingTime": 5
}

calculateFullHash

Calculate transaction full hash

GET

https://ardr.nownodes.io/nxt

Parameters

requestTypestringrequiredquery

unsignedTransactionBytesstringrequiredquery

signatureHashstringrequiredquery

Response

200OK

Full hash calculation result

400Bad Request

Bad Request

500Internal Server Error

Internal Server Error

Calculate transaction full hash

curl -X GET 'https://ardr.nownodes.io/nxt'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ardr.nownodes.io/nxt')
data = response.json()

200

{
  "requestProcessingTime": 0,
  "fullHash": "8820b388d7c5be819e20dac430c44d7dae1474932c9289f4c9c54408a415fed0"
}

getBlockchainTransactions

Get blockchain transactions

GET

https://ardr.nownodes.io/nxt

Parameters

requestTypestringrequiredquery

chainintegerrequiredquery

accountstringrequiredquery

lastIndexintegerquery

Response

200OK

Blockchain transactions

400Bad Request

Bad Request

500Internal Server Error

Internal Server Error

Get blockchain transactions

curl -X GET 'https://ardr.nownodes.io/nxt'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ardr.nownodes.io/nxt')
data = response.json()

200

{
  "requestProcessingTime": 1,
  "transactions": [
    {}
  ]
}

getExecutedTransactions

Get executed transactions

GET

https://ardr.nownodes.io/nxt

Parameters

requestTypestringrequiredquery

chainintegerrequiredquery

senderstringrequiredquery

Response

200OK

Executed transactions

400Bad Request

Bad Request

500Internal Server Error

Internal Server Error

Get executed transactions

curl -X GET 'https://ardr.nownodes.io/nxt'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ardr.nownodes.io/nxt')
data = response.json()

200

{
  "requestProcessingTime": 2,
  "transactions": [
    {}
  ]
}

getExpectedTransactions

Get expected transactions

GET

https://ardr.nownodes.io/nxt

Parameters

requestTypestringrequiredquery

chainintegerrequiredquery

accountstringrequiredquery

Response

200OK

Expected transactions

400Bad Request

Bad Request

500Internal Server Error

Internal Server Error

Get expected transactions

curl -X GET 'https://ardr.nownodes.io/nxt'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ardr.nownodes.io/nxt')
data = response.json()

200

{
  "expectedTransactions": [
    {}
  ],
  "requestProcessingTime": 3
}

getFxtTransaction

Get FXT transactions

GET

https://ardr.nownodes.io/nxt

Parameters

requestTypestringrequiredquery

transactionstringrequiredquery

fullHashstringrequiredquery

Response

200OK

FXT transactions

400Bad Request

Bad Request

500Internal Server Error

Internal Server Error

Get FXT transactions

curl -X GET 'https://ardr.nownodes.io/nxt'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ardr.nownodes.io/nxt')
data = response.json()

200

{
  "errorDescription": "Unknown transaction",
  "errorCode": 5
}

getReferencingTransactions

Get referencing transactions

GET

https://ardr.nownodes.io/nxt

Parameters

requestTypestringrequiredquery

chainintegerrequiredquery

transactionFullHashstringrequiredquery

Response

200OK

Referencing transactions

400Bad Request

Bad Request

500Internal Server Error

Internal Server Error

Get referencing transactions

curl -X GET 'https://ardr.nownodes.io/nxt'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ardr.nownodes.io/nxt')
data = response.json()

200

{
  "requestProcessingTime": 1,
  "transactions": [
    {}
  ]
}

getTransaction

Get transaction

GET

https://ardr.nownodes.io/nxt

Parameters

requestTypestringrequiredquery

chainintegerrequiredquery

fullHashstringrequiredquery

Response

200OK

Transaction information

400Bad Request

Bad Request

500Internal Server Error

Internal Server Error

Get transaction

curl -X GET 'https://ardr.nownodes.io/nxt'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ardr.nownodes.io/nxt')
data = response.json()

200

{
  "errorDescription": "Unknown transaction",
  "errorCode": 5
}

getTransactionBytes

Get transaction bytes

GET

https://ardr.nownodes.io/nxt

Parameters

requestTypestringrequiredquery

chainintegerrequiredquery

transactionstringrequiredquery

Response

200OK

Transaction bytes

400Bad Request

Bad Request

500Internal Server Error

Internal Server Error

Get transaction bytes

curl -X GET 'https://ardr.nownodes.io/nxt'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ardr.nownodes.io/nxt')
data = response.json()

200

{
  "errorDescription": "\"fullHash\" not specified",
  "errorCode": 3
}

getUnconfirmedTransactionIds

Get unconfirmed transaction IDs

GET

https://ardr.nownodes.io/nxt

Parameters

requestTypestringrequiredquery

chainintegerrequiredquery

accountstringrequiredquery

Response

200OK

Unconfirmed transaction IDs

400Bad Request

Bad Request

500Internal Server Error

Internal Server Error

Get unconfirmed transaction IDs

curl -X GET 'https://ardr.nownodes.io/nxt'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ardr.nownodes.io/nxt')
data = response.json()

200

{
  "unconfirmedTransactionHashes": [
    "string"
  ],
  "requestProcessingTime": 1,
  "unconfirmedTransactionIds": [
    "string"
  ]
}

getUnconfirmedTransactions

Get unconfirmed transactions

GET

https://ardr.nownodes.io/nxt

Parameters

requestTypestringrequiredquery

chainintegerrequiredquery

accountstringrequiredquery

Response

200OK

Unconfirmed transactions

400Bad Request

Bad Request

500Internal Server Error

Internal Server Error

Get unconfirmed transactions

curl -X GET 'https://ardr.nownodes.io/nxt'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ardr.nownodes.io/nxt')
data = response.json()

200

{
  "unconfirmedTransactions": [
    {}
  ],
  "requestProcessingTime": 0
}

parseTransaction

Parse transaction

GET

https://ardr.nownodes.io/nxt

Parameters

requestTypestringrequiredquery

transactionBytesstringrequiredquery

Response

200OK

Parsed transaction

400Bad Request

Bad Request

500Internal Server Error

Internal Server Error

Parse transaction

curl -X GET 'https://ardr.nownodes.io/nxt'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ardr.nownodes.io/nxt')
data = response.json()

200

{
  "errorDescription": "Invalid transaction: Invalid finish height 1753210",
  "signature": "58cda06a138b59b46b19c5e5d06d65334ed338d0e48d9694ae5c119913d2a00c9b4871989dd367442d1dbd94d22336515135cc3bf35e7c952c244e9d1b6a5c98",
  "errorCode": 4,
  "type": 0,
  "error": "nxt.NxtException$NotCurrentlyValidException: Invalid finish height 1753210",
  "fxtTransaction": "0",
  "phased": true,
  "ecBlockId": "932872672786447209",
  "signatureHash": "c398f205e8f20a0bfe45c86a563874216a60091d39f2aa3c8a711d124c72e0d9",
  "attachment": {},
  "senderRS": "ARDOR-X8ZN-WUJ2-SXY3-FBUYC",
  "subtype": 0,
  "amountNQT": "10000000000",
  "recipientRS": "ARDOR-8UA2-QQ7E-BN7G-G9YCD",
  "verify": true,
  "deadline": 40,
  "timestamp": 41820640,
  "height": 2147483647,
  "validate": false,
  "senderPublicKey": "df21142bd38c04bd5c5c342c6ca36802f9de89b75b2a0a8cbd32d29dca481e5c",
  "chain": 2,
  "feeNQT": "1000000",
  "requestProcessingTime": 3,
  "fullHash": "e407147def5982a0e330065939043f0b7c0f3158da7ff6216a730328f9de0a51",
  "version": 1,
  "sender": "15382970207090678772",
  "recipient": "16549540838234089728",
  "ecBlockHeight": 1738000
}

processVoucher

Process voucher

POST

https://ardr.nownodes.io/nxt

Body

application/x-www-form-urlencoded

secretPhrasestring

transactionBytesstring

Parameters

requestTypestringrequiredquery

Response

200OK

Voucher processing result

400Bad Request

Bad Request

500Internal Server Error

Internal Server Error

Process voucher

curl -X POST 'https://ardr.nownodes.io/nxt' \
  -H 'Content-Type: application/x-www-form-urlencoded' \
  -d '{
    "secretPhrase": "IwontTellYou",
    "transactionBytes": "02000000000001e0217e022800df21142bd38c04bd5c5c342c6ca36802f9de89b75b2a0a8cbd32d29dca481e5c0069c38ab5c7abe500e40b540200000040420f000000000058cda06a138b59b46b19c5e5d06d65334ed338d0e48d9694ae5c119913d2a00c9b4871989dd367442d1dbd94d22336515135cc3bf35e7c952c244e9d1b6a5c9810851a0069fb1adac03af20c40000000017ac01a000001000000000000000000000000000000016059eed721ae4ad4000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
  }'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/x-www-form-urlencoded',
  },
  body: JSON.stringify({
      "secretPhrase": "IwontTellYou",
      "transactionBytes": "02000000000001e0217e022800df21142bd38c04bd5c5c342c6ca36802f9de89b75b2a0a8cbd32d29dca481e5c0069c38ab5c7abe500e40b540200000040420f000000000058cda06a138b59b46b19c5e5d06d65334ed338d0e48d9694ae5c119913d2a00c9b4871989dd367442d1dbd94d22336515135cc3bf35e7c952c244e9d1b6a5c9810851a0069fb1adac03af20c40000000017ac01a000001000000000000000000000000000000016059eed721ae4ad4000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
    }),
});

const data = await response.json();

import requests

payload = {
  "secretPhrase": "IwontTellYou",
  "transactionBytes": "02000000000001e0217e022800df21142bd38c04bd5c5c342c6ca36802f9de89b75b2a0a8cbd32d29dca481e5c0069c38ab5c7abe500e40b540200000040420f000000000058cda06a138b59b46b19c5e5d06d65334ed338d0e48d9694ae5c119913d2a00c9b4871989dd367442d1dbd94d22336515135cc3bf35e7c952c244e9d1b6a5c9810851a0069fb1adac03af20c40000000017ac01a000001000000000000000000000000000000016059eed721ae4ad4000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
}

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

Request Body

{
  "secretPhrase": "IwontTellYou",
  "transactionBytes": "02000000000001e0217e022800df21142bd38c04bd5c5c342c6ca36802f9de89b75b2a0a8cbd32d29dca481e5c0069c38ab5c7abe500e40b540200000040420f000000000058cda06a138b59b46b19c5e5d06d65334ed338d0e48d9694ae5c119913d2a00c9b4871989dd367442d1dbd94d22336515135cc3bf35e7c952c244e9d1b6a5c9810851a0069fb1adac03af20c40000000017ac01a000001000000000000000000000000000000016059eed721ae4ad4000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
}

200

{
  "errorDescription": "Incorrect \"file\" cannot read file data",
  "errorCode": 4
}

retrievePrunedTransaction

Retrieve pruned transaction

GET

https://ardr.nownodes.io/nxt

Parameters

requestTypestringrequiredquery

chainintegerrequiredquery

transactionFullHashstringrequiredquery

Response

200OK

Pruned transaction retrieval result

400Bad Request

Bad Request

500Internal Server Error

Internal Server Error

Retrieve pruned transaction

curl -X GET 'https://ardr.nownodes.io/nxt'

const response = await fetch('https://ardr.nownodes.io/nxt', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ardr.nownodes.io/nxt')
data = response.json()

200

{
  "errorDescription": "Incorrect \"file\" cannot read file data",
  "errorCode": 4
}

Documentation

Authentication

Account Control

getAccount

Body

Response

Authorization

getAllPhasingOnlyControls

Parameters

Response

Authorization

getPhasingOnlyControl

Parameters

Response

Authorization

leaseBalance

Body

Response

Authorization

setPhasingOnlyControl

Body

Response

Authorization

Forging

leaseBalance

Body

Response

Authorization

addBundlingRule

Body

Response

Authorization

blacklistBundler

Body

Response

Authorization

bundleTransactions

Body

Response

Authorization

getAllBundlersRates

Body

Response

Authorization

getBundlers

Body

Response

Authorization

getBundlersRates

Body

Response

Authorization

getGuaranteedBalance

Body

Response

Authorization

getNextBlockGenerators

Body

Response

Authorization

startBundler

Body

Response

Authorization

startForging

Body

Response

Authorization

stopForging

Body

Response

Authorization

getForging

Body

Response

Authorization

stopBundler

Body

Response

Authorization