Kaspa REST-API server

v1.0.0

Base URL

https://kas.nownodes.io

This server is to communicate with kaspa network via REST-API

Authentication

api-keyAuthapiKey

API Key: api-key in header

Kaspa REST-API server

Addresses

Get Balance From Kaspa Address

GET

https://kas.nownodes.io/addresses/{kaspaAddress}/balance

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Get balance for a given kaspa address

Parameters

kaspaAddressstringrequiredpath

Kaspa address as string e.g. kaspa:qqkqkzjvr7zwxxmjxjkmxxdwju9kjs6e9u82uh59z07vgaks6gg62v8707g73

Response

200OK

Successful Response

422Unprocessable Entity

Validation Error

503Service Unavailable

Service Unavailable: no synced Kaspa node is reachable

Get Balance From Kaspa Address

curl -X GET 'https://kas.nownodes.io/addresses/{kaspaAddress}/balance'

const response = await fetch('https://kas.nownodes.io/addresses/{kaspaAddress}/balance', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://kas.nownodes.io/addresses/{kaspaAddress}/balance')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://kas.nownodes.io/addresses/{kaspaAddress}/balance')
data = response.json()

const response = await fetch('https://kas.nownodes.io/addresses/{kaspaAddress}/balance', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://kas.nownodes.io/addresses/{kaspaAddress}/balance";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://kas.nownodes.io/addresses/{kaspaAddress}/balance', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://kas.nownodes.io/addresses/{kaspaAddress}/balance')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://kas.nownodes.io/addresses/{kaspaAddress}/balance')
request = Net::HTTP::Get.new(uri)

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

{
  "address": "kaspa:qqkqkzjvr7zwxxmjxjkmxxdwju9kjs6e9u82uh59z07vgaks6gg62v8707g73",
  "balance": 38240000000
}

{
  "detail": [
    {
      "loc": [
        "string"
      ],
      "msg": "string",
      "type": "string"
    }
  ]
}

{
  "detail": "Kaspad unavailable"
}

Get Utxos For Address

GET

https://kas.nownodes.io/addresses/{kaspaAddress}/utxos

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Lists all open utxo for a given kaspa address

Parameters

kaspaAddressstringrequiredpath

Kaspa address as string e.g. kaspa:qqkqkzjvr7zwxxmjxjkmxxdwju9kjs6e9u82uh59z07vgaks6gg62v8707g73

Response

200OK

Successful Response

422Unprocessable Entity

Validation Error

503Service Unavailable

Service Unavailable: no synced Kaspa node is reachable

Get Utxos For Address

curl -X GET 'https://kas.nownodes.io/addresses/{kaspaAddress}/utxos'

const response = await fetch('https://kas.nownodes.io/addresses/{kaspaAddress}/utxos', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://kas.nownodes.io/addresses/{kaspaAddress}/utxos')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://kas.nownodes.io/addresses/{kaspaAddress}/utxos')
data = response.json()

const response = await fetch('https://kas.nownodes.io/addresses/{kaspaAddress}/utxos', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://kas.nownodes.io/addresses/{kaspaAddress}/utxos";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://kas.nownodes.io/addresses/{kaspaAddress}/utxos', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://kas.nownodes.io/addresses/{kaspaAddress}/utxos')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://kas.nownodes.io/addresses/{kaspaAddress}/utxos')
request = Net::HTTP::Get.new(uri)

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

[
  {
    "address": "kaspa:qqkqkzjvr7zwxxmjxjkmxxdwju9kjs6e9u82uh59z07vgaks6gg62v8707g73",
    "outpoint": {
      "transactionId": "ef62efbc2825d3ef9ec1cf9b80506876ac077b64b11a39c8ef5e028415444dc9",
      "index": 0
    },
    "utxoEntry": {
      "amount": "11501593788",
      "scriptPublicKey": {
        "scriptPublicKey": "20c5629ce85f6618cd3ed1ac1c99dc6d3064ed244013555c51385d9efab0d0072fac"
      },
      "blockDaaScore": "18867232",
      "isCoinbase": false
    }
  }
]

{
  "detail": [
    {
      "loc": [
        "string"
      ],
      "msg": "string",
      "type": "string"
    }
  ]
}

{
  "detail": "Kaspad unavailable"
}

Get Utxos For Addresses

POST

https://kas.nownodes.io/addresses/utxos

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Lists all open utxo for a given kaspa address

Body

application/json

addressesArray<string>kaspa:qqkqkzjvr7zwxxmjxjkmxxdwju9kjs6e9u82uh59z07vgaks6gg62v8707g73

Response

200OK

Successful Response

422Unprocessable Entity

Validation Error

503Service Unavailable

Service Unavailable: no synced Kaspa node is reachable

Get Utxos For Addresses

curl -X POST 'https://kas.nownodes.io/addresses/utxos' \
  -H 'Content-Type: application/json' \
  -d '{
    "addresses": [
      "kaspa:qqkqkzjvr7zwxxmjxjkmxxdwju9kjs6e9u82uh59z07vgaks6gg62v8707g73"
    ]
  }'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://kas.nownodes.io/addresses/utxos')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "addresses": [
      "kaspa:qqkqkzjvr7zwxxmjxjkmxxdwju9kjs6e9u82uh59z07vgaks6gg62v8707g73"
    ]
  }'

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

import requests

payload = {
  "addresses": [
    "kaspa:qqkqkzjvr7zwxxmjxjkmxxdwju9kjs6e9u82uh59z07vgaks6gg62v8707g73"
  ]
}

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

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

const data = await response.json();

const endpoint = "https://kas.nownodes.io/addresses/utxos";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({
    "addresses": [
      "kaspa:qqkqkzjvr7zwxxmjxjkmxxdwju9kjs6e9u82uh59z07vgaks6gg62v8707g73"
    ]
  });
console.log(result);

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

const data = await response.json();

import requests

payload = {
  "addresses": [
    "kaspa:qqkqkzjvr7zwxxmjxjkmxxdwju9kjs6e9u82uh59z07vgaks6gg62v8707g73"
  ]
}

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

require 'net/http'
require 'json'

uri = URI('https://kas.nownodes.io/addresses/utxos')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "addresses": [
      "kaspa:qqkqkzjvr7zwxxmjxjkmxxdwju9kjs6e9u82uh59z07vgaks6gg62v8707g73"
    ]
  }'

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

Request Body

{
  "addresses": [
    "kaspa:qqkqkzjvr7zwxxmjxjkmxxdwju9kjs6e9u82uh59z07vgaks6gg62v8707g73"
  ]
}

[
  {
    "address": "kaspa:qqkqkzjvr7zwxxmjxjkmxxdwju9kjs6e9u82uh59z07vgaks6gg62v8707g73",
    "outpoint": {
      "transactionId": "ef62efbc2825d3ef9ec1cf9b80506876ac077b64b11a39c8ef5e028415444dc9",
      "index": 0
    },
    "utxoEntry": {
      "amount": "11501593788",
      "scriptPublicKey": {
        "scriptPublicKey": "20c5629ce85f6618cd3ed1ac1c99dc6d3064ed244013555c51385d9efab0d0072fac"
      },
      "blockDaaScore": "18867232",
      "isCoinbase": false
    }
  }
]

{
  "detail": [
    {
      "loc": [
        "string"
      ],
      "msg": "string",
      "type": "string"
    }
  ]
}

{
  "detail": "Kaspad unavailable"
}

Get Full Transactions For Address

GET

https://kas.nownodes.io/addresses/{kaspaAddress}/full-transactions

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Get full transaction data for the transactions of a given address, newest first. Use limit and offset for paging.

Parameters

kaspaAddressstringrequiredpath

Kaspa address as string e.g. kaspa:qqkqkzjvr7zwxxmjxjkmxxdwju9kjs6e9u82uh59z07vgaks6gg62v8707g73

limitinteger[1, 500]50query

The number of records to get

offsetinteger>= 00query

The offset from which to get records

fieldsstringquery

resolve_previous_outpointsPreviousOutpointLookupModenoquery

Use this parameter if you want to fetch the TransactionInput previous outpoint details. Light fetches only the adress and amount. Full fetches the whole TransactionOutput and adds it into each TxInput.

Response

200OK

Successful Response

422Unprocessable Entity

Validation Error

Get Full Transactions For Address

curl -X GET 'https://kas.nownodes.io/addresses/{kaspaAddress}/full-transactions'

const response = await fetch('https://kas.nownodes.io/addresses/{kaspaAddress}/full-transactions', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://kas.nownodes.io/addresses/{kaspaAddress}/full-transactions')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://kas.nownodes.io/addresses/{kaspaAddress}/full-transactions')
data = response.json()

const response = await fetch('https://kas.nownodes.io/addresses/{kaspaAddress}/full-transactions', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://kas.nownodes.io/addresses/{kaspaAddress}/full-transactions";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://kas.nownodes.io/addresses/{kaspaAddress}/full-transactions', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://kas.nownodes.io/addresses/{kaspaAddress}/full-transactions')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://kas.nownodes.io/addresses/{kaspaAddress}/full-transactions')
request = Net::HTTP::Get.new(uri)

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

[
  {
    "subnetwork_id": "string",
    "transaction_id": "string",
    "hash": "string",
    "mass": "string",
    "payload": "string",
    "block_hash": [
      "string"
    ],
    "block_time": 0,
    "is_accepted": true,
    "accepting_block_hash": "string",
    "accepting_block_blue_score": 0,
    "accepting_block_time": 0,
    "inputs": [
      {
        "transaction_id": "string",
        "index": 0,
        "previous_outpoint_hash": "string",
        "previous_outpoint_index": "string",
        "previous_outpoint_resolved": {
          "transaction_id": "string",
          "index": 0,
          "amount": 0,
          "script_public_key": "string",
          "script_public_key_address": "string",
          "script_public_key_type": "string",
          "accepting_block_hash": "string"
        },
        "previous_outpoint_address": "string",
        "previous_outpoint_amount": 0,
        "signature_script": "string",
        "sig_op_count": "string"
      }
    ],
    "outputs": [
      {
        "transaction_id": "string",
        "index": 0,
        "amount": 0,
        "script_public_key": "string",
        "script_public_key_address": "string",
        "script_public_key_type": "string",
        "accepting_block_hash": "string"
      }
    ]
  }
]

{
  "detail": [
    {
      "loc": [
        "string"
      ],
      "msg": "string",
      "type": "string"
    }
  ]
}

Get Addresses Active

POST

https://kas.nownodes.io/addresses/active

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

This endpoint checks if addresses have had any transaction activity in the past. It is specifically designed for HD Wallets to verify historical address activity.

Body

application/json

addressesArray<string>kaspa:qqkqkzjvr7zwxxmjxjkmxxdwju9kjs6e9u82uh59z07vgaks6gg62v8707g73

Response

200OK

Successful Response

422Unprocessable Entity

Validation Error

Get Addresses Active

curl -X POST 'https://kas.nownodes.io/addresses/active' \
  -H 'Content-Type: application/json' \
  -d '{
    "addresses": [
      "kaspa:qqkqkzjvr7zwxxmjxjkmxxdwju9kjs6e9u82uh59z07vgaks6gg62v8707g73"
    ]
  }'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://kas.nownodes.io/addresses/active')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "addresses": [
      "kaspa:qqkqkzjvr7zwxxmjxjkmxxdwju9kjs6e9u82uh59z07vgaks6gg62v8707g73"
    ]
  }'

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

import requests

payload = {
  "addresses": [
    "kaspa:qqkqkzjvr7zwxxmjxjkmxxdwju9kjs6e9u82uh59z07vgaks6gg62v8707g73"
  ]
}

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

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

const data = await response.json();

const endpoint = "https://kas.nownodes.io/addresses/active";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({
    "addresses": [
      "kaspa:qqkqkzjvr7zwxxmjxjkmxxdwju9kjs6e9u82uh59z07vgaks6gg62v8707g73"
    ]
  });
console.log(result);

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

const data = await response.json();

import requests

payload = {
  "addresses": [
    "kaspa:qqkqkzjvr7zwxxmjxjkmxxdwju9kjs6e9u82uh59z07vgaks6gg62v8707g73"
  ]
}

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

require 'net/http'
require 'json'

uri = URI('https://kas.nownodes.io/addresses/active')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "addresses": [
      "kaspa:qqkqkzjvr7zwxxmjxjkmxxdwju9kjs6e9u82uh59z07vgaks6gg62v8707g73"
    ]
  }'

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

Request Body

{
  "addresses": [
    "kaspa:qqkqkzjvr7zwxxmjxjkmxxdwju9kjs6e9u82uh59z07vgaks6gg62v8707g73"
  ]
}

[
  {
    "address": "kaspa:qqkqkzjvr7zwxxmjxjkmxxdwju9kjs6e9u82uh59z07vgaks6gg62v8707g73",
    "active": true,
    "lastTxBlockTime": 1752924174352
  }
]

{
  "detail": [
    {
      "loc": [
        "string"
      ],
      "msg": "string",
      "type": "string"
    }
  ]
}

Get Full Transactions For Address Page

GET

https://kas.nownodes.io/addresses/{kaspaAddress}/full-transactions-page

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Get full transaction data for the transactions of a given address, newest first. Use limit and before/after for paging.

Parameters

kaspaAddressstringrequiredpath

Kaspa address as string e.g. kaspa:qqkqkzjvr7zwxxmjxjkmxxdwju9kjs6e9u82uh59z07vgaks6gg62v8707g73

limitinteger[1, 500]50query

The max number of records to get. For paging combine with using 'before/after' from oldest previous result. Use value of X-Next-Page-Before/-After as long as header is present to continue paging. The actual number of transactions returned for each page can be > limit.

beforeinteger>= 00query

Only include transactions with block time before this (epoch-millis)

afterinteger>= 00query

Only include transactions with block time after this (epoch-millis)

fieldsstringquery

resolve_previous_outpointsPreviousOutpointLookupModenoquery

acceptanceAcceptanceModeacceptedrejectedquery

Response

200OK

Successful Response

422Unprocessable Entity

Validation Error

Get Full Transactions For Address Page

curl -X GET 'https://kas.nownodes.io/addresses/{kaspaAddress}/full-transactions-page'

const response = await fetch('https://kas.nownodes.io/addresses/{kaspaAddress}/full-transactions-page', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://kas.nownodes.io/addresses/{kaspaAddress}/full-transactions-page')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://kas.nownodes.io/addresses/{kaspaAddress}/full-transactions-page')
data = response.json()

const response = await fetch('https://kas.nownodes.io/addresses/{kaspaAddress}/full-transactions-page', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://kas.nownodes.io/addresses/{kaspaAddress}/full-transactions-page";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://kas.nownodes.io/addresses/{kaspaAddress}/full-transactions-page', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://kas.nownodes.io/addresses/{kaspaAddress}/full-transactions-page')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://kas.nownodes.io/addresses/{kaspaAddress}/full-transactions-page')
request = Net::HTTP::Get.new(uri)

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

[
  {
    "subnetwork_id": "string",
    "transaction_id": "string",
    "hash": "string",
    "mass": "string",
    "payload": "string",
    "block_hash": [
      "string"
    ],
    "block_time": 0,
    "is_accepted": true,
    "accepting_block_hash": "string",
    "accepting_block_blue_score": 0,
    "accepting_block_time": 0,
    "inputs": [
      {
        "transaction_id": "string",
        "index": 0,
        "previous_outpoint_hash": "string",
        "previous_outpoint_index": "string",
        "previous_outpoint_resolved": {
          "transaction_id": "string",
          "index": 0,
          "amount": 0,
          "script_public_key": "string",
          "script_public_key_address": "string",
          "script_public_key_type": "string",
          "accepting_block_hash": "string"
        },
        "previous_outpoint_address": "string",
        "previous_outpoint_amount": 0,
        "signature_script": "string",
        "sig_op_count": "string"
      }
    ],
    "outputs": [
      {
        "transaction_id": "string",
        "index": 0,
        "amount": 0,
        "script_public_key": "string",
        "script_public_key_address": "string",
        "script_public_key_type": "string",
        "accepting_block_hash": "string"
      }
    ]
  }
]

{
  "detail": [
    {
      "loc": [
        "string"
      ],
      "msg": "string",
      "type": "string"
    }
  ]
}

Get Transaction Count For Address

GET

https://kas.nownodes.io/addresses/{kaspaAddress}/transactions-count

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Count the number of transactions associated with this address

Parameters

kaspaAddressstringrequiredpath

Kaspa address as string e.g. kaspa:qqkqkzjvr7zwxxmjxjkmxxdwju9kjs6e9u82uh59z07vgaks6gg62v8707g73

Response

200OK

Successful Response

422Unprocessable Entity

Validation Error

Get Transaction Count For Address

curl -X GET 'https://kas.nownodes.io/addresses/{kaspaAddress}/transactions-count'

const response = await fetch('https://kas.nownodes.io/addresses/{kaspaAddress}/transactions-count', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://kas.nownodes.io/addresses/{kaspaAddress}/transactions-count')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://kas.nownodes.io/addresses/{kaspaAddress}/transactions-count')
data = response.json()

const response = await fetch('https://kas.nownodes.io/addresses/{kaspaAddress}/transactions-count', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://kas.nownodes.io/addresses/{kaspaAddress}/transactions-count";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://kas.nownodes.io/addresses/{kaspaAddress}/transactions-count', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://kas.nownodes.io/addresses/{kaspaAddress}/transactions-count')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://kas.nownodes.io/addresses/{kaspaAddress}/transactions-count')
request = Net::HTTP::Get.new(uri)

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

{
  "total": 0,
  "limit_exceeded": true
}

{
  "detail": [
    {
      "loc": [
        "string"
      ],
      "msg": "string",
      "type": "string"
    }
  ]
}

Get Addresses Names

GET

https://kas.nownodes.io/addresses/names

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Get the name for an address

Response

200OK

Successful Response

Get Addresses Names

curl -X GET 'https://kas.nownodes.io/addresses/names'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://kas.nownodes.io/addresses/names')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://kas.nownodes.io/addresses/names')
data = response.json()

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

const data = await response.json();

const endpoint = "https://kas.nownodes.io/addresses/names";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

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

const data = await response.json();

import requests

response = requests.get('https://kas.nownodes.io/addresses/names')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://kas.nownodes.io/addresses/names')
request = Net::HTTP::Get.new(uri)

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

200

[
  {
    "address": "string",
    "name": "string"
  }
]

Get Name For Address

GET

https://kas.nownodes.io/addresses/{kaspaAddress}/name

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Get the name for an address

Parameters

kaspaAddressstringrequiredpath

Kaspa address as string e.g. kaspa:qqkqkzjvr7zwxxmjxjkmxxdwju9kjs6e9u82uh59z07vgaks6gg62v8707g73

Response

200OK

Successful Response

422Unprocessable Entity

Validation Error

Get Name For Address

curl -X GET 'https://kas.nownodes.io/addresses/{kaspaAddress}/name'

const response = await fetch('https://kas.nownodes.io/addresses/{kaspaAddress}/name', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://kas.nownodes.io/addresses/{kaspaAddress}/name')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://kas.nownodes.io/addresses/{kaspaAddress}/name')
data = response.json()

const response = await fetch('https://kas.nownodes.io/addresses/{kaspaAddress}/name', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://kas.nownodes.io/addresses/{kaspaAddress}/name";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://kas.nownodes.io/addresses/{kaspaAddress}/name', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://kas.nownodes.io/addresses/{kaspaAddress}/name')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://kas.nownodes.io/addresses/{kaspaAddress}/name')
request = Net::HTTP::Get.new(uri)

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

{
  "address": "string",
  "name": "string"
}

{
  "detail": [
    {
      "loc": [
        "string"
      ],
      "msg": "string",
      "type": "string"
    }
  ]
}

Get Balances From Addresses

POST

https://kas.nownodes.io/addresses/balances

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Get balances for multiple Addresses

Body

application/json

addressesArray<string>kaspa:qqkqkzjvr7zwxxmjxjkmxxdwju9kjs6e9u82uh59z07vgaks6gg62v8707g73

Response

200OK

Successful Response

422Unprocessable Entity

Validation Error

503Service Unavailable

Service Unavailable: no synced Kaspa node is reachable

Get Balances From Addresses

curl -X POST 'https://kas.nownodes.io/addresses/balances' \
  -H 'Content-Type: application/json' \
  -d '{
    "addresses": [
      "kaspa:qqkqkzjvr7zwxxmjxjkmxxdwju9kjs6e9u82uh59z07vgaks6gg62v8707g73"
    ]
  }'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://kas.nownodes.io/addresses/balances')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "addresses": [
      "kaspa:qqkqkzjvr7zwxxmjxjkmxxdwju9kjs6e9u82uh59z07vgaks6gg62v8707g73"
    ]
  }'

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

import requests

payload = {
  "addresses": [
    "kaspa:qqkqkzjvr7zwxxmjxjkmxxdwju9kjs6e9u82uh59z07vgaks6gg62v8707g73"
  ]
}

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

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

const data = await response.json();

const endpoint = "https://kas.nownodes.io/addresses/balances";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({
    "addresses": [
      "kaspa:qqkqkzjvr7zwxxmjxjkmxxdwju9kjs6e9u82uh59z07vgaks6gg62v8707g73"
    ]
  });
console.log(result);

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

const data = await response.json();

import requests

payload = {
  "addresses": [
    "kaspa:qqkqkzjvr7zwxxmjxjkmxxdwju9kjs6e9u82uh59z07vgaks6gg62v8707g73"
  ]
}

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

require 'net/http'
require 'json'

uri = URI('https://kas.nownodes.io/addresses/balances')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "addresses": [
      "kaspa:qqkqkzjvr7zwxxmjxjkmxxdwju9kjs6e9u82uh59z07vgaks6gg62v8707g73"
    ]
  }'

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

Request Body

{
  "addresses": [
    "kaspa:qqkqkzjvr7zwxxmjxjkmxxdwju9kjs6e9u82uh59z07vgaks6gg62v8707g73"
  ]
}

[
  {
    "address": "kaspa:qqkqkzjvr7zwxxmjxjkmxxdwju9kjs6e9u82uh59z07vgaks6gg62v8707g73",
    "balance": 12451591699
  }
]

{
  "detail": [
    {
      "loc": [
        "string"
      ],
      "msg": "string",
      "type": "string"
    }
  ]
}

{
  "detail": "Kaspad unavailable"
}

Info

Get Virtual Selected Parent Blue Score

GET

https://kas.nownodes.io/info/virtual-chain-blue-score

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the blue score of the sink

Response

200OK

Successful Response

503Service Unavailable

Service Unavailable: no synced Kaspa node is reachable

Get Virtual Selected Parent Blue Score

curl -X GET 'https://kas.nownodes.io/info/virtual-chain-blue-score'

const response = await fetch('https://kas.nownodes.io/info/virtual-chain-blue-score', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://kas.nownodes.io/info/virtual-chain-blue-score')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://kas.nownodes.io/info/virtual-chain-blue-score')
data = response.json()

const response = await fetch('https://kas.nownodes.io/info/virtual-chain-blue-score', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://kas.nownodes.io/info/virtual-chain-blue-score";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://kas.nownodes.io/info/virtual-chain-blue-score', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://kas.nownodes.io/info/virtual-chain-blue-score')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://kas.nownodes.io/info/virtual-chain-blue-score')
request = Net::HTTP::Get.new(uri)

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

{
  "blueScore": 260890
}

{
  "detail": "Kaspad unavailable"
}

Get Network

GET

https://kas.nownodes.io/info/network

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Alias for /info/blockdag

Response

200OK

Successful Response

503Service Unavailable

Service Unavailable: no synced Kaspa node is reachable

Get Network

curl -X GET 'https://kas.nownodes.io/info/network'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://kas.nownodes.io/info/network')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://kas.nownodes.io/info/network')
data = response.json()

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

const data = await response.json();

const endpoint = "https://kas.nownodes.io/info/network";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

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

const data = await response.json();

import requests

response = requests.get('https://kas.nownodes.io/info/network')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://kas.nownodes.io/info/network')
request = Net::HTTP::Get.new(uri)

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

{
  "networkName": "kaspa-mainnet",
  "blockCount": "260890",
  "headerCount": "2131312",
  "tipHashes": [
    "78273854a739e3e379dfd34a262bbe922400d8e360e30e3f31228519a334350a"
  ],
  "difficulty": 3870677677777.2,
  "pastMedianTime": "1656455670700",
  "virtualParentHashes": [
    "78273854a739e3e379dfd34a262bbe922400d8e360e30e3f31228519a334350a"
  ],
  "pruningPointHash": "5d32a9403273a34b6551b84340a1459ddde2ae6ba59a47987a6374340ba41d5d",
  "virtualDaaScore": "19989141",
  "sink": "366b1cf51146cc002672b79948634751a2914a2cc9e273afe358bdc1ae19dce9"
}

{
  "detail": "Kaspad unavailable"
}

Get Blockdag

GET

https://kas.nownodes.io/info/blockdag

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Get Kaspa BlockDAG information

Response

200OK

Successful Response

503Service Unavailable

Service Unavailable: no synced Kaspa node is reachable

Get Blockdag

curl -X GET 'https://kas.nownodes.io/info/blockdag'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://kas.nownodes.io/info/blockdag')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://kas.nownodes.io/info/blockdag')
data = response.json()

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

const data = await response.json();

const endpoint = "https://kas.nownodes.io/info/blockdag";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

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

const data = await response.json();

import requests

response = requests.get('https://kas.nownodes.io/info/blockdag')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://kas.nownodes.io/info/blockdag')
request = Net::HTTP::Get.new(uri)

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

{
  "networkName": "kaspa-mainnet",
  "blockCount": "260890",
  "headerCount": "2131312",
  "tipHashes": [
    "78273854a739e3e379dfd34a262bbe922400d8e360e30e3f31228519a334350a"
  ],
  "difficulty": 3870677677777.2,
  "pastMedianTime": "1656455670700",
  "virtualParentHashes": [
    "78273854a739e3e379dfd34a262bbe922400d8e360e30e3f31228519a334350a"
  ],
  "pruningPointHash": "5d32a9403273a34b6551b84340a1459ddde2ae6ba59a47987a6374340ba41d5d",
  "virtualDaaScore": "19989141",
  "sink": "366b1cf51146cc002672b79948634751a2914a2cc9e273afe358bdc1ae19dce9"
}

{
  "detail": "Kaspad unavailable"
}

Get Coinsupply

GET

https://kas.nownodes.io/info/coinsupply

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Get $KAS coin supply information

Response

200OK

Successful Response

503Service Unavailable

Service Unavailable: no synced Kaspa node is reachable

Get Coinsupply

curl -X GET 'https://kas.nownodes.io/info/coinsupply'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://kas.nownodes.io/info/coinsupply')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://kas.nownodes.io/info/coinsupply')
data = response.json()

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

const data = await response.json();

const endpoint = "https://kas.nownodes.io/info/coinsupply";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

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

const data = await response.json();

import requests

response = requests.get('https://kas.nownodes.io/info/coinsupply')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://kas.nownodes.io/info/coinsupply')
request = Net::HTTP::Get.new(uri)

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

{
  "circulatingSupply": "1000900697580640180",
  "maxSupply": "2900000000000000000"
}

{
  "detail": "Kaspad unavailable"
}

Get Circulating Coins

GET

https://kas.nownodes.io/info/coinsupply/circulating

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Get circulating amount of $KAS coin as numerical value

Parameters

in_billionbooleanfalsequery

Response

200OK

Successful Response

422Unprocessable Entity

Validation Error

503Service Unavailable

Service Unavailable: no synced Kaspa node is reachable

Get Circulating Coins

curl -X GET 'https://kas.nownodes.io/info/coinsupply/circulating'

const response = await fetch('https://kas.nownodes.io/info/coinsupply/circulating', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://kas.nownodes.io/info/coinsupply/circulating')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://kas.nownodes.io/info/coinsupply/circulating')
data = response.json()

const response = await fetch('https://kas.nownodes.io/info/coinsupply/circulating', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://kas.nownodes.io/info/coinsupply/circulating";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://kas.nownodes.io/info/coinsupply/circulating', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://kas.nownodes.io/info/coinsupply/circulating')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://kas.nownodes.io/info/coinsupply/circulating')
request = Net::HTTP::Get.new(uri)

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

string

{
  "detail": [
    {
      "loc": [
        "string"
      ],
      "msg": "string",
      "type": "string"
    }
  ]
}

{
  "detail": "Kaspad unavailable"
}

Get Total Coins

GET

https://kas.nownodes.io/info/coinsupply/total

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Get total amount of $KAS coin as numerical value

Parameters

in_billionbooleanfalsequery

Response

200OK

Successful Response

422Unprocessable Entity

Validation Error

503Service Unavailable

Service Unavailable: no synced Kaspa node is reachable

Get Total Coins

curl -X GET 'https://kas.nownodes.io/info/coinsupply/total'

const response = await fetch('https://kas.nownodes.io/info/coinsupply/total', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://kas.nownodes.io/info/coinsupply/total')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://kas.nownodes.io/info/coinsupply/total')
data = response.json()

const response = await fetch('https://kas.nownodes.io/info/coinsupply/total', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://kas.nownodes.io/info/coinsupply/total";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://kas.nownodes.io/info/coinsupply/total', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://kas.nownodes.io/info/coinsupply/total')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://kas.nownodes.io/info/coinsupply/total')
request = Net::HTTP::Get.new(uri)

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

string

{
  "detail": [
    {
      "loc": [
        "string"
      ],
      "msg": "string",
      "type": "string"
    }
  ]
}

{
  "detail": "Kaspad unavailable"
}

Get Kaspad Info

GET

https://kas.nownodes.io/info/kaspad

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Get some information for kaspad instance, which is currently connected.

Response

200OK

Successful Response

503Service Unavailable

Service Unavailable: no synced Kaspa node is reachable

Get Kaspad Info

curl -X GET 'https://kas.nownodes.io/info/kaspad'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://kas.nownodes.io/info/kaspad')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://kas.nownodes.io/info/kaspad')
data = response.json()

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

const data = await response.json();

const endpoint = "https://kas.nownodes.io/info/kaspad";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

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

const data = await response.json();

import requests

response = requests.get('https://kas.nownodes.io/info/kaspad')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://kas.nownodes.io/info/kaspad')
request = Net::HTTP::Get.new(uri)

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

{
  "mempoolSize": "1",
  "serverVersion": "0.12.2",
  "isUtxoIndexed": true,
  "isSynced": true,
  "p2pIdHashed": "36a17cd8644eef34fc7fe4719655e06dbdf117008900c46975e66c35acd09b01"
}

{
  "detail": "Kaspad unavailable"
}

Get Fee Estimate

GET

https://kas.nownodes.io/info/fee-estimate

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Get fee estimate from Kaspad.

For all buckets, feerate values represent fee/mass of a transaction in sompi/gram units.
Given a feerate value recommendation, calculate the required fee by taking the transaction mass and multiplying it by feerate: fee = feerate * mass(tx)

Response

200OK

Successful Response

503Service Unavailable

Service Unavailable: no synced Kaspa node is reachable

Get Fee Estimate

curl -X GET 'https://kas.nownodes.io/info/fee-estimate'

const response = await fetch('https://kas.nownodes.io/info/fee-estimate', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://kas.nownodes.io/info/fee-estimate')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://kas.nownodes.io/info/fee-estimate')
data = response.json()

const response = await fetch('https://kas.nownodes.io/info/fee-estimate', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://kas.nownodes.io/info/fee-estimate";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://kas.nownodes.io/info/fee-estimate', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://kas.nownodes.io/info/fee-estimate')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://kas.nownodes.io/info/fee-estimate')
request = Net::HTTP::Get.new(uri)

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

{
  "priorityBucket": {
    "feerate": 1,
    "estimatedSeconds": 0.004
  },
  "normalBuckets": [
    {
      "feerate": 1,
      "estimatedSeconds": 0.004
    }
  ],
  "lowBuckets": [
    {
      "feerate": 1,
      "estimatedSeconds": 0.004
    }
  ]
}

{
  "detail": "Kaspad unavailable"
}

Get Price

GET

https://kas.nownodes.io/info/price

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the current price for Kaspa in USD. Price info is from coingecko.com

Parameters

stringOnlybooleanfalsequery

Response

200OK

Successful Response

422Unprocessable Entity

Validation Error

Get Price

curl -X GET 'https://kas.nownodes.io/info/price'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://kas.nownodes.io/info/price')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://kas.nownodes.io/info/price')
data = response.json()

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

const data = await response.json();

const endpoint = "https://kas.nownodes.io/info/price";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

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

const data = await response.json();

import requests

response = requests.get('https://kas.nownodes.io/info/price')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://kas.nownodes.io/info/price')
request = Net::HTTP::Get.new(uri)

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

{
  "price": 0.025235
}

{
  "detail": [
    {
      "loc": [
        "string"
      ],
      "msg": "string",
      "type": "string"
    }
  ]
}

Get Blockreward

GET

https://kas.nownodes.io/info/blockreward

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the current blockreward in KAS/block

Parameters

stringOnlybooleanfalsequery

Response

200OK

Successful Response

422Unprocessable Entity

Validation Error

Get Blockreward

curl -X GET 'https://kas.nownodes.io/info/blockreward'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://kas.nownodes.io/info/blockreward')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://kas.nownodes.io/info/blockreward')
data = response.json()

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

const data = await response.json();

const endpoint = "https://kas.nownodes.io/info/blockreward";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

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

const data = await response.json();

import requests

response = requests.get('https://kas.nownodes.io/info/blockreward')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://kas.nownodes.io/info/blockreward')
request = Net::HTTP::Get.new(uri)

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

{
  "blockreward": 12000132
}

{
  "detail": [
    {
      "loc": [
        "string"
      ],
      "msg": "string",
      "type": "string"
    }
  ]
}

Get Halving

GET

https://kas.nownodes.io/info/halving

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns information about chromatic halving

Parameters

fieldstringquery

Response

200OK

Successful Response

422Unprocessable Entity

Validation Error

Get Halving

curl -X GET 'https://kas.nownodes.io/info/halving'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://kas.nownodes.io/info/halving')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://kas.nownodes.io/info/halving')
data = response.json()

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

const data = await response.json();

const endpoint = "https://kas.nownodes.io/info/halving";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

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

const data = await response.json();

import requests

response = requests.get('https://kas.nownodes.io/info/halving')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://kas.nownodes.io/info/halving')
request = Net::HTTP::Get.new(uri)

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

{
  "nextHalvingTimestamp": 1662837270000,
  "nextHalvingDate": "2022-09-10 19:38:52 UTC",
  "nextHalvingAmount": 155.123123
}

{
  "detail": [
    {
      "loc": [
        "string"
      ],
      "msg": "string",
      "type": "string"
    }
  ]
}

Get Hashrate

GET

https://kas.nownodes.io/info/hashrate

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the current hashrate for Kaspa network in TH/s.

Parameters

stringOnlybooleanfalsequery

Response

200OK

Successful Response

422Unprocessable Entity

Validation Error

503Service Unavailable

Service Unavailable: no synced Kaspa node is reachable

Get Hashrate

curl -X GET 'https://kas.nownodes.io/info/hashrate'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://kas.nownodes.io/info/hashrate')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://kas.nownodes.io/info/hashrate')
data = response.json()

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

const data = await response.json();

const endpoint = "https://kas.nownodes.io/info/hashrate";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

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

const data = await response.json();

import requests

response = requests.get('https://kas.nownodes.io/info/hashrate')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://kas.nownodes.io/info/hashrate')
request = Net::HTTP::Get.new(uri)

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

{
  "hashrate": 12000132
}

{
  "detail": [
    {
      "loc": [
        "string"
      ],
      "msg": "string",
      "type": "string"
    }
  ]
}

{
  "detail": "Kaspad unavailable"
}

Get Max Hashrate

GET

https://kas.nownodes.io/info/hashrate/max

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the highest hashrate observed for Kaspa network in TH/s, and the block it was calculated from.

Response

200OK

Successful Response

503Service Unavailable

Service Unavailable: no synced Kaspa node is reachable

Get Max Hashrate

curl -X GET 'https://kas.nownodes.io/info/hashrate/max'

const response = await fetch('https://kas.nownodes.io/info/hashrate/max', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://kas.nownodes.io/info/hashrate/max')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://kas.nownodes.io/info/hashrate/max')
data = response.json()

const response = await fetch('https://kas.nownodes.io/info/hashrate/max', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://kas.nownodes.io/info/hashrate/max";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://kas.nownodes.io/info/hashrate/max', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://kas.nownodes.io/info/hashrate/max')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://kas.nownodes.io/info/hashrate/max')
request = Net::HTTP::Get.new(uri)

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

{
  "hashrate": 12000132,
  "blockheader": {
    "hash": "e6641454e16cff4f232b899564eeaa6e480b66069d87bee6a2b2476e63fcd887",
    "timestamp": "1656450648874",
    "difficulty": 1212312312,
    "daaScore": "19984482",
    "blueScore": "18483232"
  }
}

{
  "detail": "Kaspad unavailable"
}

Get Hashrate History

GET

https://kas.nownodes.io/info/hashrate/history

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Get historical hashrate samples with optional resolution (default = 1h)

Parameters

resolutionstring1h3h1d7dquery

Response

200OK

Successful Response

422Unprocessable Entity

Validation Error

Get Hashrate History

curl -X GET 'https://kas.nownodes.io/info/hashrate/history'

const response = await fetch('https://kas.nownodes.io/info/hashrate/history', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://kas.nownodes.io/info/hashrate/history')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://kas.nownodes.io/info/hashrate/history')
data = response.json()

const response = await fetch('https://kas.nownodes.io/info/hashrate/history', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://kas.nownodes.io/info/hashrate/history";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://kas.nownodes.io/info/hashrate/history', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://kas.nownodes.io/info/hashrate/history')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://kas.nownodes.io/info/hashrate/history')
request = Net::HTTP::Get.new(uri)

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

[
  {
    "daaScore": 0,
    "blueScore": 0,
    "timestamp": 0,
    "date_time": "string",
    "bits": 0,
    "difficulty": 0,
    "hashrate_kh": 0
  }
]

{
  "detail": [
    {
      "loc": [
        "string"
      ],
      "msg": "string",
      "type": "string"
    }
  ]
}

Health State

GET

https://kas.nownodes.io/info/health

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Checks node and database health by comparing blue score and sync status. Returns health details or 503 if the database lags by ~10min or no nodes are synced.

Response

200OK

Successful Response

Health State

curl -X GET 'https://kas.nownodes.io/info/health'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://kas.nownodes.io/info/health')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://kas.nownodes.io/info/health')
data = response.json()

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

const data = await response.json();

const endpoint = "https://kas.nownodes.io/info/health";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

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

const data = await response.json();

import requests

response = requests.get('https://kas.nownodes.io/info/health')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://kas.nownodes.io/info/health')
request = Net::HTTP::Get.new(uri)

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

200

{
  "kaspadServers": [
    {
      "kaspadHost": "string",
      "serverVersion": "0.12.6",
      "isUtxoIndexed": true,
      "isSynced": true,
      "p2pId": "1231312",
      "blueScore": 0
    }
  ],
  "database": {
    "isSynced": true,
    "blueScore": 0,
    "blueScoreDiff": 0,
    "acceptedTxBlockTime": 0,
    "acceptedTxBlockTimeDiff": 0
  }
}

Get Marketcap

GET

https://kas.nownodes.io/info/marketcap

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Get $KAS price and market cap. Price info is from coingecko.com

Parameters

stringOnlybooleanfalsequery

Response

200OK

Successful Response

422Unprocessable Entity

Validation Error

Get Marketcap

curl -X GET 'https://kas.nownodes.io/info/marketcap'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://kas.nownodes.io/info/marketcap')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://kas.nownodes.io/info/marketcap')
data = response.json()

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

const data = await response.json();

const endpoint = "https://kas.nownodes.io/info/marketcap";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

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

const data = await response.json();

import requests

response = requests.get('https://kas.nownodes.io/info/marketcap')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://kas.nownodes.io/info/marketcap')
request = Net::HTTP::Get.new(uri)

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

{
  "marketcap": 12000132
}

{
  "detail": [
    {
      "loc": [
        "string"
      ],
      "msg": "string",
      "type": "string"
    }
  ]
}

Blocks

Get Block

GET

https://kas.nownodes.io/blocks/{blockId}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Get block information for a given block id

Parameters

blockIdstringrequiredpath

includeTransactionsbooleantruequery

includeColorbooleanfalsequery

Response

200OK

Successful Response

422Unprocessable Entity

Validation Error

503Service Unavailable

Service Unavailable: no synced Kaspa node is reachable

Get Block

curl -X GET 'https://kas.nownodes.io/blocks/{blockId}'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://kas.nownodes.io/blocks/{blockId}')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://kas.nownodes.io/blocks/{blockId}')
data = response.json()

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

const data = await response.json();

const endpoint = "https://kas.nownodes.io/blocks/{blockId}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

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

const data = await response.json();

import requests

response = requests.get('https://kas.nownodes.io/blocks/{blockId}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://kas.nownodes.io/blocks/{blockId}')
request = Net::HTTP::Get.new(uri)

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

{
  "header": {
    "version": 1,
    "hashMerkleRoot": "e6641454e16cff4f232b899564eeaa6e480b66069d87bee6a2b2476e63fcd887",
    "acceptedIdMerkleRoot": "9bab45b027a0b2b47135b6f6f866e5e4040fc1fdf2fe56eb0c90a603ce86092b",
    "utxoCommitment": "236d5f9ffd19b317a97693322c3e2ae11a44b5df803d71f1ccf6c2393bc6143c",
    "timestamp": "1656450648874",
    "bits": 455233226,
    "nonce": "14797571275553019490",
    "daaScore": "19984482",
    "blueWork": "2d1b3f04f8a0dcd31",
    "parents": [
      {
        "parentHashes": [
          "580f65c8da9d436480817f6bd7c13eecd9223b37f0d34ae42fb17e1e9fda397e"
        ]
      }
    ],
    "blueScore": "18483232",
    "pruningPoint": "5d32a9403273a34b6551b84340a1459ddde2ae6ba59a47987a6374340ba41d5d"
  },
  "transactions": [
    {
      "inputs": [
        {
          "previousOutpoint": {
            "transactionId": "string",
            "index": 0
          },
          "signatureScript": "string",
          "sigOpCount": 0,
          "sequence": 0
        }
      ],
      "outputs": [
        {
          "amount": 0,
          "scriptPublicKey": {
            "scriptPublicKey": "string",
            "version": 0
          },
          "verboseData": {
            "scriptPublicKeyType": "string",
            "scriptPublicKeyAddress": "string"
          }
        }
      ],
      "subnetworkId": "string",
      "payload": "string",
      "verboseData": {
        "transactionId": "string",
        "hash": "string",
        "computeMass": 0,
        "blockHash": "string",
        "blockTime": 0
      },
      "lockTime": 0,
      "gas": 0,
      "mass": 0,
      "version": 0
    }
  ],
  "verboseData": {
    "hash": "18c7afdf8f447ca06adb8b4946dc45f5feb1188c7d177da6094dfbc760eca699",
    "difficulty": 4102204523252.94,
    "selectedParentHash": "580f65c8da9d436480817f6bd7c13eecd9223b37f0d34ae42fb17e1e9fda397e",
    "transactionIds": [
      "533f8314bf772259fe517f53507a79ebe61c8c6a11748d93a0835551233b3311"
    ],
    "blueScore": "18483232",
    "childrenHashes": [
      "string"
    ],
    "mergeSetBluesHashes": [],
    "mergeSetRedsHashes": [],
    "isChainBlock": false
  },
  "extra": {
    "color": "string",
    "minerAddress": "string",
    "minerInfo": "string"
  }
}

{
  "detail": [
    {
      "loc": [
        "string"
      ],
      "msg": "string",
      "type": "string"
    }
  ]
}

{
  "detail": "Kaspad unavailable"
}

Get Blocks

GET

https://kas.nownodes.io/blocks

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Lists block beginning from a low hash (block id).

Parameters

lowHashstringrequiredquery

includeBlocksbooleanfalsequery

includeTransactionsbooleanfalsequery

Response

200OK

Successful Response

422Unprocessable Entity

Validation Error

503Service Unavailable

Service Unavailable: no synced Kaspa node is reachable

Get Blocks

curl -X GET 'https://kas.nownodes.io/blocks'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://kas.nownodes.io/blocks')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://kas.nownodes.io/blocks')
data = response.json()

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

const data = await response.json();

const endpoint = "https://kas.nownodes.io/blocks";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

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

const data = await response.json();

import requests

response = requests.get('https://kas.nownodes.io/blocks')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://kas.nownodes.io/blocks')
request = Net::HTTP::Get.new(uri)

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

{
  "blockHashes": [
    "44edf9bfd32aa154bfad64485882f184372b64bd60565ba121b42fc3cb1238f3",
    "18c7afdf8f447ca06adb8b4946dc45f5feb1188c7d177da6094dfbc760eca699",
    "9a822351cd293a653f6721afec1646bd1690da7124b5fbe87001711406010604",
    "2fda0dad4ec879b4ad02ebb68c757955cab305558998129a7de111ab852e7dcb"
  ],
  "blocks": [
    {
      "header": {
        "version": 1,
        "hashMerkleRoot": "e6641454e16cff4f232b899564eeaa6e480b66069d87bee6a2b2476e63fcd887",
        "acceptedIdMerkleRoot": "9bab45b027a0b2b47135b6f6f866e5e4040fc1fdf2fe56eb0c90a603ce86092b",
        "utxoCommitment": "236d5f9ffd19b317a97693322c3e2ae11a44b5df803d71f1ccf6c2393bc6143c",
        "timestamp": "1656450648874",
        "bits": 455233226,
        "nonce": "14797571275553019490",
        "daaScore": "19984482",
        "blueWork": "2d1b3f04f8a0dcd31",
        "parents": [
          {
            "parentHashes": [
              "580f65c8da9d436480817f6bd7c13eecd9223b37f0d34ae42fb17e1e9fda397e"
            ]
          }
        ],
        "blueScore": "18483232",
        "pruningPoint": "5d32a9403273a34b6551b84340a1459ddde2ae6ba59a47987a6374340ba41d5d"
      },
      "transactions": [
        {
          "inputs": [
            {
              "previousOutpoint": {
                "transactionId": "string",
                "index": 0
              },
              "signatureScript": "string",
              "sigOpCount": 0,
              "sequence": 0
            }
          ],
          "outputs": [
            {
              "amount": 0,
              "scriptPublicKey": {
                "scriptPublicKey": "string",
                "version": 0
              },
              "verboseData": {
                "scriptPublicKeyType": "string",
                "scriptPublicKeyAddress": "string"
              }
            }
          ],
          "subnetworkId": "string",
          "payload": "string",
          "verboseData": {
            "transactionId": "string",
            "hash": "string",
            "computeMass": 0,
            "blockHash": "string",
            "blockTime": 0
          },
          "lockTime": 0,
          "gas": 0,
          "mass": 0,
          "version": 0
        }
      ],
      "verboseData": {
        "hash": "18c7afdf8f447ca06adb8b4946dc45f5feb1188c7d177da6094dfbc760eca699",
        "difficulty": 4102204523252.94,
        "selectedParentHash": "580f65c8da9d436480817f6bd7c13eecd9223b37f0d34ae42fb17e1e9fda397e",
        "transactionIds": [
          "533f8314bf772259fe517f53507a79ebe61c8c6a11748d93a0835551233b3311"
        ],
        "blueScore": "18483232",
        "childrenHashes": [
          "string"
        ],
        "mergeSetBluesHashes": [],
        "mergeSetRedsHashes": [],
        "isChainBlock": false
      },
      "extra": {
        "color": "string",
        "minerAddress": "string",
        "minerInfo": "string"
      }
    }
  ]
}

{
  "detail": [
    {
      "loc": [
        "string"
      ],
      "msg": "string",
      "type": "string"
    }
  ]
}

{
  "detail": "Kaspad unavailable"
}

Get Blocks From Bluescore

GET

https://kas.nownodes.io/blocks-from-bluescore

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Lists blocks of a given blueScore

Parameters

blueScoreinteger43679173query

includeTransactionsbooleanfalsequery

Response

200OK

Successful Response

422Unprocessable Entity

Validation Error

503Service Unavailable

Service Unavailable: no synced Kaspa node is reachable

Get Blocks From Bluescore

curl -X GET 'https://kas.nownodes.io/blocks-from-bluescore'

const response = await fetch('https://kas.nownodes.io/blocks-from-bluescore', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://kas.nownodes.io/blocks-from-bluescore')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://kas.nownodes.io/blocks-from-bluescore')
data = response.json()

const response = await fetch('https://kas.nownodes.io/blocks-from-bluescore', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://kas.nownodes.io/blocks-from-bluescore";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://kas.nownodes.io/blocks-from-bluescore', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://kas.nownodes.io/blocks-from-bluescore')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://kas.nownodes.io/blocks-from-bluescore')
request = Net::HTTP::Get.new(uri)

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

[
  {
    "header": {
      "version": 1,
      "hashMerkleRoot": "e6641454e16cff4f232b899564eeaa6e480b66069d87bee6a2b2476e63fcd887",
      "acceptedIdMerkleRoot": "9bab45b027a0b2b47135b6f6f866e5e4040fc1fdf2fe56eb0c90a603ce86092b",
      "utxoCommitment": "236d5f9ffd19b317a97693322c3e2ae11a44b5df803d71f1ccf6c2393bc6143c",
      "timestamp": "1656450648874",
      "bits": 455233226,
      "nonce": "14797571275553019490",
      "daaScore": "19984482",
      "blueWork": "2d1b3f04f8a0dcd31",
      "parents": [
        {
          "parentHashes": [
            "580f65c8da9d436480817f6bd7c13eecd9223b37f0d34ae42fb17e1e9fda397e"
          ]
        }
      ],
      "blueScore": "18483232",
      "pruningPoint": "5d32a9403273a34b6551b84340a1459ddde2ae6ba59a47987a6374340ba41d5d"
    },
    "transactions": [
      {
        "inputs": [
          {
            "previousOutpoint": {
              "transactionId": "string",
              "index": 0
            },
            "signatureScript": "string",
            "sigOpCount": 0,
            "sequence": 0
          }
        ],
        "outputs": [
          {
            "amount": 0,
            "scriptPublicKey": {
              "scriptPublicKey": "string",
              "version": 0
            },
            "verboseData": {
              "scriptPublicKeyType": "string",
              "scriptPublicKeyAddress": "string"
            }
          }
        ],
        "subnetworkId": "string",
        "payload": "string",
        "verboseData": {
          "transactionId": "string",
          "hash": "string",
          "computeMass": 0,
          "blockHash": "string",
          "blockTime": 0
        },
        "lockTime": 0,
        "gas": 0,
        "mass": 0,
        "version": 0
      }
    ],
    "verboseData": {
      "hash": "18c7afdf8f447ca06adb8b4946dc45f5feb1188c7d177da6094dfbc760eca699",
      "difficulty": 4102204523252.94,
      "selectedParentHash": "580f65c8da9d436480817f6bd7c13eecd9223b37f0d34ae42fb17e1e9fda397e",
      "transactionIds": [
        "533f8314bf772259fe517f53507a79ebe61c8c6a11748d93a0835551233b3311"
      ],
      "blueScore": "18483232",
      "childrenHashes": [
        "string"
      ],
      "mergeSetBluesHashes": [],
      "mergeSetRedsHashes": [],
      "isChainBlock": false
    },
    "extra": {
      "color": "string",
      "minerAddress": "string",
      "minerInfo": "string"
    }
  }
]

{
  "detail": [
    {
      "loc": [
        "string"
      ],
      "msg": "string",
      "type": "string"
    }
  ]
}

{
  "detail": "Kaspad unavailable"
}

Transactions

Get Transaction

GET

https://kas.nownodes.io/transactions/{transactionId}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Get details for a given transaction id

Parameters

transactionIdstringrequiredpath

blockHashstringquery

Specify a containing block (if known) for faster lookup

inputsbooleantruequery

outputsbooleantruequery

resolve_previous_outpointsPreviousOutpointLookupModenoquery

Use this parameter if you want to fetch the TransactionInput previous outpoint details. Light fetches only the address and amount. Full fetches the whole TransactionOutput and adds it into each TxInput.

Response

200OK

Successful Response

422Unprocessable Entity

Validation Error

Get Transaction

curl -X GET 'https://kas.nownodes.io/transactions/{transactionId}'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://kas.nownodes.io/transactions/{transactionId}')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://kas.nownodes.io/transactions/{transactionId}')
data = response.json()

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

const data = await response.json();

const endpoint = "https://kas.nownodes.io/transactions/{transactionId}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

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

const data = await response.json();

import requests

response = requests.get('https://kas.nownodes.io/transactions/{transactionId}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://kas.nownodes.io/transactions/{transactionId}')
request = Net::HTTP::Get.new(uri)

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

{
  "subnetwork_id": "string",
  "transaction_id": "string",
  "hash": "string",
  "mass": "string",
  "payload": "string",
  "block_hash": [
    "string"
  ],
  "block_time": 0,
  "is_accepted": true,
  "accepting_block_hash": "string",
  "accepting_block_blue_score": 0,
  "accepting_block_time": 0,
  "inputs": [
    {
      "transaction_id": "string",
      "index": 0,
      "previous_outpoint_hash": "string",
      "previous_outpoint_index": "string",
      "previous_outpoint_resolved": {
        "transaction_id": "string",
        "index": 0,
        "amount": 0,
        "script_public_key": "string",
        "script_public_key_address": "string",
        "script_public_key_type": "string",
        "accepting_block_hash": "string"
      },
      "previous_outpoint_address": "string",
      "previous_outpoint_amount": 0,
      "signature_script": "string",
      "sig_op_count": "string"
    }
  ],
  "outputs": [
    {
      "transaction_id": "string",
      "index": 0,
      "amount": 0,
      "script_public_key": "string",
      "script_public_key_address": "string",
      "script_public_key_type": "string",
      "accepting_block_hash": "string"
    }
  ]
}

{
  "detail": [
    {
      "loc": [
        "string"
      ],
      "msg": "string",
      "type": "string"
    }
  ]
}

Search For Transactions

POST

https://kas.nownodes.io/transactions/search

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Search for transactions by transaction_ids or blue_score

Body

application/json

transactionIdsArray<string>

acceptingBlueScoresTxSearchAcceptingBlueScores

Show child attributes

gteintegerrequired

ltintegerrequired

Parameters

fieldsstringquery

resolve_previous_outpointsPreviousOutpointLookupModenoquery

acceptanceAcceptanceModequery

Only used when searching using transactionIds

Response

200OK

Successful Response

422Unprocessable Entity

Validation Error

Search For Transactions

curl -X POST 'https://kas.nownodes.io/transactions/search' \
  -H 'Content-Type: application/json' \
  -d '{
    "transactionIds": [
      "string"
    ],
    "acceptingBlueScores": {
      "gte": 0,
      "lt": 0
    }
  }'

const response = await fetch('https://kas.nownodes.io/transactions/search', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "transactionIds": [
        "string"
      ],
      "acceptingBlueScores": {
        "gte": 0,
        "lt": 0
      }
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://kas.nownodes.io/transactions/search')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "transactionIds": [
      "string"
    ],
    "acceptingBlueScores": {
      "gte": 0,
      "lt": 0
    }
  }'

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

import requests

payload = {
  "transactionIds": [
    "string"
  ],
  "acceptingBlueScores": {
    "gte": 0,
    "lt": 0
  }
}

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

const response = await fetch('https://kas.nownodes.io/transactions/search', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "transactionIds": [
        "string"
      ],
      "acceptingBlueScores": {
        "gte": 0,
        "lt": 0
      }
    }),
});

const data = await response.json();

const endpoint = "https://kas.nownodes.io/transactions/search";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({
    "transactionIds": [
      "string"
    ],
    "acceptingBlueScores": {
      "gte": 0,
      "lt": 0
    }
  });
console.log(result);

const response = await fetch('https://kas.nownodes.io/transactions/search', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "transactionIds": [
        "string"
      ],
      "acceptingBlueScores": {
        "gte": 0,
        "lt": 0
      }
    }),
});

const data = await response.json();

import requests

payload = {
  "transactionIds": [
    "string"
  ],
  "acceptingBlueScores": {
    "gte": 0,
    "lt": 0
  }
}

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

require 'net/http'
require 'json'

uri = URI('https://kas.nownodes.io/transactions/search')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "transactionIds": [
      "string"
    ],
    "acceptingBlueScores": {
      "gte": 0,
      "lt": 0
    }
  }'

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

Request Body

{
  "transactionIds": [
    "string"
  ],
  "acceptingBlueScores": {
    "gte": 0,
    "lt": 0
  }
}

[
  {
    "subnetwork_id": "string",
    "transaction_id": "string",
    "hash": "string",
    "mass": "string",
    "payload": "string",
    "block_hash": [
      "string"
    ],
    "block_time": 0,
    "is_accepted": true,
    "accepting_block_hash": "string",
    "accepting_block_blue_score": 0,
    "accepting_block_time": 0,
    "inputs": [
      {
        "transaction_id": "string",
        "index": 0,
        "previous_outpoint_hash": "string",
        "previous_outpoint_index": "string",
        "previous_outpoint_resolved": {
          "transaction_id": "string",
          "index": 0,
          "amount": 0,
          "script_public_key": "string",
          "script_public_key_address": "string",
          "script_public_key_type": "string",
          "accepting_block_hash": "string"
        },
        "previous_outpoint_address": "string",
        "previous_outpoint_amount": 0,
        "signature_script": "string",
        "sig_op_count": "string"
      }
    ],
    "outputs": [
      {
        "transaction_id": "string",
        "index": 0,
        "amount": 0,
        "script_public_key": "string",
        "script_public_key_address": "string",
        "script_public_key_type": "string",
        "accepting_block_hash": "string"
      }
    ]
  }
]

{
  "detail": [
    {
      "loc": [
        "string"
      ],
      "msg": "string",
      "type": "string"
    }
  ]
}

Get Transaction Acceptance

POST

https://kas.nownodes.io/transactions/acceptance

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Given a list of transaction_ids, return whether each one is accepted and the accepting blue score.

Body

application/json

transactionIdsArray<string>required

Response

200OK

Successful Response

422Unprocessable Entity

Validation Error

Get Transaction Acceptance

curl -X POST 'https://kas.nownodes.io/transactions/acceptance' \
  -H 'Content-Type: application/json' \
  -d '{
    "transactionIds": [
      "b9382bdee4aa364acf73eda93914eaae61d0e78334d1b8a637ab89ef5e224e41",
      "1e098b3830c994beb28768f7924a38286cec16e85e9757e0dc3574b85f624c34",
      "000ad5138a603aadc25cfcca6b6605d5ff47d8c7be594c9cdd199afa6dc76ac6"
    ]
  }'

const response = await fetch('https://kas.nownodes.io/transactions/acceptance', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "transactionIds": [
        "b9382bdee4aa364acf73eda93914eaae61d0e78334d1b8a637ab89ef5e224e41",
        "1e098b3830c994beb28768f7924a38286cec16e85e9757e0dc3574b85f624c34",
        "000ad5138a603aadc25cfcca6b6605d5ff47d8c7be594c9cdd199afa6dc76ac6"
      ]
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://kas.nownodes.io/transactions/acceptance')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "transactionIds": [
      "b9382bdee4aa364acf73eda93914eaae61d0e78334d1b8a637ab89ef5e224e41",
      "1e098b3830c994beb28768f7924a38286cec16e85e9757e0dc3574b85f624c34",
      "000ad5138a603aadc25cfcca6b6605d5ff47d8c7be594c9cdd199afa6dc76ac6"
    ]
  }'

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

import requests

payload = {
  "transactionIds": [
    "b9382bdee4aa364acf73eda93914eaae61d0e78334d1b8a637ab89ef5e224e41",
    "1e098b3830c994beb28768f7924a38286cec16e85e9757e0dc3574b85f624c34",
    "000ad5138a603aadc25cfcca6b6605d5ff47d8c7be594c9cdd199afa6dc76ac6"
  ]
}

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

const response = await fetch('https://kas.nownodes.io/transactions/acceptance', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "transactionIds": [
        "b9382bdee4aa364acf73eda93914eaae61d0e78334d1b8a637ab89ef5e224e41",
        "1e098b3830c994beb28768f7924a38286cec16e85e9757e0dc3574b85f624c34",
        "000ad5138a603aadc25cfcca6b6605d5ff47d8c7be594c9cdd199afa6dc76ac6"
      ]
    }),
});

const data = await response.json();

const endpoint = "https://kas.nownodes.io/transactions/acceptance";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({
    "transactionIds": [
      "b9382bdee4aa364acf73eda93914eaae61d0e78334d1b8a637ab89ef5e224e41",
      "1e098b3830c994beb28768f7924a38286cec16e85e9757e0dc3574b85f624c34",
      "000ad5138a603aadc25cfcca6b6605d5ff47d8c7be594c9cdd199afa6dc76ac6"
    ]
  });
console.log(result);

const response = await fetch('https://kas.nownodes.io/transactions/acceptance', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "transactionIds": [
        "b9382bdee4aa364acf73eda93914eaae61d0e78334d1b8a637ab89ef5e224e41",
        "1e098b3830c994beb28768f7924a38286cec16e85e9757e0dc3574b85f624c34",
        "000ad5138a603aadc25cfcca6b6605d5ff47d8c7be594c9cdd199afa6dc76ac6"
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "transactionIds": [
    "b9382bdee4aa364acf73eda93914eaae61d0e78334d1b8a637ab89ef5e224e41",
    "1e098b3830c994beb28768f7924a38286cec16e85e9757e0dc3574b85f624c34",
    "000ad5138a603aadc25cfcca6b6605d5ff47d8c7be594c9cdd199afa6dc76ac6"
  ]
}

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

require 'net/http'
require 'json'

uri = URI('https://kas.nownodes.io/transactions/acceptance')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "transactionIds": [
      "b9382bdee4aa364acf73eda93914eaae61d0e78334d1b8a637ab89ef5e224e41",
      "1e098b3830c994beb28768f7924a38286cec16e85e9757e0dc3574b85f624c34",
      "000ad5138a603aadc25cfcca6b6605d5ff47d8c7be594c9cdd199afa6dc76ac6"
    ]
  }'

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

Request Body

{
  "transactionIds": [
    "b9382bdee4aa364acf73eda93914eaae61d0e78334d1b8a637ab89ef5e224e41",
    "1e098b3830c994beb28768f7924a38286cec16e85e9757e0dc3574b85f624c34",
    "000ad5138a603aadc25cfcca6b6605d5ff47d8c7be594c9cdd199afa6dc76ac6"
  ]
}

[
  {
    "transactionId": "b9382bdee4aa364acf73eda93914eaae61d0e78334d1b8a637ab89ef5e224e41",
    "accepted": true,
    "acceptingBlueScore": 0
  }
]

{
  "detail": [
    {
      "loc": [
        "string"
      ],
      "msg": "string",
      "type": "string"
    }
  ]
}

Submit A New Transaction

POST

https://kas.nownodes.io/transactions

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Submit a signed transaction to the Kaspa network and return its transaction id. Both v0 and v1 (Toccata) transactions are supported. For v1, inputs use computeBudget (with sigOpCount 0) and outputs can carry a covenant binding; the transaction can set gas. Both versions accept a hex payload. For v0 transactions the v1-only fields are ignored.

Body

application/json

transactionSubmitTxModelrequired

Show child attributes

versionintegerrequired

inputsArray<SubmitTxInput>required

Show child attributes

previousOutpointSubmitTxOutpointrequired

Show child attributes

transactionIdstringrequired

indexintegerrequired

signatureScriptstringrequired

sequenceintegerrequired

sigOpCountintegerrequired

computeBudgetinteger0

Compute budget of the input (v1 transactions). For v1, sigOpCount must be 0. Ignored for v0.

outputsArray<SubmitTxOutput>required

Show child attributes

amountintegerrequired

scriptPublicKeySubmitTxScriptPublicKeyrequired

Show child attributes

versionintegerrequired

scriptPublicKeystringrequired

covenantSubmitTxCovenantBinding

Covenant binding of an output (v1 transactions).

Show child attributes

authorizingInputintegerrequired

covenantIdstringrequired

lockTimeinteger0

subnetworkIdstring

gasinteger0

Gas (v1 transactions). Forced to 0 for v0.

payloadstring

Hex-encoded transaction payload. Supported for both v0 and v1 transactions.

allowOrphanbooleanfalse

Parameters

replaceByFeebooleanfalsequery

Replace an existing transaction in the mempool

Response

200OK

Successful Response

400Bad Request

Bad Request

422Unprocessable Entity

Validation Error

503Service Unavailable

Service Unavailable: no synced Kaspa node is reachable

Submit A New Transaction

curl -X POST 'https://kas.nownodes.io/transactions' \
  -H 'Content-Type: application/json' \
  -d '{
    "transaction": {
      "version": 0,
      "inputs": [
        {
          "previousOutpoint": {
            "transactionId": "string",
            "index": 0
          },
          "signatureScript": "string",
          "sequence": 0,
          "sigOpCount": 0,
          "computeBudget": 0
        }
      ],
      "outputs": [
        {
          "amount": 0,
          "scriptPublicKey": {
            "version": 0,
            "scriptPublicKey": "string"
          },
          "covenant": {
            "authorizingInput": 0,
            "covenantId": "string"
          }
        }
      ],
      "lockTime": 0,
      "subnetworkId": "string",
      "gas": 0,
      "payload": ""
    },
    "allowOrphan": false
  }'

const response = await fetch('https://kas.nownodes.io/transactions', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "transaction": {
        "version": 0,
        "inputs": [
          {
            "previousOutpoint": {
              "transactionId": "string",
              "index": 0
            },
            "signatureScript": "string",
            "sequence": 0,
            "sigOpCount": 0,
            "computeBudget": 0
          }
        ],
        "outputs": [
          {
            "amount": 0,
            "scriptPublicKey": {
              "version": 0,
              "scriptPublicKey": "string"
            },
            "covenant": {
              "authorizingInput": 0,
              "covenantId": "string"
            }
          }
        ],
        "lockTime": 0,
        "subnetworkId": "string",
        "gas": 0,
        "payload": ""
      },
      "allowOrphan": false
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://kas.nownodes.io/transactions')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "transaction": {
      "version": 0,
      "inputs": [
        {
          "previousOutpoint": {
            "transactionId": "string",
            "index": 0
          },
          "signatureScript": "string",
          "sequence": 0,
          "sigOpCount": 0,
          "computeBudget": 0
        }
      ],
      "outputs": [
        {
          "amount": 0,
          "scriptPublicKey": {
            "version": 0,
            "scriptPublicKey": "string"
          },
          "covenant": {
            "authorizingInput": 0,
            "covenantId": "string"
          }
        }
      ],
      "lockTime": 0,
      "subnetworkId": "string",
      "gas": 0,
      "payload": ""
    },
    "allowOrphan": false
  }'

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

import requests

payload = {
  "transaction": {
    "version": 0,
    "inputs": [
      {
        "previousOutpoint": {
          "transactionId": "string",
          "index": 0
        },
        "signatureScript": "string",
        "sequence": 0,
        "sigOpCount": 0,
        "computeBudget": 0
      }
    ],
    "outputs": [
      {
        "amount": 0,
        "scriptPublicKey": {
          "version": 0,
          "scriptPublicKey": "string"
        },
        "covenant": {
          "authorizingInput": 0,
          "covenantId": "string"
        }
      }
    ],
    "lockTime": 0,
    "subnetworkId": "string",
    "gas": 0,
    "payload": ""
  },
  "allowOrphan": False
}

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

const response = await fetch('https://kas.nownodes.io/transactions', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "transaction": {
        "version": 0,
        "inputs": [
          {
            "previousOutpoint": {
              "transactionId": "string",
              "index": 0
            },
            "signatureScript": "string",
            "sequence": 0,
            "sigOpCount": 0,
            "computeBudget": 0
          }
        ],
        "outputs": [
          {
            "amount": 0,
            "scriptPublicKey": {
              "version": 0,
              "scriptPublicKey": "string"
            },
            "covenant": {
              "authorizingInput": 0,
              "covenantId": "string"
            }
          }
        ],
        "lockTime": 0,
        "subnetworkId": "string",
        "gas": 0,
        "payload": ""
      },
      "allowOrphan": false
    }),
});

const data = await response.json();

const endpoint = "https://kas.nownodes.io/transactions";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({
    "transaction": {
      "version": 0,
      "inputs": [
        {
          "previousOutpoint": {
            "transactionId": "string",
            "index": 0
          },
          "signatureScript": "string",
          "sequence": 0,
          "sigOpCount": 0,
          "computeBudget": 0
        }
      ],
      "outputs": [
        {
          "amount": 0,
          "scriptPublicKey": {
            "version": 0,
            "scriptPublicKey": "string"
          },
          "covenant": {
            "authorizingInput": 0,
            "covenantId": "string"
          }
        }
      ],
      "lockTime": 0,
      "subnetworkId": "string",
      "gas": 0,
      "payload": ""
    },
    "allowOrphan": false
  });
console.log(result);

const response = await fetch('https://kas.nownodes.io/transactions', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "transaction": {
        "version": 0,
        "inputs": [
          {
            "previousOutpoint": {
              "transactionId": "string",
              "index": 0
            },
            "signatureScript": "string",
            "sequence": 0,
            "sigOpCount": 0,
            "computeBudget": 0
          }
        ],
        "outputs": [
          {
            "amount": 0,
            "scriptPublicKey": {
              "version": 0,
              "scriptPublicKey": "string"
            },
            "covenant": {
              "authorizingInput": 0,
              "covenantId": "string"
            }
          }
        ],
        "lockTime": 0,
        "subnetworkId": "string",
        "gas": 0,
        "payload": ""
      },
      "allowOrphan": false
    }),
});

const data = await response.json();

import requests

payload = {
  "transaction": {
    "version": 0,
    "inputs": [
      {
        "previousOutpoint": {
          "transactionId": "string",
          "index": 0
        },
        "signatureScript": "string",
        "sequence": 0,
        "sigOpCount": 0,
        "computeBudget": 0
      }
    ],
    "outputs": [
      {
        "amount": 0,
        "scriptPublicKey": {
          "version": 0,
          "scriptPublicKey": "string"
        },
        "covenant": {
          "authorizingInput": 0,
          "covenantId": "string"
        }
      }
    ],
    "lockTime": 0,
    "subnetworkId": "string",
    "gas": 0,
    "payload": ""
  },
  "allowOrphan": False
}

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

require 'net/http'
require 'json'

uri = URI('https://kas.nownodes.io/transactions')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "transaction": {
      "version": 0,
      "inputs": [
        {
          "previousOutpoint": {
            "transactionId": "string",
            "index": 0
          },
          "signatureScript": "string",
          "sequence": 0,
          "sigOpCount": 0,
          "computeBudget": 0
        }
      ],
      "outputs": [
        {
          "amount": 0,
          "scriptPublicKey": {
            "version": 0,
            "scriptPublicKey": "string"
          },
          "covenant": {
            "authorizingInput": 0,
            "covenantId": "string"
          }
        }
      ],
      "lockTime": 0,
      "subnetworkId": "string",
      "gas": 0,
      "payload": ""
    },
    "allowOrphan": false
  }'

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

Request Body

{
  "transaction": {
    "version": 0,
    "inputs": [
      {
        "previousOutpoint": {
          "transactionId": "string",
          "index": 0
        },
        "signatureScript": "string",
        "sequence": 0,
        "sigOpCount": 0,
        "computeBudget": 0
      }
    ],
    "outputs": [
      {
        "amount": 0,
        "scriptPublicKey": {
          "version": 0,
          "scriptPublicKey": "string"
        },
        "covenant": {
          "authorizingInput": 0,
          "covenantId": "string"
        }
      }
    ],
    "lockTime": 0,
    "subnetworkId": "string",
    "gas": 0,
    "payload": ""
  },
  "allowOrphan": false
}

{
  "transactionId": "string",
  "error": "string"
}

{
  "transactionId": "string",
  "error": "string"
}

{
  "detail": [
    {
      "loc": [
        "string"
      ],
      "msg": "string",
      "type": "string"
    }
  ]
}

{
  "detail": "Kaspad unavailable"
}

Calculate Transaction Mass

POST

https://kas.nownodes.io/transactions/mass

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

This function calculates and returns the mass of a transaction, which is essential for determining the minimum fee. The returned mass is the largest of the compute mass, the storage mass as defined in KIP-0009 and the normalized transient mass, for both v0 and v1 transactions.

Note: Be aware that if the transaction has a very low output amount or a high number of outputs, the mass can become significantly large.

Body

application/json

versionintegerrequired

inputsArray<SubmitTxInput>required

Show child attributes

previousOutpointSubmitTxOutpointrequired

Show child attributes

transactionIdstringrequired

indexintegerrequired

signatureScriptstringrequired

sequenceintegerrequired

sigOpCountintegerrequired

computeBudgetinteger0

Compute budget of the input (v1 transactions). For v1, sigOpCount must be 0. Ignored for v0.

outputsArray<SubmitTxOutput>required

Show child attributes

amountintegerrequired

scriptPublicKeySubmitTxScriptPublicKeyrequired

Show child attributes

versionintegerrequired

scriptPublicKeystringrequired

covenantSubmitTxCovenantBinding

Covenant binding of an output (v1 transactions).

Show child attributes

authorizingInputintegerrequired

covenantIdstringrequired

lockTimeinteger0

subnetworkIdstring

gasinteger0

Gas (v1 transactions). Forced to 0 for v0.

payloadstring

Hex-encoded transaction payload. Supported for both v0 and v1 transactions.

Response

200OK

Successful Response

422Unprocessable Entity

Validation Error

Calculate Transaction Mass

curl -X POST 'https://kas.nownodes.io/transactions/mass' \
  -H 'Content-Type: application/json' \
  -d '{
    "version": 0,
    "inputs": [
      {
        "previousOutpoint": {
          "transactionId": "string",
          "index": 0
        },
        "signatureScript": "string",
        "sequence": 0,
        "sigOpCount": 0,
        "computeBudget": 0
      }
    ],
    "outputs": [
      {
        "amount": 0,
        "scriptPublicKey": {
          "version": 0,
          "scriptPublicKey": "string"
        },
        "covenant": {
          "authorizingInput": 0,
          "covenantId": "string"
        }
      }
    ],
    "lockTime": 0,
    "subnetworkId": "string",
    "gas": 0,
    "payload": ""
  }'

const response = await fetch('https://kas.nownodes.io/transactions/mass', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "version": 0,
      "inputs": [
        {
          "previousOutpoint": {
            "transactionId": "string",
            "index": 0
          },
          "signatureScript": "string",
          "sequence": 0,
          "sigOpCount": 0,
          "computeBudget": 0
        }
      ],
      "outputs": [
        {
          "amount": 0,
          "scriptPublicKey": {
            "version": 0,
            "scriptPublicKey": "string"
          },
          "covenant": {
            "authorizingInput": 0,
            "covenantId": "string"
          }
        }
      ],
      "lockTime": 0,
      "subnetworkId": "string",
      "gas": 0,
      "payload": ""
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://kas.nownodes.io/transactions/mass')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "version": 0,
    "inputs": [
      {
        "previousOutpoint": {
          "transactionId": "string",
          "index": 0
        },
        "signatureScript": "string",
        "sequence": 0,
        "sigOpCount": 0,
        "computeBudget": 0
      }
    ],
    "outputs": [
      {
        "amount": 0,
        "scriptPublicKey": {
          "version": 0,
          "scriptPublicKey": "string"
        },
        "covenant": {
          "authorizingInput": 0,
          "covenantId": "string"
        }
      }
    ],
    "lockTime": 0,
    "subnetworkId": "string",
    "gas": 0,
    "payload": ""
  }'

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

import requests

payload = {
  "version": 0,
  "inputs": [
    {
      "previousOutpoint": {
        "transactionId": "string",
        "index": 0
      },
      "signatureScript": "string",
      "sequence": 0,
      "sigOpCount": 0,
      "computeBudget": 0
    }
  ],
  "outputs": [
    {
      "amount": 0,
      "scriptPublicKey": {
        "version": 0,
        "scriptPublicKey": "string"
      },
      "covenant": {
        "authorizingInput": 0,
        "covenantId": "string"
      }
    }
  ],
  "lockTime": 0,
  "subnetworkId": "string",
  "gas": 0,
  "payload": ""
}

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

const response = await fetch('https://kas.nownodes.io/transactions/mass', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "version": 0,
      "inputs": [
        {
          "previousOutpoint": {
            "transactionId": "string",
            "index": 0
          },
          "signatureScript": "string",
          "sequence": 0,
          "sigOpCount": 0,
          "computeBudget": 0
        }
      ],
      "outputs": [
        {
          "amount": 0,
          "scriptPublicKey": {
            "version": 0,
            "scriptPublicKey": "string"
          },
          "covenant": {
            "authorizingInput": 0,
            "covenantId": "string"
          }
        }
      ],
      "lockTime": 0,
      "subnetworkId": "string",
      "gas": 0,
      "payload": ""
    }),
});

const data = await response.json();

const endpoint = "https://kas.nownodes.io/transactions/mass";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({
    "version": 0,
    "inputs": [
      {
        "previousOutpoint": {
          "transactionId": "string",
          "index": 0
        },
        "signatureScript": "string",
        "sequence": 0,
        "sigOpCount": 0,
        "computeBudget": 0
      }
    ],
    "outputs": [
      {
        "amount": 0,
        "scriptPublicKey": {
          "version": 0,
          "scriptPublicKey": "string"
        },
        "covenant": {
          "authorizingInput": 0,
          "covenantId": "string"
        }
      }
    ],
    "lockTime": 0,
    "subnetworkId": "string",
    "gas": 0,
    "payload": ""
  });
console.log(result);

const response = await fetch('https://kas.nownodes.io/transactions/mass', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "version": 0,
      "inputs": [
        {
          "previousOutpoint": {
            "transactionId": "string",
            "index": 0
          },
          "signatureScript": "string",
          "sequence": 0,
          "sigOpCount": 0,
          "computeBudget": 0
        }
      ],
      "outputs": [
        {
          "amount": 0,
          "scriptPublicKey": {
            "version": 0,
            "scriptPublicKey": "string"
          },
          "covenant": {
            "authorizingInput": 0,
            "covenantId": "string"
          }
        }
      ],
      "lockTime": 0,
      "subnetworkId": "string",
      "gas": 0,
      "payload": ""
    }),
});

const data = await response.json();

import requests

payload = {
  "version": 0,
  "inputs": [
    {
      "previousOutpoint": {
        "transactionId": "string",
        "index": 0
      },
      "signatureScript": "string",
      "sequence": 0,
      "sigOpCount": 0,
      "computeBudget": 0
    }
  ],
  "outputs": [
    {
      "amount": 0,
      "scriptPublicKey": {
        "version": 0,
        "scriptPublicKey": "string"
      },
      "covenant": {
        "authorizingInput": 0,
        "covenantId": "string"
      }
    }
  ],
  "lockTime": 0,
  "subnetworkId": "string",
  "gas": 0,
  "payload": ""
}

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

require 'net/http'
require 'json'

uri = URI('https://kas.nownodes.io/transactions/mass')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "version": 0,
    "inputs": [
      {
        "previousOutpoint": {
          "transactionId": "string",
          "index": 0
        },
        "signatureScript": "string",
        "sequence": 0,
        "sigOpCount": 0,
        "computeBudget": 0
      }
    ],
    "outputs": [
      {
        "amount": 0,
        "scriptPublicKey": {
          "version": 0,
          "scriptPublicKey": "string"
        },
        "covenant": {
          "authorizingInput": 0,
          "covenantId": "string"
        }
      }
    ],
    "lockTime": 0,
    "subnetworkId": "string",
    "gas": 0,
    "payload": ""
  }'

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

Request Body

{
  "version": 0,
  "inputs": [
    {
      "previousOutpoint": {
        "transactionId": "string",
        "index": 0
      },
      "signatureScript": "string",
      "sequence": 0,
      "sigOpCount": 0,
      "computeBudget": 0
    }
  ],
  "outputs": [
    {
      "amount": 0,
      "scriptPublicKey": {
        "version": 0,
        "scriptPublicKey": "string"
      },
      "covenant": {
        "authorizingInput": 0,
        "covenantId": "string"
      }
    }
  ],
  "lockTime": 0,
  "subnetworkId": "string",
  "gas": 0,
  "payload": ""
}

{
  "mass": 0,
  "storage_mass": 0,
  "compute_mass": 0
}

{
  "detail": [
    {
      "loc": [
        "string"
      ],
      "msg": "string",
      "type": "string"
    }
  ]
}

Virtual chain

Get Virtual Chain Transactions

GET

https://kas.nownodes.io/virtual-chain

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

EXPERIMENTAL - EXPECT BREAKING CHANGES: Get virtual chain transactions by blue score.

Parameters

blueScoreGteinteger>= 0requiredquery

Divisible by limit

limitinteger1010010query

resolveInputsbooleanfalsequery

includeCoinbasebooleantruequery

Response

200OK

Successful Response

422Unprocessable Entity

Validation Error

Get Virtual Chain Transactions

curl -X GET 'https://kas.nownodes.io/virtual-chain'

const response = await fetch('https://kas.nownodes.io/virtual-chain', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://kas.nownodes.io/virtual-chain')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://kas.nownodes.io/virtual-chain')
data = response.json()

const response = await fetch('https://kas.nownodes.io/virtual-chain', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://kas.nownodes.io/virtual-chain";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest({});
console.log(result);

const response = await fetch('https://kas.nownodes.io/virtual-chain', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://kas.nownodes.io/virtual-chain')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://kas.nownodes.io/virtual-chain')
request = Net::HTTP::Get.new(uri)

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

[
  {
    "hash": "string",
    "blue_score": 0,
    "daa_score": 0,
    "timestamp": 0,
    "transactions": [
      {
        "transaction_id": "string",
        "is_accepted": true,
        "inputs": [
          {
            "previous_outpoint_hash": "string",
            "previous_outpoint_index": 0,
            "previous_outpoint_script": "string",
            "previous_outpoint_address": "string",
            "previous_outpoint_amount": 0
          }
        ],
        "outputs": [
          {
            "script_public_key": "string",
            "script_public_key_address": "string",
            "amount": 0
          }
        ]
      }
    ]
  }
]

{
  "detail": [
    {
      "loc": [
        "string"
      ],
      "msg": "string",
      "type": "string"
    }
  ]
}