Alephium API

v3.3.0

Base URL

https://alephium.nownodes.io

Authentication

api-keyAuthapiKey

API Key: api-key in header

Node

Infos

Get basic ALPH node information

GET

https://alephium.nownodes.io/infos/node

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the build version, commit hash, UPnP configuration, and the external address (if available) of the ALPH node.

Response

200OK

Node information retrieved successfully.

400Bad Request

BadRequest

401Unauthorized

Unauthorized

404Not Found

NotFound

500Internal Server Error

InternalServerError

503Service Unavailable

ServiceUnavailable

Get basic ALPH node information

curl -X GET 'https://alephium.nownodes.io/infos/node'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/infos/node')
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://alephium.nownodes.io/infos/node')
data = response.json()

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

const data = await response.json();

const endpoint = "https://alephium.nownodes.io/infos/node";
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://alephium.nownodes.io/infos/node', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://alephium.nownodes.io/infos/node')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/infos/node')
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)

{
  "buildInfo": {
    "releaseVersion": "4.0.4",
    "commit": "cdcf3e2a09e4414729de08b21c7087992b98eb18"
  },
  "upnp": true,
  "externalAddress": null
}

{
  "detail": "string"
}

{
  "detail": "string"
}

{
  "resource": "wallet-name",
  "detail": "wallet-name not found"
}

{
  "detail": "string"
}

{
  "detail": "string"
}

Get ALPH Node Software Version

GET

https://alephium.nownodes.io/infos/version

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the current version of the ALPH node software.

Response

200OK

Version information retrieved successfully.

400Bad Request

BadRequest

401Unauthorized

Unauthorized

404Not Found

NotFound

500Internal Server Error

InternalServerError

503Service Unavailable

ServiceUnavailable

Get ALPH Node Software Version

curl -X GET 'https://alephium.nownodes.io/infos/version'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/infos/version')
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://alephium.nownodes.io/infos/version')
data = response.json()

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

const data = await response.json();

const endpoint = "https://alephium.nownodes.io/infos/version";
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://alephium.nownodes.io/infos/version', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://alephium.nownodes.io/infos/version')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/infos/version')
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)

{
  "version": "v4.0.4"
}

{
  "detail": "string"
}

{
  "detail": "string"
}

{
  "resource": "wallet-name",
  "detail": "wallet-name not found"
}

{
  "detail": "string"
}

{
  "detail": "string"
}

Get Chain Parameters

GET

https://alephium.nownodes.io/infos/chain-params

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns various blockchain configuration parameters used by the ALPH node.

Response

200OK

Chain parameters retrieved successfully.

400Bad Request

BadRequest

401Unauthorized

Unauthorized

404Not Found

NotFound

500Internal Server Error

InternalServerError

503Service Unavailable

ServiceUnavailable

Get Chain Parameters

curl -X GET 'https://alephium.nownodes.io/infos/chain-params'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/infos/chain-params')
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://alephium.nownodes.io/infos/chain-params')
data = response.json()

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

const data = await response.json();

const endpoint = "https://alephium.nownodes.io/infos/chain-params";
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://alephium.nownodes.io/infos/chain-params', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://alephium.nownodes.io/infos/chain-params')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/infos/chain-params')
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)

{
  "networkId": 0,
  "numZerosAtLeastInHash": 37,
  "groupNumPerBroker": 4,
  "groups": 4
}

{
  "detail": "string"
}

{
  "detail": "string"
}

{
  "resource": "wallet-name",
  "detail": "wallet-name not found"
}

{
  "detail": "string"
}

{
  "detail": "string"
}

Get Self Clique Information

GET

https://alephium.nownodes.io/infos/self-clique

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns information about the current node's clique, including clique ID, participating nodes, and sync status.

Response

200OK

Self clique information retrieved successfully.

400Bad Request

BadRequest

401Unauthorized

Unauthorized

404Not Found

NotFound

500Internal Server Error

InternalServerError

503Service Unavailable

ServiceUnavailable

Get Self Clique Information

curl -X GET 'https://alephium.nownodes.io/infos/self-clique'

const response = await fetch('https://alephium.nownodes.io/infos/self-clique', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/infos/self-clique')
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://alephium.nownodes.io/infos/self-clique')
data = response.json()

const response = await fetch('https://alephium.nownodes.io/infos/self-clique', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://alephium.nownodes.io/infos/self-clique";
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://alephium.nownodes.io/infos/self-clique', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://alephium.nownodes.io/infos/self-clique')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/infos/self-clique')
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)

{
  "cliqueId": "0272a124586f31dbe068b953fb2214657f4747f109d2e9b15c36cb222082979067",
  "nodes": [
    {
      "address": "0.0.0.0",
      "restPort": 12973,
      "wsPort": 11973,
      "minerApiPort": 10973
    }
  ],
  "selfReady": true,
  "synced": true
}

{
  "detail": "string"
}

{
  "detail": "string"
}

{
  "resource": "wallet-name",
  "detail": "wallet-name not found"
}

{
  "detail": "string"
}

{
  "detail": "string"
}

Get Inter-Clique Peer Information

GET

https://alephium.nownodes.io/infos/inter-clique-peer-info

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of peers from other cliques that the node is aware of, including their clique IDs, sync status, and client version.

Response

200OK

Peer information retrieved successfully.

400Bad Request

BadRequest

401Unauthorized

Unauthorized

404Not Found

NotFound

500Internal Server Error

InternalServerError

503Service Unavailable

ServiceUnavailable

Get Inter-Clique Peer Information

curl -X GET 'https://alephium.nownodes.io/infos/inter-clique-peer-info'

const response = await fetch('https://alephium.nownodes.io/infos/inter-clique-peer-info', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/infos/inter-clique-peer-info')
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://alephium.nownodes.io/infos/inter-clique-peer-info')
data = response.json()

const response = await fetch('https://alephium.nownodes.io/infos/inter-clique-peer-info', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://alephium.nownodes.io/infos/inter-clique-peer-info";
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://alephium.nownodes.io/infos/inter-clique-peer-info', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://alephium.nownodes.io/infos/inter-clique-peer-info')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/infos/inter-clique-peer-info')
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)

[
  {
    "cliqueId": "03de24c07d2e742cd4ad4053e1a3234d198bc6a076432d9cca5f654792074dd96f",
    "brokerId": 0,
    "groupNumPerBroker": 4,
    "address": {
      "addr": "139.99.16.105",
      "port": 9973
    },
    "isSynced": true,
    "clientVersion": "scala-alephium/v4.0.4/Linux/p2p-v2"
  }
]

{
  "detail": "string"
}

{
  "detail": "string"
}

{
  "resource": "wallet-name",
  "detail": "wallet-name not found"
}

{
  "detail": "string"
}

{
  "detail": "string"
}

Get Discovered Neighboring Peers

GET

https://alephium.nownodes.io/infos/discovered-neighbors

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of discovered neighbors from other cliques, including their clique ID, broker ID, broker number, and network address.

Response

200OK

Discovered neighbors retrieved successfully.

400Bad Request

BadRequest

401Unauthorized

Unauthorized

404Not Found

NotFound

500Internal Server Error

InternalServerError

503Service Unavailable

ServiceUnavailable

Get Discovered Neighboring Peers

curl -X GET 'https://alephium.nownodes.io/infos/discovered-neighbors'

const response = await fetch('https://alephium.nownodes.io/infos/discovered-neighbors', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/infos/discovered-neighbors')
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://alephium.nownodes.io/infos/discovered-neighbors')
data = response.json()

const response = await fetch('https://alephium.nownodes.io/infos/discovered-neighbors', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://alephium.nownodes.io/infos/discovered-neighbors";
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://alephium.nownodes.io/infos/discovered-neighbors', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://alephium.nownodes.io/infos/discovered-neighbors')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/infos/discovered-neighbors')
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)

[
  {
    "cliqueId": "037e0a046eda3de8e42cfe2bdebea7033bb779d99efa7b9c36b2c940695eb21942",
    "brokerId": 0,
    "brokerNum": 1,
    "address": {
      "addr": "195.154.210.36",
      "port": 19140
    }
  }
]

{
  "detail": "string"
}

{
  "detail": "string"
}

{
  "resource": "wallet-name",
  "detail": "wallet-name not found"
}

{
  "detail": "string"
}

{
  "detail": "string"
}

Get Misbehaving Peers

GET

https://alephium.nownodes.io/infos/misbehaviors

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of peers that have been flagged for misbehavior, including their status and ban information.

Response

200OK

Misbehaving peer list retrieved successfully.

400Bad Request

BadRequest

401Unauthorized

Unauthorized

404Not Found

NotFound

500Internal Server Error

InternalServerError

503Service Unavailable

ServiceUnavailable

Get Misbehaving Peers

curl -X GET 'https://alephium.nownodes.io/infos/misbehaviors'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/infos/misbehaviors')
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://alephium.nownodes.io/infos/misbehaviors')
data = response.json()

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

const data = await response.json();

const endpoint = "https://alephium.nownodes.io/infos/misbehaviors";
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://alephium.nownodes.io/infos/misbehaviors', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://alephium.nownodes.io/infos/misbehaviors')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/infos/misbehaviors')
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)

[
  {
    "peer": "77.223.102.9",
    "status": {
      "type": "Banned",
      "until": 1754943461295
    }
  }
]

{
  "detail": "string"
}

{
  "detail": "string"
}

{
  "resource": "wallet-name",
  "detail": "wallet-name not found"
}

{
  "detail": "string"
}

{
  "detail": "string"
}

Get Unreachable Peers

GET

https://alephium.nownodes.io/infos/unreachable

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of peer IP addresses that are currently unreachable from this node.

Response

200OK

List of unreachable peers retrieved successfully.

400Bad Request

BadRequest

401Unauthorized

Unauthorized

404Not Found

NotFound

500Internal Server Error

InternalServerError

503Service Unavailable

ServiceUnavailable

Get Unreachable Peers

curl -X GET 'https://alephium.nownodes.io/infos/unreachable'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/infos/unreachable')
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://alephium.nownodes.io/infos/unreachable')
data = response.json()

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

const data = await response.json();

const endpoint = "https://alephium.nownodes.io/infos/unreachable";
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://alephium.nownodes.io/infos/unreachable', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://alephium.nownodes.io/infos/unreachable')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/infos/unreachable')
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)

[
  "77.223.102.9"
]

{
  "detail": "string"
}

{
  "detail": "string"
}

{
  "resource": "wallet-name",
  "detail": "wallet-name not found"
}

{
  "detail": "string"
}

{
  "detail": "string"
}

Get Historical Hashrate Summary

GET

https://alephium.nownodes.io/infos/history-hashrate

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a summary string representing the node's hashrate over the specified time range.

Parameters

fromTsinteger<int64>requiredquery

Start timestamp (Unix ms) for the requested hashrate history.

toTsinteger<int64>requiredquery

End timestamp (Unix ms) for the requested hashrate history.

Response

200OK

Historical hashrate summary retrieved successfully.

400Bad Request

Invalid or missing query parameters.

401Unauthorized

Unauthorized

404Not Found

NotFound

500Internal Server Error

InternalServerError

503Service Unavailable

ServiceUnavailable

Get Historical Hashrate Summary

curl -X GET 'https://alephium.nownodes.io/infos/history-hashrate'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/infos/history-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://alephium.nownodes.io/infos/history-hashrate')
data = response.json()

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

const data = await response.json();

const endpoint = "https://alephium.nownodes.io/infos/history-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://alephium.nownodes.io/infos/history-hashrate', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://alephium.nownodes.io/infos/history-hashrate')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/infos/history-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": "0 MH/s"
}

{
  "error": "Missing or invalid fromTs/toTs parameters"
}

{
  "detail": "string"
}

{
  "resource": "wallet-name",
  "detail": "wallet-name not found"
}

{
  "detail": "string"
}

{
  "detail": "string"
}

Get Current Hashrate

GET

https://alephium.nownodes.io/infos/current-hashrate

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the current hashrate of the node as a string with units.

Response

200OK

Current hashrate retrieved successfully.

400Bad Request

BadRequest

401Unauthorized

Unauthorized

404Not Found

NotFound

500Internal Server Error

InternalServerError

503Service Unavailable

ServiceUnavailable

Get Current Hashrate

curl -X GET 'https://alephium.nownodes.io/infos/current-hashrate'

const response = await fetch('https://alephium.nownodes.io/infos/current-hashrate', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/infos/current-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://alephium.nownodes.io/infos/current-hashrate')
data = response.json()

const response = await fetch('https://alephium.nownodes.io/infos/current-hashrate', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://alephium.nownodes.io/infos/current-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://alephium.nownodes.io/infos/current-hashrate', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://alephium.nownodes.io/infos/current-hashrate')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/infos/current-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": "19812439796 MH/s"
}

{
  "detail": "string"
}

{
  "detail": "string"
}

{
  "resource": "wallet-name",
  "detail": "wallet-name not found"
}

{
  "detail": "string"
}

{
  "detail": "string"
}

Get Current Difficulty

GET

https://alephium.nownodes.io/infos/current-difficulty

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the current network difficulty as a string.

Response

200OK

Current difficulty retrieved successfully.

400Bad Request

BadRequest

401Unauthorized

Unauthorized

404Not Found

NotFound

500Internal Server Error

InternalServerError

503Service Unavailable

ServiceUnavailable

Get Current Difficulty

curl -X GET 'https://alephium.nownodes.io/infos/current-difficulty'

const response = await fetch('https://alephium.nownodes.io/infos/current-difficulty', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/infos/current-difficulty')
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://alephium.nownodes.io/infos/current-difficulty')
data = response.json()

const response = await fetch('https://alephium.nownodes.io/infos/current-difficulty', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://alephium.nownodes.io/infos/current-difficulty";
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://alephium.nownodes.io/infos/current-difficulty', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://alephium.nownodes.io/infos/current-difficulty')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/infos/current-difficulty')
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)

{
  "difficulty": "617922583757445"
}

{
  "detail": "string"
}

{
  "detail": "string"
}

{
  "resource": "wallet-name",
  "detail": "wallet-name not found"
}

{
  "detail": "string"
}

{
  "detail": "string"
}

Blockflow

List blocks on the given time interval

GET

https://alephium.nownodes.io/blockflow/blocks

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns blocks produced within the specified time range.

Parameters

fromTsinteger<int64>>= 0requiredquery

toTsinteger<int64>>= 0query

Response

200OK

Valid response

400Bad Request

BadRequest

401Unauthorized

Unauthorized

404Not Found

NotFound

500Internal Server Error

InternalServerError

503Service Unavailable

ServiceUnavailable

List blocks on the given time interval

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

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/blockflow/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://alephium.nownodes.io/blockflow/blocks')
data = response.json()

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

const data = await response.json();

const endpoint = "https://alephium.nownodes.io/blockflow/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://alephium.nownodes.io/blockflow/blocks', {
  method: 'GET',
});

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/blockflow/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)

{
  "blocks": [
    [
      {
        "hash": "bdaf9dc514ce7d34b6474b8ca10a3dfb93ba997cb9d5ff1ea724ebe2af48abe5",
        "timestamp": 1611041396892,
        "chainFrom": 1,
        "chainTo": 2,
        "height": 42,
        "deps": [
          "bdaf9dc514ce7d34b6474b8ca10a3dfb93ba997cb9d5ff1ea724ebe2af48abe5",
          "bdaf9dc514ce7d34b6474b8ca10a3dfb93ba997cb9d5ff1ea724ebe2af48abe5"
        ],
        "transactions": [
          {
            "unsigned": {
              "txId": "503bfb16230888af4924aa8f8250d7d348b862e267d75d3147f1998050b6da69",
              "version": 1,
              "networkId": 1,
              "gasAmount": 20000,
              "gasPrice": "100000000000",
              "inputs": [
                {
                  "outputRef": {
                    "hint": 23412,
                    "key": "798e9e137aec7c2d59d9655b4ffa640f301f628bf7c365083bb255f6aa5f89ef"
                  },
                  "unlockScript": "00d1b70d2226308b46da297486adb6b4f1a8c1842cb159ac5ec04f384fe2d6f5da28"
                }
              ],
              "fixedOutputs": [
                {
                  "hint": 1,
                  "key": "798e9e137aec7c2d59d9655b4ffa640f301f628bf7c365083bb255f6aa5f89ef",
                  "attoAlphAmount": "2000000000000000000",
                  "address": "1AujpupFP4KWeZvqA7itsHY9cLJmx4qTzojVZrg8W9y",
                  "tokens": [
                    {
                      "id": "2d11fd6c12435ffb07aaed4d190a505b621b927a5f6e51b61ce0ebe186397bdd",
                      "amount": "42000000000000000000"
                    },
                    {
                      "id": "bd165d20bd063c7a023d22232a1e75bf46e904067f92b49323fe89fa0fd586bf",
                      "amount": "1000000000000000000000"
                    }
                  ],
                  "lockTime": 1611041396892,
                  "message": "798e9e137aec7c2d59d9655b4ffa640f301f628bf7c365083bb255f6aa5f89ef"
                }
              ]
            },
            "scriptExecutionOk": true,
            "contractInputs": [
              {
                "hint": 23412,
                "key": "798e9e137aec7c2d59d9655b4ffa640f301f628bf7c365083bb255f6aa5f89ef"
              }
            ],
            "generatedOutputs": [
              {
                "type": "AssetOutput",
                "hint": 1,
                "key": "798e9e137aec7c2d59d9655b4ffa640f301f628bf7c365083bb255f6aa5f89ef",
                "attoAlphAmount": "2000000000000000000",
                "address": "1AujpupFP4KWeZvqA7itsHY9cLJmx4qTzojVZrg8W9y",
                "tokens": [
                  {
                    "id": "2d11fd6c12435ffb07aaed4d190a505b621b927a5f6e51b61ce0ebe186397bdd",
                    "amount": "42000000000000000000"
                  },
                  {
                    "id": "bd165d20bd063c7a023d22232a1e75bf46e904067f92b49323fe89fa0fd586bf",
                    "amount": "1000000000000000000000"
                  }
                ],
                "lockTime": 1611041396892,
                "message": "798e9e137aec7c2d59d9655b4ffa640f301f628bf7c365083bb255f6aa5f89ef"
              },
              {
                "type": "ContractOutput",
                "hint": 1,
                "key": "798e9e137aec7c2d59d9655b4ffa640f301f628bf7c365083bb255f6aa5f89ef",
                "attoAlphAmount": "2000000000000000000",
                "address": "uomjgUz6D4tLejTkQtbNJMY8apAjTm1bgQf7em1wDV7S",
                "tokens": [
                  {
                    "id": "2d11fd6c12435ffb07aaed4d190a505b621b927a5f6e51b61ce0ebe186397bdd",
                    "amount": "42000000000000000000"
                  },
                  {
                    "id": "bd165d20bd063c7a023d22232a1e75bf46e904067f92b49323fe89fa0fd586bf",
                    "amount": "1000000000000000000000"
                  }
                ]
              }
            ],
            "inputSignatures": [
              "9e1a35b2931bd04e6780d01c36e3e5337941aa80f173cfe4f4e249c44ab135272b834c1a639db9c89d673a8a30524042b0469672ca845458a5a0cf2cad53221b"
            ],
            "scriptSignatures": [
              "9e1a35b2931bd04e6780d01c36e3e5337941aa80f173cfe4f4e249c44ab135272b834c1a639db9c89d673a8a30524042b0469672ca845458a5a0cf2cad53221b"
            ]
          }
        ],
        "nonce": "798e9e137aec7c2d59d9655b4ffa640f301f628bf7c365083bb255f6aa5f89ef",
        "version": 1,
        "depStateHash": "798e9e137aec7c2d59d9655b4ffa640f301f628bf7c365083bb255f6aa5f89ef",
        "txsHash": "798e9e137aec7c2d59d9655b4ffa640f301f628bf7c365083bb255f6aa5f89ef",
        "target": "798e9e137aec7c2d59d9655b4ffa640f301f628bf7c365083bb255f6aa5f89ef",
        "ghostUncles": [
          {
            "blockHash": "bdaf9dc514ce7d34b6474b8ca10a3dfb93ba997cb9d5ff1ea724ebe2af48abe5",
            "miner": "1AujpupFP4KWeZvqA7itsHY9cLJmx4qTzojVZrg8W9y"
          }
        ]
      }
    ]
  ]
}

{
  "detail": "string"
}

{
  "detail": "string"
}

{
  "resource": "wallet-name",
  "detail": "wallet-name not found"
}

{
  "detail": "string"
}

{
  "detail": "string"
}

List blocks with events on the given time interval

GET

https://alephium.nownodes.io/blockflow/blocks-with-events

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

fromTsinteger<int64>>= 0requiredquery

toTsinteger<int64>>= 0query

Response

200OK

Valid response

400Bad Request

BadRequest

401Unauthorized

Unauthorized

404Not Found

NotFound

500Internal Server Error

InternalServerError

503Service Unavailable

ServiceUnavailable

List blocks with events on the given time interval

curl -X GET 'https://alephium.nownodes.io/blockflow/blocks-with-events'

const response = await fetch('https://alephium.nownodes.io/blockflow/blocks-with-events', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/blockflow/blocks-with-events')
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://alephium.nownodes.io/blockflow/blocks-with-events')
data = response.json()

const response = await fetch('https://alephium.nownodes.io/blockflow/blocks-with-events', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://alephium.nownodes.io/blockflow/blocks-with-events";
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://alephium.nownodes.io/blockflow/blocks-with-events', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://alephium.nownodes.io/blockflow/blocks-with-events')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/blockflow/blocks-with-events')
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)

{
  "blocksAndEvents": [
    [
      {
        "block": {
          "hash": "bdaf9dc514ce7d34b6474b8ca10a3dfb93ba997cb9d5ff1ea724ebe2af48abe5",
          "timestamp": 1611041396892,
          "chainFrom": 1,
          "chainTo": 2,
          "height": 42,
          "deps": [
            "bdaf9dc514ce7d34b6474b8ca10a3dfb93ba997cb9d5ff1ea724ebe2af48abe5",
            "bdaf9dc514ce7d34b6474b8ca10a3dfb93ba997cb9d5ff1ea724ebe2af48abe5"
          ],
          "transactions": [
            {
              "unsigned": {
                "txId": "503bfb16230888af4924aa8f8250d7d348b862e267d75d3147f1998050b6da69",
                "version": 1,
                "networkId": 1,
                "gasAmount": 20000,
                "gasPrice": "100000000000",
                "inputs": [
                  {
                    "outputRef": {
                      "hint": 23412,
                      "key": "798e9e137aec7c2d59d9655b4ffa640f301f628bf7c365083bb255f6aa5f89ef"
                    },
                    "unlockScript": "00d1b70d2226308b46da297486adb6b4f1a8c1842cb159ac5ec04f384fe2d6f5da28"
                  }
                ],
                "fixedOutputs": [
                  {
                    "hint": 1,
                    "key": "798e9e137aec7c2d59d9655b4ffa640f301f628bf7c365083bb255f6aa5f89ef",
                    "attoAlphAmount": "2000000000000000000",
                    "address": "1AujpupFP4KWeZvqA7itsHY9cLJmx4qTzojVZrg8W9y",
                    "tokens": [
                      {
                        "id": "2d11fd6c12435ffb07aaed4d190a505b621b927a5f6e51b61ce0ebe186397bdd",
                        "amount": "42000000000000000000"
                      },
                      {
                        "id": "bd165d20bd063c7a023d22232a1e75bf46e904067f92b49323fe89fa0fd586bf",
                        "amount": "1000000000000000000000"
                      }
                    ],
                    "lockTime": 1611041396892,
                    "message": "798e9e137aec7c2d59d9655b4ffa640f301f628bf7c365083bb255f6aa5f89ef"
                  }
                ]
              },
              "scriptExecutionOk": true,
              "contractInputs": [
                {
                  "hint": 23412,
                  "key": "798e9e137aec7c2d59d9655b4ffa640f301f628bf7c365083bb255f6aa5f89ef"
                }
              ],
              "generatedOutputs": [
                {
                  "type": "AssetOutput",
                  "hint": 1,
                  "key": "798e9e137aec7c2d59d9655b4ffa640f301f628bf7c365083bb255f6aa5f89ef",
                  "attoAlphAmount": "2000000000000000000",
                  "address": "1AujpupFP4KWeZvqA7itsHY9cLJmx4qTzojVZrg8W9y",
                  "tokens": [
                    {
                      "id": "2d11fd6c12435ffb07aaed4d190a505b621b927a5f6e51b61ce0ebe186397bdd",
                      "amount": "42000000000000000000"
                    },
                    {
                      "id": "bd165d20bd063c7a023d22232a1e75bf46e904067f92b49323fe89fa0fd586bf",
                      "amount": "1000000000000000000000"
                    }
                  ],
                  "lockTime": 1611041396892,
                  "message": "798e9e137aec7c2d59d9655b4ffa640f301f628bf7c365083bb255f6aa5f89ef"
                },
                {
                  "type": "ContractOutput",
                  "hint": 1,
                  "key": "798e9e137aec7c2d59d9655b4ffa640f301f628bf7c365083bb255f6aa5f89ef",
                  "attoAlphAmount": "2000000000000000000",
                  "address": "uomjgUz6D4tLejTkQtbNJMY8apAjTm1bgQf7em1wDV7S",
                  "tokens": [
                    {
                      "id": "2d11fd6c12435ffb07aaed4d190a505b621b927a5f6e51b61ce0ebe186397bdd",
                      "amount": "42000000000000000000"
                    },
                    {
                      "id": "bd165d20bd063c7a023d22232a1e75bf46e904067f92b49323fe89fa0fd586bf",
                      "amount": "1000000000000000000000"
                    }
                  ]
                }
              ],
              "inputSignatures": [
                "9e1a35b2931bd04e6780d01c36e3e5337941aa80f173cfe4f4e249c44ab135272b834c1a639db9c89d673a8a30524042b0469672ca845458a5a0cf2cad53221b"
              ],
              "scriptSignatures": [
                "9e1a35b2931bd04e6780d01c36e3e5337941aa80f173cfe4f4e249c44ab135272b834c1a639db9c89d673a8a30524042b0469672ca845458a5a0cf2cad53221b"
              ]
            }
          ],
          "nonce": "798e9e137aec7c2d59d9655b4ffa640f301f628bf7c365083bb255f6aa5f89ef",
          "version": 1,
          "depStateHash": "798e9e137aec7c2d59d9655b4ffa640f301f628bf7c365083bb255f6aa5f89ef",
          "txsHash": "798e9e137aec7c2d59d9655b4ffa640f301f628bf7c365083bb255f6aa5f89ef",
          "target": "798e9e137aec7c2d59d9655b4ffa640f301f628bf7c365083bb255f6aa5f89ef",
          "ghostUncles": [
            {
              "blockHash": "bdaf9dc514ce7d34b6474b8ca10a3dfb93ba997cb9d5ff1ea724ebe2af48abe5",
              "miner": "1AujpupFP4KWeZvqA7itsHY9cLJmx4qTzojVZrg8W9y"
            }
          ]
        },
        "events": [
          {
            "txId": "503bfb16230888af4924aa8f8250d7d348b862e267d75d3147f1998050b6da69",
            "contractAddress": "vSxdLL2kE3o6vJBdKkdgmS3W39G3ZEmFHpo2y1jnbzBq",
            "eventIndex": 1,
            "fields": [
              {
                "type": "Address",
                "value": "1AujpupFP4KWeZvqA7itsHY9cLJmx4qTzojVZrg8W9y"
              },
              {
                "type": "U256",
                "value": "10"
              }
            ]
          }
        ]
      }
    ]
  ]
}

{
  "detail": "string"
}

{
  "detail": "string"
}

{
  "resource": "wallet-name",
  "detail": "wallet-name not found"
}

{
  "detail": "string"
}

{
  "detail": "string"
}

Get Block by Hash

GET

https://alephium.nownodes.io/blockflow/blocks/{block_hash}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Retrieves detailed information about a block identified by its hash.

Parameters

block_hashstringrequiredpath

The hash of the block to retrieve.

Response

200OK

Block information retrieved successfully.

400Bad Request

Invalid block hash supplied.

404Not Found

Block not found.

500Internal Server Error

Internal server error.

503Service Unavailable

ServiceUnavailable

Get Block by Hash

curl -X GET 'https://alephium.nownodes.io/blockflow/blocks/{block_hash}'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/blockflow/blocks/{block_hash}')
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://alephium.nownodes.io/blockflow/blocks/{block_hash}')
data = response.json()

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

const data = await response.json();

const endpoint = "https://alephium.nownodes.io/blockflow/blocks/{block_hash}";
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://alephium.nownodes.io/blockflow/blocks/{block_hash}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://alephium.nownodes.io/blockflow/blocks/{block_hash}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/blockflow/blocks/{block_hash}')
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": "0000000000004612ec7dbcf08dc4f07e65ac767f9fe0c32b53a61c18761ef44c",
  "timestamp": 1754913020964,
  "chainFrom": 3,
  "chainTo": 0,
  "height": 3117858,
  "deps": [
    "00000000000007d6582a5af7ce642de0454d790b0f8f55ccf30667c747eabf00"
  ],
  "transactions": [
    {
      "unsigned": {
        "txId": "12a99bdb3aa8961f0d099a30996e3c6003f49cafe9397ed0e96daea2938a8e42",
        "version": 0,
        "networkId": 0,
        "gasAmount": 20000,
        "gasPrice": "1000000000",
        "inputs": [],
        "fixedOutputs": [
          {
            "hint": -856749559,
            "key": "a523cac223b9ef2a98c66b92de5ff2b8042a0e951cb6f5f0919b4b1eec3a362d",
            "attoAlphAmount": "191472590469365818",
            "address": "1PZonix2UoaguUfbbBnWevk4vod1m9MeJXBnkr7aqN76",
            "tokens": [
              {}
            ],
            "lockTime": 1754943020964,
            "message": "030000"
          }
        ]
      },
      "scriptExecutionOk": true,
      "contractInputs": [],
      "generatedOutputs": [],
      "inputSignatures": [],
      "scriptSignatures": []
    }
  ],
  "nonce": "1a4d00000000000000000000000000000022a74ad1b6753f",
  "version": 0,
  "depStateHash": "0ad632ebff89ecb0d1af82f7de24372d8dc823dba623f2073983bcb8c56eedd2",
  "txsHash": "480dc015f5267c1d27e5a665016254f72b83554e7992e6b4473a65566cdbb4a7",
  "target": "1a808a0f",
  "ghostUncles": []
}

{
  "error": "Invalid block hash"
}

{
  "error": "Block not found"
}

{
  "error": "Internal server error"
}

{
  "detail": "string"
}

Get a mainchain block by ghost uncle hash

GET

https://alephium.nownodes.io/blockflow/main-chain-block-by-ghost-uncle/{ghost_uncle_hash}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

ghost_uncle_hashstring<block-hash>requiredpath

Response

200OK

Valid response

400Bad Request

BadRequest

401Unauthorized

Unauthorized

404Not Found

NotFound

500Internal Server Error

InternalServerError

503Service Unavailable

ServiceUnavailable

Get a mainchain block by ghost uncle hash

curl -X GET 'https://alephium.nownodes.io/blockflow/main-chain-block-by-ghost-uncle/{ghost_uncle_hash}'

const response = await fetch('https://alephium.nownodes.io/blockflow/main-chain-block-by-ghost-uncle/{ghost_uncle_hash}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/blockflow/main-chain-block-by-ghost-uncle/{ghost_uncle_hash}')
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://alephium.nownodes.io/blockflow/main-chain-block-by-ghost-uncle/{ghost_uncle_hash}')
data = response.json()

const response = await fetch('https://alephium.nownodes.io/blockflow/main-chain-block-by-ghost-uncle/{ghost_uncle_hash}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://alephium.nownodes.io/blockflow/main-chain-block-by-ghost-uncle/{ghost_uncle_hash}";
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://alephium.nownodes.io/blockflow/main-chain-block-by-ghost-uncle/{ghost_uncle_hash}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://alephium.nownodes.io/blockflow/main-chain-block-by-ghost-uncle/{ghost_uncle_hash}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/blockflow/main-chain-block-by-ghost-uncle/{ghost_uncle_hash}')
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": "bdaf9dc514ce7d34b6474b8ca10a3dfb93ba997cb9d5ff1ea724ebe2af48abe5",
  "timestamp": 1611041396892,
  "chainFrom": 1,
  "chainTo": 2,
  "height": 42,
  "deps": [
    "bdaf9dc514ce7d34b6474b8ca10a3dfb93ba997cb9d5ff1ea724ebe2af48abe5",
    "bdaf9dc514ce7d34b6474b8ca10a3dfb93ba997cb9d5ff1ea724ebe2af48abe5"
  ],
  "transactions": [
    {
      "unsigned": {
        "txId": "503bfb16230888af4924aa8f8250d7d348b862e267d75d3147f1998050b6da69",
        "version": 1,
        "networkId": 1,
        "gasAmount": 20000,
        "gasPrice": "100000000000",
        "inputs": [
          {
            "outputRef": {
              "hint": 23412,
              "key": "798e9e137aec7c2d59d9655b4ffa640f301f628bf7c365083bb255f6aa5f89ef"
            },
            "unlockScript": "00d1b70d2226308b46da297486adb6b4f1a8c1842cb159ac5ec04f384fe2d6f5da28"
          }
        ],
        "fixedOutputs": [
          {
            "hint": 1,
            "key": "798e9e137aec7c2d59d9655b4ffa640f301f628bf7c365083bb255f6aa5f89ef",
            "attoAlphAmount": "2000000000000000000",
            "address": "1AujpupFP4KWeZvqA7itsHY9cLJmx4qTzojVZrg8W9y",
            "tokens": [
              {
                "id": "2d11fd6c12435ffb07aaed4d190a505b621b927a5f6e51b61ce0ebe186397bdd",
                "amount": "42000000000000000000"
              },
              {
                "id": "bd165d20bd063c7a023d22232a1e75bf46e904067f92b49323fe89fa0fd586bf",
                "amount": "1000000000000000000000"
              }
            ],
            "lockTime": 1611041396892,
            "message": "798e9e137aec7c2d59d9655b4ffa640f301f628bf7c365083bb255f6aa5f89ef"
          }
        ]
      },
      "scriptExecutionOk": true,
      "contractInputs": [
        {
          "hint": 23412,
          "key": "798e9e137aec7c2d59d9655b4ffa640f301f628bf7c365083bb255f6aa5f89ef"
        }
      ],
      "generatedOutputs": [
        {
          "type": "AssetOutput",
          "hint": 1,
          "key": "798e9e137aec7c2d59d9655b4ffa640f301f628bf7c365083bb255f6aa5f89ef",
          "attoAlphAmount": "2000000000000000000",
          "address": "1AujpupFP4KWeZvqA7itsHY9cLJmx4qTzojVZrg8W9y",
          "tokens": [
            {
              "id": "2d11fd6c12435ffb07aaed4d190a505b621b927a5f6e51b61ce0ebe186397bdd",
              "amount": "42000000000000000000"
            },
            {
              "id": "bd165d20bd063c7a023d22232a1e75bf46e904067f92b49323fe89fa0fd586bf",
              "amount": "1000000000000000000000"
            }
          ],
          "lockTime": 1611041396892,
          "message": "798e9e137aec7c2d59d9655b4ffa640f301f628bf7c365083bb255f6aa5f89ef"
        },
        {
          "type": "ContractOutput",
          "hint": 1,
          "key": "798e9e137aec7c2d59d9655b4ffa640f301f628bf7c365083bb255f6aa5f89ef",
          "attoAlphAmount": "2000000000000000000",
          "address": "uomjgUz6D4tLejTkQtbNJMY8apAjTm1bgQf7em1wDV7S",
          "tokens": [
            {
              "id": "2d11fd6c12435ffb07aaed4d190a505b621b927a5f6e51b61ce0ebe186397bdd",
              "amount": "42000000000000000000"
            },
            {
              "id": "bd165d20bd063c7a023d22232a1e75bf46e904067f92b49323fe89fa0fd586bf",
              "amount": "1000000000000000000000"
            }
          ]
        }
      ],
      "inputSignatures": [
        "9e1a35b2931bd04e6780d01c36e3e5337941aa80f173cfe4f4e249c44ab135272b834c1a639db9c89d673a8a30524042b0469672ca845458a5a0cf2cad53221b"
      ],
      "scriptSignatures": [
        "9e1a35b2931bd04e6780d01c36e3e5337941aa80f173cfe4f4e249c44ab135272b834c1a639db9c89d673a8a30524042b0469672ca845458a5a0cf2cad53221b"
      ]
    }
  ],
  "nonce": "798e9e137aec7c2d59d9655b4ffa640f301f628bf7c365083bb255f6aa5f89ef",
  "version": 1,
  "depStateHash": "798e9e137aec7c2d59d9655b4ffa640f301f628bf7c365083bb255f6aa5f89ef",
  "txsHash": "798e9e137aec7c2d59d9655b4ffa640f301f628bf7c365083bb255f6aa5f89ef",
  "target": "798e9e137aec7c2d59d9655b4ffa640f301f628bf7c365083bb255f6aa5f89ef",
  "ghostUncles": [
    {
      "blockHash": "bdaf9dc514ce7d34b6474b8ca10a3dfb93ba997cb9d5ff1ea724ebe2af48abe5",
      "miner": "1AujpupFP4KWeZvqA7itsHY9cLJmx4qTzojVZrg8W9y"
    }
  ]
}

{
  "detail": "string"
}

{
  "detail": "string"
}

{
  "resource": "wallet-name",
  "detail": "wallet-name not found"
}

{
  "detail": "string"
}

{
  "detail": "string"
}

Get Block with Events

GET

https://alephium.nownodes.io/blockflow/blocks-with-events/{block_hash}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Retrieves detailed block information along with any smart contract events emitted in the block.

Parameters

block_hashstringrequiredpath

The hash of the block.

Response

200OK

Block with events retrieved successfully.

404Not Found

Block not found.

500Internal Server Error

Internal server error.

503Service Unavailable

ServiceUnavailable

Get Block with Events

curl -X GET 'https://alephium.nownodes.io/blockflow/blocks-with-events/{block_hash}'

const response = await fetch('https://alephium.nownodes.io/blockflow/blocks-with-events/{block_hash}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/blockflow/blocks-with-events/{block_hash}')
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://alephium.nownodes.io/blockflow/blocks-with-events/{block_hash}')
data = response.json()

const response = await fetch('https://alephium.nownodes.io/blockflow/blocks-with-events/{block_hash}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://alephium.nownodes.io/blockflow/blocks-with-events/{block_hash}";
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://alephium.nownodes.io/blockflow/blocks-with-events/{block_hash}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://alephium.nownodes.io/blockflow/blocks-with-events/{block_hash}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/blockflow/blocks-with-events/{block_hash}')
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)

{
  "block": {
    "hash": "0000000000001ddd11912d103cae4d7596a49485ee7ea8e9c2acdc32b4480759",
    "timestamp": 1754913626360,
    "chainFrom": 2,
    "chainTo": 1,
    "height": 3217510,
    "deps": [
      "string"
    ],
    "transactions": [
      {
        "unsigned": {
          "txId": "4a91d581039055cef017e0ced7dae4a9176be281153e7cc12aebf790e536b645",
          "version": 0,
          "networkId": 0,
          "gasAmount": 20000,
          "gasPrice": "1000000000",
          "inputs": [],
          "fixedOutputs": [
            {
              "hint": -502957581,
              "key": "string",
              "attoAlphAmount": "string",
              "address": "string",
              "tokens": [
                {}
              ],
              "lockTime": 0,
              "message": "string"
            }
          ]
        },
        "scriptExecutionOk": true,
        "contractInputs": [],
        "generatedOutputs": [],
        "inputSignatures": [],
        "scriptSignatures": []
      }
    ],
    "nonce": "68710000000000000000000000000000009b4cca7126d384",
    "version": 0,
    "depStateHash": "600fd8ce293930f6c7361894f33f54a04df2ac1339617eee13ed7da99bba98ab",
    "txsHash": "12e5681ac5f5ab02779778bc22df52aca57846cec805d4dd3ee5dc0d466223d2",
    "target": "1a76456d",
    "ghostUncles": []
  },
  "events": []
}

{
  "error": "Block not found"
}

{
  "error": "Internal server error"
}

{
  "detail": "string"
}

Check if Block is in Main Chain

GET

https://alephium.nownodes.io/blockflow/is-block-in-main-chain

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns whether the specified block is part of the main chain.

Parameters

blockHashstringrequiredquery

The hash of the block to check.

Response

200OK

Successfully checked block status.

400Bad Request

Invalid or missing block hash.

404Not Found

Block not found.

500Internal Server Error

Internal server error.

503Service Unavailable

ServiceUnavailable

Check if Block is in Main Chain

curl -X GET 'https://alephium.nownodes.io/blockflow/is-block-in-main-chain'

const response = await fetch('https://alephium.nownodes.io/blockflow/is-block-in-main-chain', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/blockflow/is-block-in-main-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://alephium.nownodes.io/blockflow/is-block-in-main-chain')
data = response.json()

const response = await fetch('https://alephium.nownodes.io/blockflow/is-block-in-main-chain', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://alephium.nownodes.io/blockflow/is-block-in-main-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://alephium.nownodes.io/blockflow/is-block-in-main-chain', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://alephium.nownodes.io/blockflow/is-block-in-main-chain')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/blockflow/is-block-in-main-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)

{
  "isMainChain": true
}

{
  "error": "Missing or invalid blockHash"
}

{
  "error": "Block not found"
}

{
  "error": "Internal server error"
}

{
  "detail": "string"
}

Get Block Headers Hashes

GET

https://alephium.nownodes.io/blockflow/hashes

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Retrieves block header hashes filtered by source group, destination group, and block height.

Parameters

fromGroupintegerrequiredquery

Source group number.

toGroupintegerrequiredquery

Destination group number.

heightintegerrequiredquery

Block height to filter.

Response

200OK

List of block header hashes.

400Bad Request

Invalid or missing query parameters.

500Internal Server Error

Internal server error.

503Service Unavailable

ServiceUnavailable

Get Block Headers Hashes

curl -X GET 'https://alephium.nownodes.io/blockflow/hashes'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/blockflow/hashes')
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://alephium.nownodes.io/blockflow/hashes')
data = response.json()

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

const data = await response.json();

const endpoint = "https://alephium.nownodes.io/blockflow/hashes";
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://alephium.nownodes.io/blockflow/hashes', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://alephium.nownodes.io/blockflow/hashes')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/blockflow/hashes')
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)

{
  "headers": [
    "0000000000000edd995d369f408344e473eeb1beaa050911c393661a7ef71b46"
  ]
}

{
  "error": "Missing or invalid query parameters"
}

{
  "error": "Internal server error"
}

{
  "detail": "string"
}

Get Chain Info by Groups

GET

https://alephium.nownodes.io/blockflow/chain-info

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the current chain height filtered by fromGroup and toGroup.

Parameters

fromGroupintegerrequiredquery

Source group number.

toGroupintegerrequiredquery

Destination group number.

Response

200OK

Chain information retrieved successfully.

400Bad Request

Invalid or missing query parameters.

500Internal Server Error

Internal server error.

503Service Unavailable

ServiceUnavailable

Get Chain Info by Groups

curl -X GET 'https://alephium.nownodes.io/blockflow/chain-info'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/blockflow/chain-info')
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://alephium.nownodes.io/blockflow/chain-info')
data = response.json()

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

const data = await response.json();

const endpoint = "https://alephium.nownodes.io/blockflow/chain-info";
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://alephium.nownodes.io/blockflow/chain-info', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://alephium.nownodes.io/blockflow/chain-info')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/blockflow/chain-info')
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)

{
  "currentHeight": 3351911
}

{
  "error": "Missing or invalid query parameters"
}

{
  "error": "Internal server error"
}

{
  "detail": "string"
}

Get Block Header by Hash

GET

https://alephium.nownodes.io/blockflow/headers/{block_hash}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns detailed information about a block header identified by its hash.

Parameters

block_hashstringrequiredpath

Hash of the block header to retrieve.

Response

200OK

Block header retrieved successfully.

400Bad Request

Invalid block hash supplied.

404Not Found

Block header not found.

500Internal Server Error

Internal server error.

503Service Unavailable

ServiceUnavailable

Get Block Header by Hash

curl -X GET 'https://alephium.nownodes.io/blockflow/headers/{block_hash}'

const response = await fetch('https://alephium.nownodes.io/blockflow/headers/{block_hash}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/blockflow/headers/{block_hash}')
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://alephium.nownodes.io/blockflow/headers/{block_hash}')
data = response.json()

const response = await fetch('https://alephium.nownodes.io/blockflow/headers/{block_hash}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://alephium.nownodes.io/blockflow/headers/{block_hash}";
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://alephium.nownodes.io/blockflow/headers/{block_hash}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://alephium.nownodes.io/blockflow/headers/{block_hash}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/blockflow/headers/{block_hash}')
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": "0000000000005c8d2761b8c0967d5e0dcbfe47a5678a80f676a54276d956e3ed",
  "timestamp": 1754914650065,
  "chainFrom": 3,
  "chainTo": 1,
  "height": 3087063,
  "deps": [
    "00000000000077b5fa47c09862b5e5bdac2d607a0c2d5f47c6a809dfe648fe30",
    "0000000000002607d92a86fe627d89508c772b8212c2e329ec01ff08b8a72e05",
    "0000000000001bf5527420ea81e4cfbe9f876d8684789dad8141ea761624f6ba",
    "00000000000051c9411b5c0d34753677a2c05f36f085dddb9a5ac6462559727c",
    "00000000000025f9d5df85bee58053b9e0a66a707e6a20b385c5ab7afb566c9d",
    "0000000000005266b43014907a76202f534ecf9370033aa72cca5112c8448dae",
    "0000000000003979d68003f93bb1d10e82ef0a7ff62e19cdd94aa19d3f4379ef"
  ]
}

{
  "error": "Invalid block hash"
}

{
  "error": "Block not found"
}

{
  "error": "Internal server error"
}

{
  "detail": "string"
}

Addresses

Get Address Balance (with optional mempool)

GET

https://alephium.nownodes.io/addresses/{address}/balance

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns total and locked balances for the specified address. If mempool=true, balances will include the effect of unconfirmed transactions.

Parameters

addressstringrequiredpath

The address to query.

mempoolbooleanfalsequery

Whether to include unconfirmed (mempool) transactions in the balance calculation.

Response

200OK

Address balance retrieved successfully.

400Bad Request

Invalid address or query parameter.

404Not Found

Address not found.

500Internal Server Error

Internal server error.

503Service Unavailable

ServiceUnavailable

Get Address Balance (with optional mempool)

curl -X GET 'https://alephium.nownodes.io/addresses/{address}/balance'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/addresses/{address}/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://alephium.nownodes.io/addresses/{address}/balance')
data = response.json()

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

const data = await response.json();

const endpoint = "https://alephium.nownodes.io/addresses/{address}/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://alephium.nownodes.io/addresses/{address}/balance', {
  method: 'GET',
});

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/addresses/{address}/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)

{
  "balance": "465478842708706554897",
  "balanceHint": "465.478842708706554897 ALPH",
  "lockedBalance": "461357694374776064051",
  "lockedBalanceHint": "461.357694374776064051 ALPH",
  "utxoNum": 2459
}

{
  "error": "Invalid address"
}

{
  "error": "Address not found"
}

{
  "error": "Internal server error"
}

{
  "detail": "string"
}

Get UTXOs for Address

GET

https://alephium.nownodes.io/addresses/{address}/utxos

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns all unspent outputs (UTXOs) associated with a specific address.

Parameters

addressstringrequiredpath

The address whose UTXOs are requested.

Response

200OK

List of UTXOs retrieved successfully.

400Bad Request

Invalid address format.

404Not Found

Address not found or has no UTXOs.

500Internal Server Error

Internal server error.

503Service Unavailable

ServiceUnavailable

Get UTXOs for Address

curl -X GET 'https://alephium.nownodes.io/addresses/{address}/utxos'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/addresses/{address}/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://alephium.nownodes.io/addresses/{address}/utxos')
data = response.json()

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

const data = await response.json();

const endpoint = "https://alephium.nownodes.io/addresses/{address}/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://alephium.nownodes.io/addresses/{address}/utxos', {
  method: 'GET',
});

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/addresses/{address}/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)

{
  "utxos": [
    {
      "ref": {
        "hint": -421195643,
        "key": "000cee2f94bbb6c87776016a9c55d2d7e454564f1ce38b7b3ace0ec6399021ec"
      },
      "amount": "191472590469365818",
      "lockTime": 1754924356031,
      "additionalData": "030200"
    }
  ]
}

{
  "error": "Invalid address format"
}

{
  "error": "No UTXOs found for address"
}

{
  "error": "Internal server error"
}

{
  "detail": "string"
}

Get Group Number by Address

GET

https://alephium.nownodes.io/addresses/{address}/group

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the group number for the specified address.

Parameters

addressstringrequiredpath

The address to query.

Response

200OK

Group number retrieved successfully.

400Bad Request

Invalid address format.

404Not Found

Address not found.

500Internal Server Error

Internal server error.

503Service Unavailable

ServiceUnavailable

Get Group Number by Address

curl -X GET 'https://alephium.nownodes.io/addresses/{address}/group'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/addresses/{address}/group')
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://alephium.nownodes.io/addresses/{address}/group')
data = response.json()

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

const data = await response.json();

const endpoint = "https://alephium.nownodes.io/addresses/{address}/group";
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://alephium.nownodes.io/addresses/{address}/group', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://alephium.nownodes.io/addresses/{address}/group')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/addresses/{address}/group')
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)

{
  "group": 2
}

{
  "error": "Invalid address format"
}

{
  "error": "Address not found"
}

{
  "error": "Internal server error"
}

{
  "detail": "string"
}

Transactions

Build Transaction

POST

https://alephium.nownodes.io/transactions/build

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Creates a new unsigned transaction from the sender’s public key to specified destinations.

Body

application/json

fromPublicKeystringrequired

Sender’s public key in hex format.

destinationsArray<object>required

List of destination addresses with amounts.

Show child attributes

addressstringrequired

Destination ALPH address.

attoAlphAmountstringrequired

Amount in attoALPH to send (1 ALPH = 10^18 attoALPH).

Response

200OK

Transaction built successfully.

400Bad Request

Invalid request payload.

401Unauthorized

Unauthorized

404Not Found

NotFound

500Internal Server Error

InternalServerError

503Service Unavailable

ServiceUnavailable

Build Transaction

curl -X POST 'https://alephium.nownodes.io/transactions/build' \
  -H 'Content-Type: application/json' \
  -d '{
    "fromPublicKey": "d1b70d2226308b46da297486adb6b4f1a8c1842cb159ac5ec04f384fe2d6f5da28",
    "destinations": [
      {
        "address": "12jK2jHyyJTJyuRMRya7QJSojgVnb5yh4HVzNNw6BTBDF",
        "attoAlphAmount": "2000000000000000"
      }
    ]
  }'

const response = await fetch('https://alephium.nownodes.io/transactions/build', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "fromPublicKey": "d1b70d2226308b46da297486adb6b4f1a8c1842cb159ac5ec04f384fe2d6f5da28",
      "destinations": [
        {
          "address": "12jK2jHyyJTJyuRMRya7QJSojgVnb5yh4HVzNNw6BTBDF",
          "attoAlphAmount": "2000000000000000"
        }
      ]
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/transactions/build')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "fromPublicKey": "d1b70d2226308b46da297486adb6b4f1a8c1842cb159ac5ec04f384fe2d6f5da28",
    "destinations": [
      {
        "address": "12jK2jHyyJTJyuRMRya7QJSojgVnb5yh4HVzNNw6BTBDF",
        "attoAlphAmount": "2000000000000000"
      }
    ]
  }'

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

import requests

payload = {
  "fromPublicKey": "d1b70d2226308b46da297486adb6b4f1a8c1842cb159ac5ec04f384fe2d6f5da28",
  "destinations": [
    {
      "address": "12jK2jHyyJTJyuRMRya7QJSojgVnb5yh4HVzNNw6BTBDF",
      "attoAlphAmount": "2000000000000000"
    }
  ]
}

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

const response = await fetch('https://alephium.nownodes.io/transactions/build', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "fromPublicKey": "d1b70d2226308b46da297486adb6b4f1a8c1842cb159ac5ec04f384fe2d6f5da28",
      "destinations": [
        {
          "address": "12jK2jHyyJTJyuRMRya7QJSojgVnb5yh4HVzNNw6BTBDF",
          "attoAlphAmount": "2000000000000000"
        }
      ]
    }),
});

const data = await response.json();

const endpoint = "https://alephium.nownodes.io/transactions/build";
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({
    "fromPublicKey": "d1b70d2226308b46da297486adb6b4f1a8c1842cb159ac5ec04f384fe2d6f5da28",
    "destinations": [
      {
        "address": "12jK2jHyyJTJyuRMRya7QJSojgVnb5yh4HVzNNw6BTBDF",
        "attoAlphAmount": "2000000000000000"
      }
    ]
  });
console.log(result);

const response = await fetch('https://alephium.nownodes.io/transactions/build', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "fromPublicKey": "d1b70d2226308b46da297486adb6b4f1a8c1842cb159ac5ec04f384fe2d6f5da28",
      "destinations": [
        {
          "address": "12jK2jHyyJTJyuRMRya7QJSojgVnb5yh4HVzNNw6BTBDF",
          "attoAlphAmount": "2000000000000000"
        }
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "fromPublicKey": "d1b70d2226308b46da297486adb6b4f1a8c1842cb159ac5ec04f384fe2d6f5da28",
  "destinations": [
    {
      "address": "12jK2jHyyJTJyuRMRya7QJSojgVnb5yh4HVzNNw6BTBDF",
      "attoAlphAmount": "2000000000000000"
    }
  ]
}

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

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/transactions/build')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "fromPublicKey": "d1b70d2226308b46da297486adb6b4f1a8c1842cb159ac5ec04f384fe2d6f5da28",
    "destinations": [
      {
        "address": "12jK2jHyyJTJyuRMRya7QJSojgVnb5yh4HVzNNw6BTBDF",
        "attoAlphAmount": "2000000000000000"
      }
    ]
  }'

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

Request Body

{
  "fromPublicKey": "d1b70d2226308b46da297486adb6b4f1a8c1842cb159ac5ec04f384fe2d6f5da28",
  "destinations": [
    {
      "address": "12jK2jHyyJTJyuRMRya7QJSojgVnb5yh4HVzNNw6BTBDF",
      "attoAlphAmount": "2000000000000000"
    }
  ]
}

{
  "unsignedTx": "35d1b2a520a0da34c5eb8d712aa9cc",
  "gasAmount": 20000,
  "gasPrice": "100000000000",
  "txId": "503bfb16230888af4924aa8f8250d7d348b862e267d75d3147f1998050b6da69",
  "fromGroup": 2,
  "toGroup": 1
}

{
  "error": "Invalid input data"
}

{
  "detail": "string"
}

{
  "resource": "wallet-name",
  "detail": "wallet-name not found"
}

{
  "detail": "string"
}

{
  "detail": "string"
}

Build Transaction from Multiple Addresses

POST

https://alephium.nownodes.io/transactions/build-multi-addresses

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Creates a new unsigned transaction from multiple senders each with their own destinations.

Body

application/json

fromArray<object>required

List of sender public keys with their destinations.

Show child attributes

fromPublicKeystringrequired

Sender’s public key in hex format.

destinationsArray<object>required

List of destination addresses with amounts for this sender.

Show child attributes

addressstringrequired

Destination ALPH address.

attoAlphAmountstringrequired

Amount in attoALPH to send (1 ALPH = 10^18 attoALPH).

Response

200OK

Transaction built successfully.

400Bad Request

BadRequest

401Unauthorized

Unauthorized

404Not Found

NotFound

500Internal Server Error

InternalServerError

503Service Unavailable

ServiceUnavailable

Build Transaction from Multiple Addresses

curl -X POST 'https://alephium.nownodes.io/transactions/build-multi-addresses' \
  -H 'Content-Type: application/json' \
  -d '{
    "from": [
      {
        "fromPublicKey": "d1b70d2226308b46da297486adb6b4f1a8c1842cb159ac5ec04f384fe2d6f5da28",
        "destinations": [
          {
            "address": "1AujpupFP4KWeZvqA7itsHY9cLJmx4qTzojVZrg8W9y",
            "attoAlphAmount": "2000000000000000000"
          }
        ]
      }
    ]
  }'

const response = await fetch('https://alephium.nownodes.io/transactions/build-multi-addresses', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "from": [
        {
          "fromPublicKey": "d1b70d2226308b46da297486adb6b4f1a8c1842cb159ac5ec04f384fe2d6f5da28",
          "destinations": [
            {
              "address": "1AujpupFP4KWeZvqA7itsHY9cLJmx4qTzojVZrg8W9y",
              "attoAlphAmount": "2000000000000000000"
            }
          ]
        }
      ]
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/transactions/build-multi-addresses')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "from": [
      {
        "fromPublicKey": "d1b70d2226308b46da297486adb6b4f1a8c1842cb159ac5ec04f384fe2d6f5da28",
        "destinations": [
          {
            "address": "1AujpupFP4KWeZvqA7itsHY9cLJmx4qTzojVZrg8W9y",
            "attoAlphAmount": "2000000000000000000"
          }
        ]
      }
    ]
  }'

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

import requests

payload = {
  "from": [
    {
      "fromPublicKey": "d1b70d2226308b46da297486adb6b4f1a8c1842cb159ac5ec04f384fe2d6f5da28",
      "destinations": [
        {
          "address": "1AujpupFP4KWeZvqA7itsHY9cLJmx4qTzojVZrg8W9y",
          "attoAlphAmount": "2000000000000000000"
        }
      ]
    }
  ]
}

response = requests.post('https://alephium.nownodes.io/transactions/build-multi-addresses', json=payload)
data = response.json()

const response = await fetch('https://alephium.nownodes.io/transactions/build-multi-addresses', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "from": [
        {
          "fromPublicKey": "d1b70d2226308b46da297486adb6b4f1a8c1842cb159ac5ec04f384fe2d6f5da28",
          "destinations": [
            {
              "address": "1AujpupFP4KWeZvqA7itsHY9cLJmx4qTzojVZrg8W9y",
              "attoAlphAmount": "2000000000000000000"
            }
          ]
        }
      ]
    }),
});

const data = await response.json();

const endpoint = "https://alephium.nownodes.io/transactions/build-multi-addresses";
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({
    "from": [
      {
        "fromPublicKey": "d1b70d2226308b46da297486adb6b4f1a8c1842cb159ac5ec04f384fe2d6f5da28",
        "destinations": [
          {
            "address": "1AujpupFP4KWeZvqA7itsHY9cLJmx4qTzojVZrg8W9y",
            "attoAlphAmount": "2000000000000000000"
          }
        ]
      }
    ]
  });
console.log(result);

const response = await fetch('https://alephium.nownodes.io/transactions/build-multi-addresses', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "from": [
        {
          "fromPublicKey": "d1b70d2226308b46da297486adb6b4f1a8c1842cb159ac5ec04f384fe2d6f5da28",
          "destinations": [
            {
              "address": "1AujpupFP4KWeZvqA7itsHY9cLJmx4qTzojVZrg8W9y",
              "attoAlphAmount": "2000000000000000000"
            }
          ]
        }
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "from": [
    {
      "fromPublicKey": "d1b70d2226308b46da297486adb6b4f1a8c1842cb159ac5ec04f384fe2d6f5da28",
      "destinations": [
        {
          "address": "1AujpupFP4KWeZvqA7itsHY9cLJmx4qTzojVZrg8W9y",
          "attoAlphAmount": "2000000000000000000"
        }
      ]
    }
  ]
}

response = requests.post('https://alephium.nownodes.io/transactions/build-multi-addresses', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/transactions/build-multi-addresses')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "from": [
      {
        "fromPublicKey": "d1b70d2226308b46da297486adb6b4f1a8c1842cb159ac5ec04f384fe2d6f5da28",
        "destinations": [
          {
            "address": "1AujpupFP4KWeZvqA7itsHY9cLJmx4qTzojVZrg8W9y",
            "attoAlphAmount": "2000000000000000000"
          }
        ]
      }
    ]
  }'

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

Request Body

{
  "from": [
    {
      "fromPublicKey": "d1b70d2226308b46da297486adb6b4f1a8c1842cb159ac5ec04f384fe2d6f5da28",
      "destinations": [
        {
          "address": "1AujpupFP4KWeZvqA7itsHY9cLJmx4qTzojVZrg8W9y",
          "attoAlphAmount": "2000000000000000000"
        }
      ]
    }
  ]
}

{
  "unsignedTx": "35d1b2a520a0da34c5eb8d712aa9cc",
  "gasAmount": 20000,
  "gasPrice": "100000000000",
  "txId": "503bfb16230888af4924aa8f8250d7d348b862e267d75d3147f1998050b6da69",
  "fromGroup": 2,
  "toGroup": 1
}

{
  "detail": "string"
}

{
  "detail": "string"
}

{
  "resource": "wallet-name",
  "detail": "wallet-name not found"
}

{
  "detail": "string"
}

{
  "detail": "string"
}

Build Sweep Transaction

POST

https://alephium.nownodes.io/transactions/sweep-address/build

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Creates unsigned transaction(s) to sweep all funds from the specified public key’s address to a destination address.

Body

application/json

fromPublicKeystringrequired

Public key of the source address to sweep funds from.

toAddressstringrequired

Destination ALPH address where all funds will be sent.

Response

200OK

Sweep transaction(s) built successfully.

400Bad Request

BadRequest

401Unauthorized

Unauthorized

404Not Found

NotFound

500Internal Server Error

InternalServerError

503Service Unavailable

ServiceUnavailable

Build Sweep Transaction

curl -X POST 'https://alephium.nownodes.io/transactions/sweep-address/build' \
  -H 'Content-Type: application/json' \
  -d '{
    "fromPublicKey": "d1b70d2226308b46da297486adb6b4f1a8c1842cb159ac5ec04f384fe2d6f5da28",
    "toAddress": "1AujpupFP4KWeZvqA7itsHY9cLJmx4qTzojVZrg8W9y"
  }'

const response = await fetch('https://alephium.nownodes.io/transactions/sweep-address/build', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "fromPublicKey": "d1b70d2226308b46da297486adb6b4f1a8c1842cb159ac5ec04f384fe2d6f5da28",
      "toAddress": "1AujpupFP4KWeZvqA7itsHY9cLJmx4qTzojVZrg8W9y"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/transactions/sweep-address/build')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "fromPublicKey": "d1b70d2226308b46da297486adb6b4f1a8c1842cb159ac5ec04f384fe2d6f5da28",
    "toAddress": "1AujpupFP4KWeZvqA7itsHY9cLJmx4qTzojVZrg8W9y"
  }'

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

import requests

payload = {
  "fromPublicKey": "d1b70d2226308b46da297486adb6b4f1a8c1842cb159ac5ec04f384fe2d6f5da28",
  "toAddress": "1AujpupFP4KWeZvqA7itsHY9cLJmx4qTzojVZrg8W9y"
}

response = requests.post('https://alephium.nownodes.io/transactions/sweep-address/build', json=payload)
data = response.json()

const response = await fetch('https://alephium.nownodes.io/transactions/sweep-address/build', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "fromPublicKey": "d1b70d2226308b46da297486adb6b4f1a8c1842cb159ac5ec04f384fe2d6f5da28",
      "toAddress": "1AujpupFP4KWeZvqA7itsHY9cLJmx4qTzojVZrg8W9y"
    }),
});

const data = await response.json();

const endpoint = "https://alephium.nownodes.io/transactions/sweep-address/build";
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({
    "fromPublicKey": "d1b70d2226308b46da297486adb6b4f1a8c1842cb159ac5ec04f384fe2d6f5da28",
    "toAddress": "1AujpupFP4KWeZvqA7itsHY9cLJmx4qTzojVZrg8W9y"
  });
console.log(result);

const response = await fetch('https://alephium.nownodes.io/transactions/sweep-address/build', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "fromPublicKey": "d1b70d2226308b46da297486adb6b4f1a8c1842cb159ac5ec04f384fe2d6f5da28",
      "toAddress": "1AujpupFP4KWeZvqA7itsHY9cLJmx4qTzojVZrg8W9y"
    }),
});

const data = await response.json();

import requests

payload = {
  "fromPublicKey": "d1b70d2226308b46da297486adb6b4f1a8c1842cb159ac5ec04f384fe2d6f5da28",
  "toAddress": "1AujpupFP4KWeZvqA7itsHY9cLJmx4qTzojVZrg8W9y"
}

response = requests.post('https://alephium.nownodes.io/transactions/sweep-address/build', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/transactions/sweep-address/build')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "fromPublicKey": "d1b70d2226308b46da297486adb6b4f1a8c1842cb159ac5ec04f384fe2d6f5da28",
    "toAddress": "1AujpupFP4KWeZvqA7itsHY9cLJmx4qTzojVZrg8W9y"
  }'

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

Request Body

{
  "fromPublicKey": "d1b70d2226308b46da297486adb6b4f1a8c1842cb159ac5ec04f384fe2d6f5da28",
  "toAddress": "1AujpupFP4KWeZvqA7itsHY9cLJmx4qTzojVZrg8W9y"
}

{
  "unsignedTxs": [
    {
      "txId": "503bfb16230888af4924aa8f8250d7d348b862e267d75d3147f1998050b6da69",
      "unsignedTx": "35d1b2a520a0da34c5eb8d712aa9cc",
      "gasAmount": 20000,
      "gasPrice": "100000000000"
    }
  ],
  "fromGroup": 2,
  "toGroup": 1
}

{
  "detail": "string"
}

{
  "detail": "string"
}

{
  "resource": "wallet-name",
  "detail": "wallet-name not found"
}

{
  "detail": "string"
}

{
  "detail": "string"
}

Submit Signed Transaction

POST

https://alephium.nownodes.io/transactions/submit

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Submits a signed transaction to the ALPH network for processing.

Body

application/json

unsignedTxstringrequired

Serialized unsigned transaction data in hex or base64 format.

signaturestringrequired

Signature of the unsigned transaction.

Response

200OK

Transaction successfully submitted.

400Bad Request

BadRequest

401Unauthorized

Unauthorized

404Not Found

NotFound

500Internal Server Error

InternalServerError

503Service Unavailable

ServiceUnavailable

Submit Signed Transaction

curl -X POST 'https://alephium.nownodes.io/transactions/submit' \
  -H 'Content-Type: application/json' \
  -d '{
    "unsignedTx": "35d1b2a520a0da34c5eb8d712aa9cc",
    "signature": "9e1a35b2931bd04e6780d01c36e3e5337941aa80f173cfe4f4e249c44ab135272b834c1a639db9c89d673a8a30524042b0469672ca845458a5a0cf2cad53221b"
  }'

const response = await fetch('https://alephium.nownodes.io/transactions/submit', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "unsignedTx": "35d1b2a520a0da34c5eb8d712aa9cc",
      "signature": "9e1a35b2931bd04e6780d01c36e3e5337941aa80f173cfe4f4e249c44ab135272b834c1a639db9c89d673a8a30524042b0469672ca845458a5a0cf2cad53221b"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/transactions/submit')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "unsignedTx": "35d1b2a520a0da34c5eb8d712aa9cc",
    "signature": "9e1a35b2931bd04e6780d01c36e3e5337941aa80f173cfe4f4e249c44ab135272b834c1a639db9c89d673a8a30524042b0469672ca845458a5a0cf2cad53221b"
  }'

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

import requests

payload = {
  "unsignedTx": "35d1b2a520a0da34c5eb8d712aa9cc",
  "signature": "9e1a35b2931bd04e6780d01c36e3e5337941aa80f173cfe4f4e249c44ab135272b834c1a639db9c89d673a8a30524042b0469672ca845458a5a0cf2cad53221b"
}

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

const response = await fetch('https://alephium.nownodes.io/transactions/submit', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "unsignedTx": "35d1b2a520a0da34c5eb8d712aa9cc",
      "signature": "9e1a35b2931bd04e6780d01c36e3e5337941aa80f173cfe4f4e249c44ab135272b834c1a639db9c89d673a8a30524042b0469672ca845458a5a0cf2cad53221b"
    }),
});

const data = await response.json();

const endpoint = "https://alephium.nownodes.io/transactions/submit";
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({
    "unsignedTx": "35d1b2a520a0da34c5eb8d712aa9cc",
    "signature": "9e1a35b2931bd04e6780d01c36e3e5337941aa80f173cfe4f4e249c44ab135272b834c1a639db9c89d673a8a30524042b0469672ca845458a5a0cf2cad53221b"
  });
console.log(result);

const response = await fetch('https://alephium.nownodes.io/transactions/submit', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "unsignedTx": "35d1b2a520a0da34c5eb8d712aa9cc",
      "signature": "9e1a35b2931bd04e6780d01c36e3e5337941aa80f173cfe4f4e249c44ab135272b834c1a639db9c89d673a8a30524042b0469672ca845458a5a0cf2cad53221b"
    }),
});

const data = await response.json();

import requests

payload = {
  "unsignedTx": "35d1b2a520a0da34c5eb8d712aa9cc",
  "signature": "9e1a35b2931bd04e6780d01c36e3e5337941aa80f173cfe4f4e249c44ab135272b834c1a639db9c89d673a8a30524042b0469672ca845458a5a0cf2cad53221b"
}

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

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/transactions/submit')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "unsignedTx": "35d1b2a520a0da34c5eb8d712aa9cc",
    "signature": "9e1a35b2931bd04e6780d01c36e3e5337941aa80f173cfe4f4e249c44ab135272b834c1a639db9c89d673a8a30524042b0469672ca845458a5a0cf2cad53221b"
  }'

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

Request Body

{
  "unsignedTx": "35d1b2a520a0da34c5eb8d712aa9cc",
  "signature": "9e1a35b2931bd04e6780d01c36e3e5337941aa80f173cfe4f4e249c44ab135272b834c1a639db9c89d673a8a30524042b0469672ca845458a5a0cf2cad53221b"
}

{
  "txId": "503bfb16230888af4924aa8f8250d7d348b862e267d75d3147f1998050b6da69",
  "fromGroup": 2,
  "toGroup": 1
}

{
  "detail": "string"
}

{
  "detail": "string"
}

{
  "resource": "wallet-name",
  "detail": "wallet-name not found"
}

{
  "detail": "string"
}

{
  "detail": "string"
}

Decode an unsigned transaction

POST

https://alephium.nownodes.io/transactions/decode-unsigned-tx

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Decodes a serialized unsigned transaction string and returns the detailed transaction data, including groups involved, inputs, outputs, gas parameters, and token information.

Body

application/json

unsignedTxstringrequired

Serialized unsigned transaction string to decode.

Response

200OK

Successfully decoded unsigned transaction details.

400Bad Request

BadRequest

401Unauthorized

Unauthorized

404Not Found

NotFound

500Internal Server Error

InternalServerError

503Service Unavailable

ServiceUnavailable

Decode an unsigned transaction

curl -X POST 'https://alephium.nownodes.io/transactions/decode-unsigned-tx' \
  -H 'Content-Type: application/json' \
  -d '{
    "unsignedTx": "35d1b2a520a0da34c5eb8d712aa9cc"
  }'

const response = await fetch('https://alephium.nownodes.io/transactions/decode-unsigned-tx', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "unsignedTx": "35d1b2a520a0da34c5eb8d712aa9cc"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/transactions/decode-unsigned-tx')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "unsignedTx": "35d1b2a520a0da34c5eb8d712aa9cc"
  }'

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

import requests

payload = {
  "unsignedTx": "35d1b2a520a0da34c5eb8d712aa9cc"
}

response = requests.post('https://alephium.nownodes.io/transactions/decode-unsigned-tx', json=payload)
data = response.json()

const response = await fetch('https://alephium.nownodes.io/transactions/decode-unsigned-tx', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "unsignedTx": "35d1b2a520a0da34c5eb8d712aa9cc"
    }),
});

const data = await response.json();

const endpoint = "https://alephium.nownodes.io/transactions/decode-unsigned-tx";
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({
    "unsignedTx": "35d1b2a520a0da34c5eb8d712aa9cc"
  });
console.log(result);

const response = await fetch('https://alephium.nownodes.io/transactions/decode-unsigned-tx', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "unsignedTx": "35d1b2a520a0da34c5eb8d712aa9cc"
    }),
});

const data = await response.json();

import requests

payload = {
  "unsignedTx": "35d1b2a520a0da34c5eb8d712aa9cc"
}

response = requests.post('https://alephium.nownodes.io/transactions/decode-unsigned-tx', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/transactions/decode-unsigned-tx')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "unsignedTx": "35d1b2a520a0da34c5eb8d712aa9cc"
  }'

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

Request Body

{
  "unsignedTx": "35d1b2a520a0da34c5eb8d712aa9cc"
}

{
  "fromGroup": 1,
  "toGroup": 2,
  "unsignedTx": {
    "txId": "503bfb16230888af4924aa8f8250d7d348b862e267d75d3147f1998050b6da69",
    "version": 1,
    "networkId": 1,
    "gasAmount": 20000,
    "gasPrice": "100000000000",
    "inputs": [
      {
        "outputRef": {
          "hint": 23412,
          "key": "798e9e137aec7c2d59d9655b4ffa640f301f628bf7c365083bb255f6aa5f89ef"
        },
        "unlockScript": "00d1b70d2226308b46da297486adb6b4f1a8c1842cb159ac5ec04f384fe2d6f5da28"
      }
    ],
    "fixedOutputs": [
      {
        "hint": 1,
        "key": "798e9e137aec7c2d59d9655b4ffa640f301f628bf7c365083bb255f6aa5f89ef",
        "attoAlphAmount": "2000000000000000000",
        "address": "1AujpupFP4KWeZvqA7itsHY9cLJmx4qTzojVZrg8W9y",
        "tokens": [
          {
            "id": "2d11fd6c12435ffb07aaed4d190a505b621b927a5f6e51b61ce0ebe186397bdd",
            "amount": "42000000000000000000"
          }
        ],
        "lockTime": 1611041396892,
        "message": "798e9e137aec7c2d59d9655b4ffa640f301f628bf7c365083bb255f6aa5f89ef"
      }
    ]
  }
}

{
  "detail": "string"
}

{
  "detail": "string"
}

{
  "resource": "wallet-name",
  "detail": "wallet-name not found"
}

{
  "detail": "string"
}

{
  "detail": "string"
}

Get detailed information of a transaction by transaction ID

GET

https://alephium.nownodes.io/transactions/details/{txId}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Retrieves detailed information about a specific transaction, including unsigned transaction data, script execution status, contract inputs and outputs, and signatures.

Parameters

txIdstringrequiredpath

Transaction ID (hash) to get details for.

fromGroupintegerquery

Originating group number of the transaction.

toGroupintegerquery

Target group number of the transaction.

Response

200OK

Successful transaction detail retrieval

400Bad Request

BadRequest

401Unauthorized

Unauthorized

404Not Found

NotFound

500Internal Server Error

InternalServerError

503Service Unavailable

ServiceUnavailable

Get detailed information of a transaction by transaction ID

curl -X GET 'https://alephium.nownodes.io/transactions/details/{txId}'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/transactions/details/{txId}')
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://alephium.nownodes.io/transactions/details/{txId}')
data = response.json()

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

const data = await response.json();

const endpoint = "https://alephium.nownodes.io/transactions/details/{txId}";
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://alephium.nownodes.io/transactions/details/{txId}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://alephium.nownodes.io/transactions/details/{txId}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/transactions/details/{txId}')
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)

{
  "unsigned": {
    "txId": "98401002e2d85e8be4765ae29ac768f4f110ee46e3a0fab3e7a754e4bcffa3c4",
    "version": 0,
    "networkId": 0,
    "gasAmount": 20000,
    "gasPrice": "1000000000",
    "inputs": [],
    "fixedOutputs": [
      {
        "hint": -1023270969,
        "key": "f777a262eacace6f015ae547ece4c9de2ebe12bac116942d72c0c67140abdfed",
        "attoAlphAmount": "191472590469365818",
        "address": "19WzSnmNC1SQ6v7RpFFXhpcMcFSiwM4nKTSdbwgSJfSHy",
        "tokens": [],
        "lockTime": 1754944650065,
        "message": "030100"
      }
    ]
  },
  "scriptExecutionOk": true,
  "contractInputs": [],
  "generatedOutputs": [],
  "inputSignatures": [],
  "scriptSignatures": []
}

{
  "detail": "string"
}

{
  "detail": "string"
}

{
  "resource": "wallet-name",
  "detail": "wallet-name not found"
}

{
  "detail": "string"
}

{
  "detail": "string"
}

Get the status of a transaction by transaction ID and group parameters

GET

https://alephium.nownodes.io/transactions/status

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the current status of a transaction, including confirmation status, block hash where it is included, index within the block, and confirmation counts across groups.

Parameters

txIdstringrequiredquery

Transaction ID (hash) to check status for

fromGroupintegerrequiredquery

Originating group number of the transaction

toGroupintegerrequiredquery

Target group number of the transaction

Response

200OK

Transaction status information

400Bad Request

BadRequest

401Unauthorized

Unauthorized

404Not Found

NotFound

500Internal Server Error

InternalServerError

503Service Unavailable

ServiceUnavailable

Get the status of a transaction by transaction ID and group parameters

curl -X GET 'https://alephium.nownodes.io/transactions/status'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/transactions/status')
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://alephium.nownodes.io/transactions/status')
data = response.json()

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

const data = await response.json();

const endpoint = "https://alephium.nownodes.io/transactions/status";
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://alephium.nownodes.io/transactions/status', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://alephium.nownodes.io/transactions/status')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/transactions/status')
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)

{
  "type": "Confirmed",
  "blockHash": "0000000000005c8d2761b8c0967d5e0dcbfe47a5678a80f676a54276d956e3ed",
  "txIndex": 0,
  "chainConfirmations": 208,
  "fromGroupConfirmations": 202,
  "toGroupConfirmations": 209
}

{
  "detail": "string"
}

{
  "detail": "string"
}

{
  "resource": "wallet-name",
  "detail": "wallet-name not found"
}

{
  "detail": "string"
}

{
  "detail": "string"
}

Mempool

Get transactions currently in the mempool

GET

https://alephium.nownodes.io/mempool/transactions

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of transactions currently waiting in the mempool, grouped by source and destination groups.

Response

200OK

A list of mempool transactions grouped by fromGroup and toGroup

400Bad Request

BadRequest

401Unauthorized

Unauthorized

404Not Found

NotFound

500Internal Server Error

InternalServerError

503Service Unavailable

ServiceUnavailable

Get transactions currently in the mempool

curl -X GET 'https://alephium.nownodes.io/mempool/transactions'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/mempool/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://alephium.nownodes.io/mempool/transactions')
data = response.json()

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

const data = await response.json();

const endpoint = "https://alephium.nownodes.io/mempool/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://alephium.nownodes.io/mempool/transactions', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://alephium.nownodes.io/mempool/transactions')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/mempool/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)

[
  {
    "fromGroup": 2,
    "toGroup": 1,
    "transactions": [
      {
        "unsigned": {
          "txId": "7df86c8c25c728160afaa7e88511329b1be8566c9110b47d9fa53b75d9931cd3",
          "version": 0,
          "networkId": 0,
          "gasAmount": 20000,
          "gasPrice": "100000000000",
          "inputs": [
            {
              "outputRef": {
                "hint": -590615467,
                "key": "4642ab5e4d1a5d2fb65768459ff845e169e20b0f217cf204d8d0811ceb334bdd"
              },
              "unlockScript": "000312656f2f81a217bf2d4cfef9d7f12b1c127f91b7a761dc119b93d942aed9a4b2"
            }
          ],
          "fixedOutputs": [
            {
              "hint": -1570538195,
              "key": "7bf65c28a1f7d928692078d65053ef9dee86372b94e255a74739b2db9bce252a",
              "attoAlphAmount": "1628000000000000000",
              "address": "19CEhknuadh8muZ3vHcdwfDA8BHJ6h9tFoEAnHNTB7UKN",
              "tokens": [
                {}
              ],
              "lockTime": 0,
              "message": ""
            }
          ]
        },
        "inputSignatures": [
          "45b1e50e85cfef84c5c9e6914ea1442d465fc3a234f85c097dbc7916f25befb860dc76b09ba556c71e624dc392acce736e0ed47ee4c17ca819c79ed6ed2e6a34"
        ],
        "scriptSignatures": [
          "string"
        ],
        "seenAt": 1754916328387
      }
    ]
  }
]

{
  "detail": "string"
}

{
  "detail": "string"
}

{
  "resource": "wallet-name",
  "detail": "wallet-name not found"
}

{
  "detail": "string"
}

{
  "detail": "string"
}

Contracts

Compile a contract script

POST

https://alephium.nownodes.io/contracts/compile-script

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Compiles a contract script written in ALPH TxScript language. Returns metadata about the compiled bytecode, fields, functions, and any warnings.

Body

application/json

codestring

The contract script source code in TxScript language

compilerOptionsobject

Compiler options to control the compilation behavior

Show child attributes

ignoreUnusedConstantsWarningsboolean

Whether to ignore warnings about unused constants

Response

200OK

Compilation result with bytecode and metadata

400Bad Request

BadRequest

401Unauthorized

Unauthorized

404Not Found

NotFound

500Internal Server Error

InternalServerError

503Service Unavailable

ServiceUnavailable

Compile a contract script

curl -X POST 'https://alephium.nownodes.io/contracts/compile-script' \
  -H 'Content-Type: application/json' \
  -d '{
    "code": "TxScript Main { let token = Token(#36cdbfabca2d71622b6) token.withdraw(@1AujpupFP4KWeZvqA7itsHY9cLJmx4qTzojVZrg8W9y, 1024) }",
    "compilerOptions": {
      "ignoreUnusedConstantsWarnings": true
    }
  }'

const response = await fetch('https://alephium.nownodes.io/contracts/compile-script', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "code": "TxScript Main { let token = Token(#36cdbfabca2d71622b6) token.withdraw(@1AujpupFP4KWeZvqA7itsHY9cLJmx4qTzojVZrg8W9y, 1024) }",
      "compilerOptions": {
        "ignoreUnusedConstantsWarnings": true
      }
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/contracts/compile-script')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "code": "TxScript Main { let token = Token(#36cdbfabca2d71622b6) token.withdraw(@1AujpupFP4KWeZvqA7itsHY9cLJmx4qTzojVZrg8W9y, 1024) }",
    "compilerOptions": {
      "ignoreUnusedConstantsWarnings": true
    }
  }'

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

import requests

payload = {
  "code": "TxScript Main { let token = Token(#36cdbfabca2d71622b6) token.withdraw(@1AujpupFP4KWeZvqA7itsHY9cLJmx4qTzojVZrg8W9y, 1024) }",
  "compilerOptions": {
    "ignoreUnusedConstantsWarnings": True
  }
}

response = requests.post('https://alephium.nownodes.io/contracts/compile-script', json=payload)
data = response.json()

const response = await fetch('https://alephium.nownodes.io/contracts/compile-script', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "code": "TxScript Main { let token = Token(#36cdbfabca2d71622b6) token.withdraw(@1AujpupFP4KWeZvqA7itsHY9cLJmx4qTzojVZrg8W9y, 1024) }",
      "compilerOptions": {
        "ignoreUnusedConstantsWarnings": true
      }
    }),
});

const data = await response.json();

const endpoint = "https://alephium.nownodes.io/contracts/compile-script";
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({
    "code": "TxScript Main { let token = Token(#36cdbfabca2d71622b6) token.withdraw(@1AujpupFP4KWeZvqA7itsHY9cLJmx4qTzojVZrg8W9y, 1024) }",
    "compilerOptions": {
      "ignoreUnusedConstantsWarnings": true
    }
  });
console.log(result);

const response = await fetch('https://alephium.nownodes.io/contracts/compile-script', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "code": "TxScript Main { let token = Token(#36cdbfabca2d71622b6) token.withdraw(@1AujpupFP4KWeZvqA7itsHY9cLJmx4qTzojVZrg8W9y, 1024) }",
      "compilerOptions": {
        "ignoreUnusedConstantsWarnings": true
      }
    }),
});

const data = await response.json();

import requests

payload = {
  "code": "TxScript Main { let token = Token(#36cdbfabca2d71622b6) token.withdraw(@1AujpupFP4KWeZvqA7itsHY9cLJmx4qTzojVZrg8W9y, 1024) }",
  "compilerOptions": {
    "ignoreUnusedConstantsWarnings": True
  }
}

response = requests.post('https://alephium.nownodes.io/contracts/compile-script', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/contracts/compile-script')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "code": "TxScript Main { let token = Token(#36cdbfabca2d71622b6) token.withdraw(@1AujpupFP4KWeZvqA7itsHY9cLJmx4qTzojVZrg8W9y, 1024) }",
    "compilerOptions": {
      "ignoreUnusedConstantsWarnings": true
    }
  }'

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

Request Body

{
  "code": "TxScript Main { let token = Token(#36cdbfabca2d71622b6) token.withdraw(@1AujpupFP4KWeZvqA7itsHY9cLJmx4qTzojVZrg8W9y, 1024) }",
  "compilerOptions": {
    "ignoreUnusedConstantsWarnings": true
  }
}

{
  "version": "v0.0.1",
  "name": "Main",
  "bytecodeTemplate": "35d1b2a520a0da34c5eb8d712aa9cc",
  "bytecodeDebugPatch": "=1-1+ef",
  "fields": {
    "names": [
      "aa",
      "bb",
      "cc",
      "dd",
      "ee"
    ],
    "types": [
      "Bool",
      "U256",
      "I256",
      "ByteVec",
      "Address"
    ],
    "isMutable": [
      false,
      true,
      false,
      true,
      false
    ]
  },
  "functions": [
    {
      "name": "bar",
      "usePreapprovedAssets": false,
      "useAssetsInContract": false,
      "isPublic": true,
      "paramNames": [
        "a",
        "b",
        "c",
        "d",
        "e"
      ],
      "paramTypes": [
        "Bool",
        "U256",
        "I256",
        "ByteVec",
        "Address"
      ],
      "paramIsMutable": [
        false,
        true,
        false,
        true,
        false
      ],
      "returnTypes": [
        "U256",
        "I256",
        "ByteVec",
        "Address"
      ]
    }
  ],
  "warnings": [
    "Found unused fields in Foo: a"
  ]
}

{
  "detail": "string"
}

{
  "detail": "string"
}

{
  "resource": "wallet-name",
  "detail": "wallet-name not found"
}

{
  "detail": "string"
}

{
  "detail": "string"
}

Build an unsigned script

POST

https://alephium.nownodes.io/contracts/unsigned-tx/execute-script

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Body

application/json

fromPublicKeystring<hex-string>required

fromPublicKeyTypestring<hex-string>

bytecodestring<hex-string>required

attoAlphAmountstring<uint256>

tokensArray<Token>

Show child attributes

idstring<32-byte-hash>required

amountstring<uint256>required

gasAmountinteger<gas>

gasPricestring<uint256>

targetBlockHashstring<block-hash>

gasEstimationMultipliernumber<double>

Response

200OK

Valid response

400Bad Request

BadRequest

401Unauthorized

Unauthorized

404Not Found

NotFound

500Internal Server Error

InternalServerError

503Service Unavailable

ServiceUnavailable

Build an unsigned script

curl -X POST 'https://alephium.nownodes.io/contracts/unsigned-tx/execute-script' \
  -H 'Content-Type: application/json' \
  -d '{
    "fromPublicKey": "string",
    "fromPublicKeyType": "string",
    "bytecode": "string",
    "attoAlphAmount": "string",
    "tokens": [
      {
        "id": "string",
        "amount": "string"
      }
    ],
    "gasAmount": 0,
    "gasPrice": "string",
    "targetBlockHash": "string",
    "gasEstimationMultiplier": 0
  }'

const response = await fetch('https://alephium.nownodes.io/contracts/unsigned-tx/execute-script', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "fromPublicKey": "string",
      "fromPublicKeyType": "string",
      "bytecode": "string",
      "attoAlphAmount": "string",
      "tokens": [
        {
          "id": "string",
          "amount": "string"
        }
      ],
      "gasAmount": 0,
      "gasPrice": "string",
      "targetBlockHash": "string",
      "gasEstimationMultiplier": 0
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/contracts/unsigned-tx/execute-script')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "fromPublicKey": "string",
    "fromPublicKeyType": "string",
    "bytecode": "string",
    "attoAlphAmount": "string",
    "tokens": [
      {
        "id": "string",
        "amount": "string"
      }
    ],
    "gasAmount": 0,
    "gasPrice": "string",
    "targetBlockHash": "string",
    "gasEstimationMultiplier": 0
  }'

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

import requests

payload = {
  "fromPublicKey": "string",
  "fromPublicKeyType": "string",
  "bytecode": "string",
  "attoAlphAmount": "string",
  "tokens": [
    {
      "id": "string",
      "amount": "string"
    }
  ],
  "gasAmount": 0,
  "gasPrice": "string",
  "targetBlockHash": "string",
  "gasEstimationMultiplier": 0
}

response = requests.post('https://alephium.nownodes.io/contracts/unsigned-tx/execute-script', json=payload)
data = response.json()

const response = await fetch('https://alephium.nownodes.io/contracts/unsigned-tx/execute-script', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "fromPublicKey": "string",
      "fromPublicKeyType": "string",
      "bytecode": "string",
      "attoAlphAmount": "string",
      "tokens": [
        {
          "id": "string",
          "amount": "string"
        }
      ],
      "gasAmount": 0,
      "gasPrice": "string",
      "targetBlockHash": "string",
      "gasEstimationMultiplier": 0
    }),
});

const data = await response.json();

const endpoint = "https://alephium.nownodes.io/contracts/unsigned-tx/execute-script";
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({
    "fromPublicKey": "string",
    "fromPublicKeyType": "string",
    "bytecode": "string",
    "attoAlphAmount": "string",
    "tokens": [
      {
        "id": "string",
        "amount": "string"
      }
    ],
    "gasAmount": 0,
    "gasPrice": "string",
    "targetBlockHash": "string",
    "gasEstimationMultiplier": 0
  });
console.log(result);

const response = await fetch('https://alephium.nownodes.io/contracts/unsigned-tx/execute-script', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "fromPublicKey": "string",
      "fromPublicKeyType": "string",
      "bytecode": "string",
      "attoAlphAmount": "string",
      "tokens": [
        {
          "id": "string",
          "amount": "string"
        }
      ],
      "gasAmount": 0,
      "gasPrice": "string",
      "targetBlockHash": "string",
      "gasEstimationMultiplier": 0
    }),
});

const data = await response.json();

import requests

payload = {
  "fromPublicKey": "string",
  "fromPublicKeyType": "string",
  "bytecode": "string",
  "attoAlphAmount": "string",
  "tokens": [
    {
      "id": "string",
      "amount": "string"
    }
  ],
  "gasAmount": 0,
  "gasPrice": "string",
  "targetBlockHash": "string",
  "gasEstimationMultiplier": 0
}

response = requests.post('https://alephium.nownodes.io/contracts/unsigned-tx/execute-script', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/contracts/unsigned-tx/execute-script')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "fromPublicKey": "string",
    "fromPublicKeyType": "string",
    "bytecode": "string",
    "attoAlphAmount": "string",
    "tokens": [
      {
        "id": "string",
        "amount": "string"
      }
    ],
    "gasAmount": 0,
    "gasPrice": "string",
    "targetBlockHash": "string",
    "gasEstimationMultiplier": 0
  }'

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

Request Body

{
  "fromPublicKey": "d1b70d2226308b46da297486adb6b4f1a8c1842cb159ac5ec04f384fe2d6f5da28",
  "bytecode": "35d1b2a520a0da34c5eb8d712aa9cc"
}

{
  "fromPublicKey": "d1b70d2226308b46da297486adb6b4f1a8c1842cb159ac5ec04f384fe2d6f5da28",
  "fromPublicKeyType": "default",
  "bytecode": "35d1b2a520a0da34c5eb8d712aa9cc",
  "attoAlphAmount": "1000000000000000",
  "tokens": [
    {
      "id": "2d11fd6c12435ffb07aaed4d190a505b621b927a5f6e51b61ce0ebe186397bdd",
      "amount": "42000000000000000000"
    },
    {
      "id": "bd165d20bd063c7a023d22232a1e75bf46e904067f92b49323fe89fa0fd586bf",
      "amount": "1000000000000000000000"
    }
  ],
  "gasAmount": 20000,
  "gasPrice": "100000000000"
}

{
  "fromGroup": 2,
  "toGroup": 2,
  "unsignedTx": "35d1b2a520a0da34c5eb8d712aa9cc",
  "gasAmount": 20000,
  "gasPrice": "100000000000",
  "txId": "503bfb16230888af4924aa8f8250d7d348b862e267d75d3147f1998050b6da69"
}

{
  "detail": "string"
}

{
  "detail": "string"
}

{
  "resource": "wallet-name",
  "detail": "wallet-name not found"
}

{
  "detail": "string"
}

{
  "detail": "string"
}

Compile a smart contract

POST

https://alephium.nownodes.io/contracts/compile-contract

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Body

application/json

codestringrequired

compilerOptionsCompilerOptions

Show child attributes

ignoreUnusedConstantsWarningsboolean

ignoreUnusedVariablesWarningsboolean

ignoreUnusedFieldsWarningsboolean

ignoreUnusedPrivateFunctionsWarningsboolean

ignoreUpdateFieldsCheckWarningsboolean

ignoreCheckExternalCallerWarningsboolean

Response

200OK

Valid response

400Bad Request

BadRequest

401Unauthorized

Unauthorized

404Not Found

NotFound

500Internal Server Error

InternalServerError

503Service Unavailable

ServiceUnavailable

Compile a smart contract

curl -X POST 'https://alephium.nownodes.io/contracts/compile-contract' \
  -H 'Content-Type: application/json' \
  -d '{
    "code": "Contract Foo(bar: ByteVec) {\n pub fn baz(amount: U256) -> () {\nissueToken!(amount)\n}}",
    "compilerOptions": {
      "ignoreUnusedConstantsWarnings": true
    }
  }'

const response = await fetch('https://alephium.nownodes.io/contracts/compile-contract', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "code": "Contract Foo(bar: ByteVec) {\n pub fn baz(amount: U256) -> () {\nissueToken!(amount)\n}}",
      "compilerOptions": {
        "ignoreUnusedConstantsWarnings": true
      }
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/contracts/compile-contract')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "code": "Contract Foo(bar: ByteVec) {\\n pub fn baz(amount: U256) -> () {\\nissueToken!(amount)\\n}}",
    "compilerOptions": {
      "ignoreUnusedConstantsWarnings": true
    }
  }'

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

import requests

payload = {
  "code": "Contract Foo(bar: ByteVec) {\n pub fn baz(amount: U256) -> () {\nissueToken!(amount)\n}}",
  "compilerOptions": {
    "ignoreUnusedConstantsWarnings": True
  }
}

response = requests.post('https://alephium.nownodes.io/contracts/compile-contract', json=payload)
data = response.json()

const response = await fetch('https://alephium.nownodes.io/contracts/compile-contract', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "code": "Contract Foo(bar: ByteVec) {\n pub fn baz(amount: U256) -> () {\nissueToken!(amount)\n}}",
      "compilerOptions": {
        "ignoreUnusedConstantsWarnings": true
      }
    }),
});

const data = await response.json();

const endpoint = "https://alephium.nownodes.io/contracts/compile-contract";
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({
    "code": "Contract Foo(bar: ByteVec) {\n pub fn baz(amount: U256) -> () {\nissueToken!(amount)\n}}",
    "compilerOptions": {
      "ignoreUnusedConstantsWarnings": true
    }
  });
console.log(result);

const response = await fetch('https://alephium.nownodes.io/contracts/compile-contract', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "code": "Contract Foo(bar: ByteVec) {\n pub fn baz(amount: U256) -> () {\nissueToken!(amount)\n}}",
      "compilerOptions": {
        "ignoreUnusedConstantsWarnings": true
      }
    }),
});

const data = await response.json();

import requests

payload = {
  "code": "Contract Foo(bar: ByteVec) {\n pub fn baz(amount: U256) -> () {\nissueToken!(amount)\n}}",
  "compilerOptions": {
    "ignoreUnusedConstantsWarnings": True
  }
}

response = requests.post('https://alephium.nownodes.io/contracts/compile-contract', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/contracts/compile-contract')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "code": "Contract Foo(bar: ByteVec) {\\n pub fn baz(amount: U256) -> () {\\nissueToken!(amount)\\n}}",
    "compilerOptions": {
      "ignoreUnusedConstantsWarnings": true
    }
  }'

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

Request Body

{
  "code": "Contract Foo(bar: ByteVec) {\n pub fn baz(amount: U256) -> () {\nissueToken!(amount)\n}}",
  "compilerOptions": {
    "ignoreUnusedConstantsWarnings": true
  }
}

{
  "version": "v0.0.1",
  "name": "Foo",
  "bytecode": "35d1b2a520a0da34c5eb8d712aa9cc",
  "bytecodeDebugPatch": "=1-1+ef",
  "codeHash": "798e9e137aec7c2d59d9655b4ffa640f301f628bf7c365083bb255f6aa5f89ef",
  "codeHashDebug": "798e9e137aec7c2d59d9655b4ffa640f301f628bf7c365083bb255f6aa5f89ef",
  "fields": {
    "names": [
      "aa",
      "bb",
      "cc",
      "dd",
      "ee"
    ],
    "types": [
      "Bool",
      "U256",
      "I256",
      "ByteVec",
      "Address"
    ],
    "isMutable": [
      false,
      true,
      false,
      true,
      false
    ]
  },
  "functions": [
    {
      "name": "bar",
      "usePreapprovedAssets": false,
      "useAssetsInContract": false,
      "isPublic": true,
      "paramNames": [
        "a",
        "b",
        "c",
        "d",
        "e"
      ],
      "paramTypes": [
        "Bool",
        "U256",
        "I256",
        "ByteVec",
        "Address"
      ],
      "paramIsMutable": [
        false,
        true,
        false,
        true,
        false
      ],
      "returnTypes": [
        "U256",
        "I256",
        "ByteVec",
        "Address"
      ]
    }
  ],
  "constants": [
    {
      "name": "A",
      "value": {
        "type": "Bool",
        "value": true
      }
    }
  ],
  "enums": [
    {
      "name": "Color",
      "fields": [
        {
          "name": "Red",
          "value": {
            "type": "U256",
            "value": "0"
          }
        },
        {
          "name": "Blue",
          "value": {
            "type": "U256",
            "value": "1"
          }
        }
      ]
    }
  ],
  "events": [
    {
      "name": "Bar",
      "fieldNames": [
        "a",
        "b",
        "d",
        "e"
      ],
      "fieldTypes": [
        "Bool",
        "U256",
        "ByteVec",
        "Address"
      ]
    }
  ],
  "warnings": [
    "Found unused fields in Foo: a"
  ],
  "maps": {
    "names": [
      "foo"
    ],
    "types": [
      "Map[U256,U256]"
    ]
  },
  "stdInterfaceId": "0001"
}

{
  "detail": "string"
}

{
  "detail": "string"
}

{
  "resource": "wallet-name",
  "detail": "wallet-name not found"
}

{
  "detail": "string"
}

{
  "detail": "string"
}

Compile a project

POST

https://alephium.nownodes.io/contracts/compile-project

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Body

application/json

codestringrequired

compilerOptionsCompilerOptions

Show child attributes

ignoreUnusedConstantsWarningsboolean

ignoreUnusedVariablesWarningsboolean

ignoreUnusedFieldsWarningsboolean

ignoreUnusedPrivateFunctionsWarningsboolean

ignoreUpdateFieldsCheckWarningsboolean

ignoreCheckExternalCallerWarningsboolean

Response

200OK

Valid response

400Bad Request

BadRequest

401Unauthorized

Unauthorized

404Not Found

NotFound

500Internal Server Error

InternalServerError

503Service Unavailable

ServiceUnavailable

Compile a project

curl -X POST 'https://alephium.nownodes.io/contracts/compile-project' \
  -H 'Content-Type: application/json' \
  -d '{
    "code": "Contract Foo() {\n pub fn foo() -> () {}\n }\n TxScript Main(id: ByteVec) {\n Foo(id).foo() \n}",
    "compilerOptions": {
      "ignoreUnusedConstantsWarnings": true
    }
  }'

const response = await fetch('https://alephium.nownodes.io/contracts/compile-project', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "code": "Contract Foo() {\n pub fn foo() -> () {}\n }\n TxScript Main(id: ByteVec) {\n Foo(id).foo() \n}",
      "compilerOptions": {
        "ignoreUnusedConstantsWarnings": true
      }
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/contracts/compile-project')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "code": "Contract Foo() {\\n pub fn foo() -> () {}\\n }\\n TxScript Main(id: ByteVec) {\\n Foo(id).foo() \\n}",
    "compilerOptions": {
      "ignoreUnusedConstantsWarnings": true
    }
  }'

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

import requests

payload = {
  "code": "Contract Foo() {\n pub fn foo() -> () {}\n }\n TxScript Main(id: ByteVec) {\n Foo(id).foo() \n}",
  "compilerOptions": {
    "ignoreUnusedConstantsWarnings": True
  }
}

response = requests.post('https://alephium.nownodes.io/contracts/compile-project', json=payload)
data = response.json()

const response = await fetch('https://alephium.nownodes.io/contracts/compile-project', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "code": "Contract Foo() {\n pub fn foo() -> () {}\n }\n TxScript Main(id: ByteVec) {\n Foo(id).foo() \n}",
      "compilerOptions": {
        "ignoreUnusedConstantsWarnings": true
      }
    }),
});

const data = await response.json();

const endpoint = "https://alephium.nownodes.io/contracts/compile-project";
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({
    "code": "Contract Foo() {\n pub fn foo() -> () {}\n }\n TxScript Main(id: ByteVec) {\n Foo(id).foo() \n}",
    "compilerOptions": {
      "ignoreUnusedConstantsWarnings": true
    }
  });
console.log(result);

const response = await fetch('https://alephium.nownodes.io/contracts/compile-project', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "code": "Contract Foo() {\n pub fn foo() -> () {}\n }\n TxScript Main(id: ByteVec) {\n Foo(id).foo() \n}",
      "compilerOptions": {
        "ignoreUnusedConstantsWarnings": true
      }
    }),
});

const data = await response.json();

import requests

payload = {
  "code": "Contract Foo() {\n pub fn foo() -> () {}\n }\n TxScript Main(id: ByteVec) {\n Foo(id).foo() \n}",
  "compilerOptions": {
    "ignoreUnusedConstantsWarnings": True
  }
}

response = requests.post('https://alephium.nownodes.io/contracts/compile-project', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/contracts/compile-project')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "code": "Contract Foo() {\\n pub fn foo() -> () {}\\n }\\n TxScript Main(id: ByteVec) {\\n Foo(id).foo() \\n}",
    "compilerOptions": {
      "ignoreUnusedConstantsWarnings": true
    }
  }'

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

Request Body

{
  "code": "Contract Foo() {\n pub fn foo() -> () {}\n }\n TxScript Main(id: ByteVec) {\n Foo(id).foo() \n}",
  "compilerOptions": {
    "ignoreUnusedConstantsWarnings": true
  }
}

{
  "contracts": [
    {
      "version": "v0.0.1",
      "name": "Foo",
      "bytecode": "35d1b2a520a0da34c5eb8d712aa9cc",
      "bytecodeDebugPatch": "=1-1+ef",
      "codeHash": "798e9e137aec7c2d59d9655b4ffa640f301f628bf7c365083bb255f6aa5f89ef",
      "codeHashDebug": "798e9e137aec7c2d59d9655b4ffa640f301f628bf7c365083bb255f6aa5f89ef",
      "fields": {
        "names": [
          "aa",
          "bb",
          "cc",
          "dd",
          "ee"
        ],
        "types": [
          "Bool",
          "U256",
          "I256",
          "ByteVec",
          "Address"
        ],
        "isMutable": [
          false,
          true,
          false,
          true,
          false
        ]
      },
      "functions": [
        {
          "name": "bar",
          "usePreapprovedAssets": false,
          "useAssetsInContract": false,
          "isPublic": true,
          "paramNames": [
            "a",
            "b",
            "c",
            "d",
            "e"
          ],
          "paramTypes": [
            "Bool",
            "U256",
            "I256",
            "ByteVec",
            "Address"
          ],
          "paramIsMutable": [
            false,
            true,
            false,
            true,
            false
          ],
          "returnTypes": [
            "U256",
            "I256",
            "ByteVec",
            "Address"
          ]
        }
      ],
      "constants": [
        {
          "name": "A",
          "value": {
            "type": "Bool",
            "value": true
          }
        }
      ],
      "enums": [
        {
          "name": "Color",
          "fields": [
            {
              "name": "Red",
              "value": {
                "type": "U256",
                "value": "0"
              }
            },
            {
              "name": "Blue",
              "value": {
                "type": "U256",
                "value": "1"
              }
            }
          ]
        }
      ],
      "events": [
        {
          "name": "Bar",
          "fieldNames": [
            "a",
            "b",
            "d",
            "e"
          ],
          "fieldTypes": [
            "Bool",
            "U256",
            "ByteVec",
            "Address"
          ]
        }
      ],
      "warnings": [
        "Found unused fields in Foo: a"
      ],
      "maps": {
        "names": [
          "foo"
        ],
        "types": [
          "Map[U256,U256]"
        ]
      },
      "stdInterfaceId": "0001"
    }
  ],
  "scripts": [
    {
      "version": "v0.0.1",
      "name": "Main",
      "bytecodeTemplate": "35d1b2a520a0da34c5eb8d712aa9cc",
      "bytecodeDebugPatch": "=1-1+ef",
      "fields": {
        "names": [
          "aa",
          "bb",
          "cc",
          "dd",
          "ee"
        ],
        "types": [
          "Bool",
          "U256",
          "I256",
          "ByteVec",
          "Address"
        ],
        "isMutable": [
          false,
          true,
          false,
          true,
          false
        ]
      },
      "functions": [
        {
          "name": "bar",
          "usePreapprovedAssets": false,
          "useAssetsInContract": false,
          "isPublic": true,
          "paramNames": [
            "a",
            "b",
            "c",
            "d",
            "e"
          ],
          "paramTypes": [
            "Bool",
            "U256",
            "I256",
            "ByteVec",
            "Address"
          ],
          "paramIsMutable": [
            false,
            true,
            false,
            true,
            false
          ],
          "returnTypes": [
            "U256",
            "I256",
            "ByteVec",
            "Address"
          ]
        }
      ],
      "warnings": [
        "Found unused fields in Foo: a"
      ]
    }
  ],
  "structs": [
    {
      "name": "Foo",
      "fieldNames": [
        "amount",
        "id"
      ],
      "fieldTypes": [
        "U256",
        "ByteVec"
      ],
      "isMutable": [
        false,
        true
      ]
    }
  ]
}

{
  "detail": "string"
}

{
  "detail": "string"
}

{
  "resource": "wallet-name",
  "detail": "wallet-name not found"
}

{
  "detail": "string"
}

{
  "detail": "string"
}

Build an unsigned contract

POST

https://alephium.nownodes.io/contracts/unsigned-tx/deploy-contract

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Body

application/json

fromPublicKeystring<hex-string>required

fromPublicKeyTypestring<hex-string>

bytecodestring<hex-string>required

initialAttoAlphAmountstring<uint256>

initialTokenAmountsArray<Token>

Show child attributes

idstring<32-byte-hash>required

amountstring<uint256>required

issueTokenAmountstring<uint256>

issueTokenTostring<address>

gasAmountinteger<gas>

gasPricestring<uint256>

targetBlockHashstring<block-hash>

Response

200OK

Valid response

400Bad Request

BadRequest

401Unauthorized

Unauthorized

404Not Found

NotFound

500Internal Server Error

InternalServerError

503Service Unavailable

ServiceUnavailable

Build an unsigned contract

curl -X POST 'https://alephium.nownodes.io/contracts/unsigned-tx/deploy-contract' \
  -H 'Content-Type: application/json' \
  -d '{
    "fromPublicKey": "string",
    "fromPublicKeyType": "string",
    "bytecode": "string",
    "initialAttoAlphAmount": "string",
    "initialTokenAmounts": [
      {
        "id": "string",
        "amount": "string"
      }
    ],
    "issueTokenAmount": "string",
    "issueTokenTo": "string",
    "gasAmount": 0,
    "gasPrice": "string",
    "targetBlockHash": "string"
  }'

const response = await fetch('https://alephium.nownodes.io/contracts/unsigned-tx/deploy-contract', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "fromPublicKey": "string",
      "fromPublicKeyType": "string",
      "bytecode": "string",
      "initialAttoAlphAmount": "string",
      "initialTokenAmounts": [
        {
          "id": "string",
          "amount": "string"
        }
      ],
      "issueTokenAmount": "string",
      "issueTokenTo": "string",
      "gasAmount": 0,
      "gasPrice": "string",
      "targetBlockHash": "string"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/contracts/unsigned-tx/deploy-contract')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "fromPublicKey": "string",
    "fromPublicKeyType": "string",
    "bytecode": "string",
    "initialAttoAlphAmount": "string",
    "initialTokenAmounts": [
      {
        "id": "string",
        "amount": "string"
      }
    ],
    "issueTokenAmount": "string",
    "issueTokenTo": "string",
    "gasAmount": 0,
    "gasPrice": "string",
    "targetBlockHash": "string"
  }'

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

import requests

payload = {
  "fromPublicKey": "string",
  "fromPublicKeyType": "string",
  "bytecode": "string",
  "initialAttoAlphAmount": "string",
  "initialTokenAmounts": [
    {
      "id": "string",
      "amount": "string"
    }
  ],
  "issueTokenAmount": "string",
  "issueTokenTo": "string",
  "gasAmount": 0,
  "gasPrice": "string",
  "targetBlockHash": "string"
}

response = requests.post('https://alephium.nownodes.io/contracts/unsigned-tx/deploy-contract', json=payload)
data = response.json()

const response = await fetch('https://alephium.nownodes.io/contracts/unsigned-tx/deploy-contract', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "fromPublicKey": "string",
      "fromPublicKeyType": "string",
      "bytecode": "string",
      "initialAttoAlphAmount": "string",
      "initialTokenAmounts": [
        {
          "id": "string",
          "amount": "string"
        }
      ],
      "issueTokenAmount": "string",
      "issueTokenTo": "string",
      "gasAmount": 0,
      "gasPrice": "string",
      "targetBlockHash": "string"
    }),
});

const data = await response.json();

const endpoint = "https://alephium.nownodes.io/contracts/unsigned-tx/deploy-contract";
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({
    "fromPublicKey": "string",
    "fromPublicKeyType": "string",
    "bytecode": "string",
    "initialAttoAlphAmount": "string",
    "initialTokenAmounts": [
      {
        "id": "string",
        "amount": "string"
      }
    ],
    "issueTokenAmount": "string",
    "issueTokenTo": "string",
    "gasAmount": 0,
    "gasPrice": "string",
    "targetBlockHash": "string"
  });
console.log(result);

const response = await fetch('https://alephium.nownodes.io/contracts/unsigned-tx/deploy-contract', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "fromPublicKey": "string",
      "fromPublicKeyType": "string",
      "bytecode": "string",
      "initialAttoAlphAmount": "string",
      "initialTokenAmounts": [
        {
          "id": "string",
          "amount": "string"
        }
      ],
      "issueTokenAmount": "string",
      "issueTokenTo": "string",
      "gasAmount": 0,
      "gasPrice": "string",
      "targetBlockHash": "string"
    }),
});

const data = await response.json();

import requests

payload = {
  "fromPublicKey": "string",
  "fromPublicKeyType": "string",
  "bytecode": "string",
  "initialAttoAlphAmount": "string",
  "initialTokenAmounts": [
    {
      "id": "string",
      "amount": "string"
    }
  ],
  "issueTokenAmount": "string",
  "issueTokenTo": "string",
  "gasAmount": 0,
  "gasPrice": "string",
  "targetBlockHash": "string"
}

response = requests.post('https://alephium.nownodes.io/contracts/unsigned-tx/deploy-contract', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/contracts/unsigned-tx/deploy-contract')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "fromPublicKey": "string",
    "fromPublicKeyType": "string",
    "bytecode": "string",
    "initialAttoAlphAmount": "string",
    "initialTokenAmounts": [
      {
        "id": "string",
        "amount": "string"
      }
    ],
    "issueTokenAmount": "string",
    "issueTokenTo": "string",
    "gasAmount": 0,
    "gasPrice": "string",
    "targetBlockHash": "string"
  }'

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

Request Body

{
  "fromPublicKey": "d1b70d2226308b46da297486adb6b4f1a8c1842cb159ac5ec04f384fe2d6f5da28",
  "bytecode": "35d1b2a520a0da34c5eb8d712aa9cc"
}

{
  "fromPublicKey": "d1b70d2226308b46da297486adb6b4f1a8c1842cb159ac5ec04f384fe2d6f5da28",
  "fromPublicKeyType": "bip340-schnorr",
  "bytecode": "35d1b2a520a0da34c5eb8d712aa9cc",
  "initialAttoAlphAmount": "2000000000000000000",
  "initialTokenAmounts": [
    {
      "id": "2d11fd6c12435ffb07aaed4d190a505b621b927a5f6e51b61ce0ebe186397bdd",
      "amount": "42000000000000000000"
    },
    {
      "id": "bd165d20bd063c7a023d22232a1e75bf46e904067f92b49323fe89fa0fd586bf",
      "amount": "1000000000000000000000"
    }
  ],
  "issueTokenAmount": "2000000000000000000",
  "issueTokenTo": "1AujpupFP4KWeZvqA7itsHY9cLJmx4qTzojVZrg8W9y",
  "gasAmount": 20000,
  "gasPrice": "100000000000"
}

{
  "fromGroup": 2,
  "toGroup": 2,
  "unsignedTx": "35d1b2a520a0da34c5eb8d712aa9cc",
  "gasAmount": 20000,
  "gasPrice": "100000000000",
  "txId": "503bfb16230888af4924aa8f8250d7d348b862e267d75d3147f1998050b6da69",
  "contractAddress": "vSxdLL2kE3o6vJBdKkdgmS3W39G3ZEmFHpo2y1jnbzBq"
}

{
  "detail": "string"
}

{
  "detail": "string"
}

{
  "resource": "wallet-name",
  "detail": "wallet-name not found"
}

{
  "detail": "string"
}

{
  "detail": "string"
}

Get contract state

GET

https://alephium.nownodes.io/contracts/{address}/state

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

addressstring<address>requiredpath

Response

200OK

Valid response

400Bad Request

BadRequest

401Unauthorized

Unauthorized

404Not Found

NotFound

500Internal Server Error

InternalServerError

503Service Unavailable

ServiceUnavailable

Get contract state

curl -X GET 'https://alephium.nownodes.io/contracts/{address}/state'

const response = await fetch('https://alephium.nownodes.io/contracts/{address}/state', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/contracts/{address}/state')
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://alephium.nownodes.io/contracts/{address}/state')
data = response.json()

const response = await fetch('https://alephium.nownodes.io/contracts/{address}/state', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://alephium.nownodes.io/contracts/{address}/state";
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://alephium.nownodes.io/contracts/{address}/state', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://alephium.nownodes.io/contracts/{address}/state')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/contracts/{address}/state')
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": "vYZdgzNHHp7Qh9U5Rrv5H65eSJCGQTXEC4yuQCZ7mosA",
  "bytecode": "00010700000000000118",
  "codeHash": "c49d951065f85d0c673d33930e8476240c010a52313f99889ae06d9f0d92d2f9",
  "initialStateHash": "e195a4e597e62a6802a456224008b896566b7c961023954fab808a0f83d8ad63",
  "immFields": [
    {
      "type": "U256",
      "value": "1000000000000000000"
    }
  ],
  "mutFields": [
    {
      "type": "U256",
      "value": "2000000000000000000"
    }
  ],
  "asset": {
    "attoAlphAmount": "2000000000000000000",
    "tokens": [
      {
        "id": "bd165d20bd063c7a023d22232a1e75bf46e904067f92b49323fe89fa0fd586bf",
        "amount": "2000000000"
      }
    ]
  }
}

{
  "detail": "string"
}

{
  "detail": "string"
}

{
  "resource": "wallet-name",
  "detail": "wallet-name not found"
}

{
  "detail": "string"
}

{
  "detail": "string"
}

Test contract

POST

https://alephium.nownodes.io/contracts/test-contract

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Body

application/json

any

Response

200OK

Valid response

400Bad Request

BadRequest

401Unauthorized

Unauthorized

404Not Found

NotFound

500Internal Server Error

InternalServerError

503Service Unavailable

ServiceUnavailable

Test contract

curl -X POST 'https://alephium.nownodes.io/contracts/test-contract' \
  -H 'Content-Type: application/json' \
  -d '{
    "group": 0,
    "address": "tgx7VNFoP9DJiFMFgXXtafQZkUvyEdDHT9ryamHJYrjq",
    "bytecode": "00010700000000000118",
    "initialImmFields": [
      {
        "type": "U256",
        "value": "1000000000000000000"
      }
    ],
    "initialMutFields": [
      {
        "type": "U256",
        "value": "2000000000000000000"
      }
    ],
    "initialAsset": {
      "attoAlphAmount": "1000000000000000000",
      "tokens": [
        {
          "id": "2d11fd6c12435ffb07aaed4d190a505b621b927a5f6e51b61ce0ebe186397bdd",
          "amount": "1000000000"
        }
      ]
    },
    "methodIndex": 0,
    "args": [
      {
        "type": "U256",
        "value": "1000000000000000000"
      }
    ],
    "existingContracts": [
      {
        "address": "vYZdgzNHHp7Qh9U5Rrv5H65eSJCGQTXEC4yuQCZ7mosA",
        "bytecode": "00010700000000000118",
        "codeHash": "c49d951065f85d0c673d33930e8476240c010a52313f99889ae06d9f0d92d2f9",
        "initialStateHash": "e195a4e597e62a6802a456224008b896566b7c961023954fab808a0f83d8ad63",
        "immFields": [
          {
            "type": "U256",
            "value": "1000000000000000000"
          }
        ],
        "mutFields": [
          {
            "type": "U256",
            "value": "2000000000000000000"
          }
        ],
        "asset": {
          "attoAlphAmount": "2000000000000000000",
          "tokens": [
            {
              "id": "bd165d20bd063c7a023d22232a1e75bf46e904067f92b49323fe89fa0fd586bf",
              "amount": "2000000000"
            }
          ]
        }
      }
    ],
    "inputAssets": [
      {
        "address": "1AujpupFP4KWeZvqA7itsHY9cLJmx4qTzojVZrg8W9y",
        "asset": {
          "attoAlphAmount": "3000000000000000000",
          "tokens": [
            {
              "id": "20aa1fcc865087d7788302d087e4bc76691218ce5d5013dd1cedaabfac19cca4",
              "amount": "3000000000"
            }
          ]
        }
      }
    ]
  }'

const response = await fetch('https://alephium.nownodes.io/contracts/test-contract', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "group": 0,
      "address": "tgx7VNFoP9DJiFMFgXXtafQZkUvyEdDHT9ryamHJYrjq",
      "bytecode": "00010700000000000118",
      "initialImmFields": [
        {
          "type": "U256",
          "value": "1000000000000000000"
        }
      ],
      "initialMutFields": [
        {
          "type": "U256",
          "value": "2000000000000000000"
        }
      ],
      "initialAsset": {
        "attoAlphAmount": "1000000000000000000",
        "tokens": [
          {
            "id": "2d11fd6c12435ffb07aaed4d190a505b621b927a5f6e51b61ce0ebe186397bdd",
            "amount": "1000000000"
          }
        ]
      },
      "methodIndex": 0,
      "args": [
        {
          "type": "U256",
          "value": "1000000000000000000"
        }
      ],
      "existingContracts": [
        {
          "address": "vYZdgzNHHp7Qh9U5Rrv5H65eSJCGQTXEC4yuQCZ7mosA",
          "bytecode": "00010700000000000118",
          "codeHash": "c49d951065f85d0c673d33930e8476240c010a52313f99889ae06d9f0d92d2f9",
          "initialStateHash": "e195a4e597e62a6802a456224008b896566b7c961023954fab808a0f83d8ad63",
          "immFields": [
            {
              "type": "U256",
              "value": "1000000000000000000"
            }
          ],
          "mutFields": [
            {
              "type": "U256",
              "value": "2000000000000000000"
            }
          ],
          "asset": {
            "attoAlphAmount": "2000000000000000000",
            "tokens": [
              {
                "id": "bd165d20bd063c7a023d22232a1e75bf46e904067f92b49323fe89fa0fd586bf",
                "amount": "2000000000"
              }
            ]
          }
        }
      ],
      "inputAssets": [
        {
          "address": "1AujpupFP4KWeZvqA7itsHY9cLJmx4qTzojVZrg8W9y",
          "asset": {
            "attoAlphAmount": "3000000000000000000",
            "tokens": [
              {
                "id": "20aa1fcc865087d7788302d087e4bc76691218ce5d5013dd1cedaabfac19cca4",
                "amount": "3000000000"
              }
            ]
          }
        }
      ]
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/contracts/test-contract')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "group": 0,
    "address": "tgx7VNFoP9DJiFMFgXXtafQZkUvyEdDHT9ryamHJYrjq",
    "bytecode": "00010700000000000118",
    "initialImmFields": [
      {
        "type": "U256",
        "value": "1000000000000000000"
      }
    ],
    "initialMutFields": [
      {
        "type": "U256",
        "value": "2000000000000000000"
      }
    ],
    "initialAsset": {
      "attoAlphAmount": "1000000000000000000",
      "tokens": [
        {
          "id": "2d11fd6c12435ffb07aaed4d190a505b621b927a5f6e51b61ce0ebe186397bdd",
          "amount": "1000000000"
        }
      ]
    },
    "methodIndex": 0,
    "args": [
      {
        "type": "U256",
        "value": "1000000000000000000"
      }
    ],
    "existingContracts": [
      {
        "address": "vYZdgzNHHp7Qh9U5Rrv5H65eSJCGQTXEC4yuQCZ7mosA",
        "bytecode": "00010700000000000118",
        "codeHash": "c49d951065f85d0c673d33930e8476240c010a52313f99889ae06d9f0d92d2f9",
        "initialStateHash": "e195a4e597e62a6802a456224008b896566b7c961023954fab808a0f83d8ad63",
        "immFields": [
          {
            "type": "U256",
            "value": "1000000000000000000"
          }
        ],
        "mutFields": [
          {
            "type": "U256",
            "value": "2000000000000000000"
          }
        ],
        "asset": {
          "attoAlphAmount": "2000000000000000000",
          "tokens": [
            {
              "id": "bd165d20bd063c7a023d22232a1e75bf46e904067f92b49323fe89fa0fd586bf",
              "amount": "2000000000"
            }
          ]
        }
      }
    ],
    "inputAssets": [
      {
        "address": "1AujpupFP4KWeZvqA7itsHY9cLJmx4qTzojVZrg8W9y",
        "asset": {
          "attoAlphAmount": "3000000000000000000",
          "tokens": [
            {
              "id": "20aa1fcc865087d7788302d087e4bc76691218ce5d5013dd1cedaabfac19cca4",
              "amount": "3000000000"
            }
          ]
        }
      }
    ]
  }'

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

import requests

payload = {
  "group": 0,
  "address": "tgx7VNFoP9DJiFMFgXXtafQZkUvyEdDHT9ryamHJYrjq",
  "bytecode": "00010700000000000118",
  "initialImmFields": [
    {
      "type": "U256",
      "value": "1000000000000000000"
    }
  ],
  "initialMutFields": [
    {
      "type": "U256",
      "value": "2000000000000000000"
    }
  ],
  "initialAsset": {
    "attoAlphAmount": "1000000000000000000",
    "tokens": [
      {
        "id": "2d11fd6c12435ffb07aaed4d190a505b621b927a5f6e51b61ce0ebe186397bdd",
        "amount": "1000000000"
      }
    ]
  },
  "methodIndex": 0,
  "args": [
    {
      "type": "U256",
      "value": "1000000000000000000"
    }
  ],
  "existingContracts": [
    {
      "address": "vYZdgzNHHp7Qh9U5Rrv5H65eSJCGQTXEC4yuQCZ7mosA",
      "bytecode": "00010700000000000118",
      "codeHash": "c49d951065f85d0c673d33930e8476240c010a52313f99889ae06d9f0d92d2f9",
      "initialStateHash": "e195a4e597e62a6802a456224008b896566b7c961023954fab808a0f83d8ad63",
      "immFields": [
        {
          "type": "U256",
          "value": "1000000000000000000"
        }
      ],
      "mutFields": [
        {
          "type": "U256",
          "value": "2000000000000000000"
        }
      ],
      "asset": {
        "attoAlphAmount": "2000000000000000000",
        "tokens": [
          {
            "id": "bd165d20bd063c7a023d22232a1e75bf46e904067f92b49323fe89fa0fd586bf",
            "amount": "2000000000"
          }
        ]
      }
    }
  ],
  "inputAssets": [
    {
      "address": "1AujpupFP4KWeZvqA7itsHY9cLJmx4qTzojVZrg8W9y",
      "asset": {
        "attoAlphAmount": "3000000000000000000",
        "tokens": [
          {
            "id": "20aa1fcc865087d7788302d087e4bc76691218ce5d5013dd1cedaabfac19cca4",
            "amount": "3000000000"
          }
        ]
      }
    }
  ]
}

response = requests.post('https://alephium.nownodes.io/contracts/test-contract', json=payload)
data = response.json()

const response = await fetch('https://alephium.nownodes.io/contracts/test-contract', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "group": 0,
      "address": "tgx7VNFoP9DJiFMFgXXtafQZkUvyEdDHT9ryamHJYrjq",
      "bytecode": "00010700000000000118",
      "initialImmFields": [
        {
          "type": "U256",
          "value": "1000000000000000000"
        }
      ],
      "initialMutFields": [
        {
          "type": "U256",
          "value": "2000000000000000000"
        }
      ],
      "initialAsset": {
        "attoAlphAmount": "1000000000000000000",
        "tokens": [
          {
            "id": "2d11fd6c12435ffb07aaed4d190a505b621b927a5f6e51b61ce0ebe186397bdd",
            "amount": "1000000000"
          }
        ]
      },
      "methodIndex": 0,
      "args": [
        {
          "type": "U256",
          "value": "1000000000000000000"
        }
      ],
      "existingContracts": [
        {
          "address": "vYZdgzNHHp7Qh9U5Rrv5H65eSJCGQTXEC4yuQCZ7mosA",
          "bytecode": "00010700000000000118",
          "codeHash": "c49d951065f85d0c673d33930e8476240c010a52313f99889ae06d9f0d92d2f9",
          "initialStateHash": "e195a4e597e62a6802a456224008b896566b7c961023954fab808a0f83d8ad63",
          "immFields": [
            {
              "type": "U256",
              "value": "1000000000000000000"
            }
          ],
          "mutFields": [
            {
              "type": "U256",
              "value": "2000000000000000000"
            }
          ],
          "asset": {
            "attoAlphAmount": "2000000000000000000",
            "tokens": [
              {
                "id": "bd165d20bd063c7a023d22232a1e75bf46e904067f92b49323fe89fa0fd586bf",
                "amount": "2000000000"
              }
            ]
          }
        }
      ],
      "inputAssets": [
        {
          "address": "1AujpupFP4KWeZvqA7itsHY9cLJmx4qTzojVZrg8W9y",
          "asset": {
            "attoAlphAmount": "3000000000000000000",
            "tokens": [
              {
                "id": "20aa1fcc865087d7788302d087e4bc76691218ce5d5013dd1cedaabfac19cca4",
                "amount": "3000000000"
              }
            ]
          }
        }
      ]
    }),
});

const data = await response.json();

const endpoint = "https://alephium.nownodes.io/contracts/test-contract";
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({
    "group": 0,
    "address": "tgx7VNFoP9DJiFMFgXXtafQZkUvyEdDHT9ryamHJYrjq",
    "bytecode": "00010700000000000118",
    "initialImmFields": [
      {
        "type": "U256",
        "value": "1000000000000000000"
      }
    ],
    "initialMutFields": [
      {
        "type": "U256",
        "value": "2000000000000000000"
      }
    ],
    "initialAsset": {
      "attoAlphAmount": "1000000000000000000",
      "tokens": [
        {
          "id": "2d11fd6c12435ffb07aaed4d190a505b621b927a5f6e51b61ce0ebe186397bdd",
          "amount": "1000000000"
        }
      ]
    },
    "methodIndex": 0,
    "args": [
      {
        "type": "U256",
        "value": "1000000000000000000"
      }
    ],
    "existingContracts": [
      {
        "address": "vYZdgzNHHp7Qh9U5Rrv5H65eSJCGQTXEC4yuQCZ7mosA",
        "bytecode": "00010700000000000118",
        "codeHash": "c49d951065f85d0c673d33930e8476240c010a52313f99889ae06d9f0d92d2f9",
        "initialStateHash": "e195a4e597e62a6802a456224008b896566b7c961023954fab808a0f83d8ad63",
        "immFields": [
          {
            "type": "U256",
            "value": "1000000000000000000"
          }
        ],
        "mutFields": [
          {
            "type": "U256",
            "value": "2000000000000000000"
          }
        ],
        "asset": {
          "attoAlphAmount": "2000000000000000000",
          "tokens": [
            {
              "id": "bd165d20bd063c7a023d22232a1e75bf46e904067f92b49323fe89fa0fd586bf",
              "amount": "2000000000"
            }
          ]
        }
      }
    ],
    "inputAssets": [
      {
        "address": "1AujpupFP4KWeZvqA7itsHY9cLJmx4qTzojVZrg8W9y",
        "asset": {
          "attoAlphAmount": "3000000000000000000",
          "tokens": [
            {
              "id": "20aa1fcc865087d7788302d087e4bc76691218ce5d5013dd1cedaabfac19cca4",
              "amount": "3000000000"
            }
          ]
        }
      }
    ]
  });
console.log(result);

const response = await fetch('https://alephium.nownodes.io/contracts/test-contract', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "group": 0,
      "address": "tgx7VNFoP9DJiFMFgXXtafQZkUvyEdDHT9ryamHJYrjq",
      "bytecode": "00010700000000000118",
      "initialImmFields": [
        {
          "type": "U256",
          "value": "1000000000000000000"
        }
      ],
      "initialMutFields": [
        {
          "type": "U256",
          "value": "2000000000000000000"
        }
      ],
      "initialAsset": {
        "attoAlphAmount": "1000000000000000000",
        "tokens": [
          {
            "id": "2d11fd6c12435ffb07aaed4d190a505b621b927a5f6e51b61ce0ebe186397bdd",
            "amount": "1000000000"
          }
        ]
      },
      "methodIndex": 0,
      "args": [
        {
          "type": "U256",
          "value": "1000000000000000000"
        }
      ],
      "existingContracts": [
        {
          "address": "vYZdgzNHHp7Qh9U5Rrv5H65eSJCGQTXEC4yuQCZ7mosA",
          "bytecode": "00010700000000000118",
          "codeHash": "c49d951065f85d0c673d33930e8476240c010a52313f99889ae06d9f0d92d2f9",
          "initialStateHash": "e195a4e597e62a6802a456224008b896566b7c961023954fab808a0f83d8ad63",
          "immFields": [
            {
              "type": "U256",
              "value": "1000000000000000000"
            }
          ],
          "mutFields": [
            {
              "type": "U256",
              "value": "2000000000000000000"
            }
          ],
          "asset": {
            "attoAlphAmount": "2000000000000000000",
            "tokens": [
              {
                "id": "bd165d20bd063c7a023d22232a1e75bf46e904067f92b49323fe89fa0fd586bf",
                "amount": "2000000000"
              }
            ]
          }
        }
      ],
      "inputAssets": [
        {
          "address": "1AujpupFP4KWeZvqA7itsHY9cLJmx4qTzojVZrg8W9y",
          "asset": {
            "attoAlphAmount": "3000000000000000000",
            "tokens": [
              {
                "id": "20aa1fcc865087d7788302d087e4bc76691218ce5d5013dd1cedaabfac19cca4",
                "amount": "3000000000"
              }
            ]
          }
        }
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "group": 0,
  "address": "tgx7VNFoP9DJiFMFgXXtafQZkUvyEdDHT9ryamHJYrjq",
  "bytecode": "00010700000000000118",
  "initialImmFields": [
    {
      "type": "U256",
      "value": "1000000000000000000"
    }
  ],
  "initialMutFields": [
    {
      "type": "U256",
      "value": "2000000000000000000"
    }
  ],
  "initialAsset": {
    "attoAlphAmount": "1000000000000000000",
    "tokens": [
      {
        "id": "2d11fd6c12435ffb07aaed4d190a505b621b927a5f6e51b61ce0ebe186397bdd",
        "amount": "1000000000"
      }
    ]
  },
  "methodIndex": 0,
  "args": [
    {
      "type": "U256",
      "value": "1000000000000000000"
    }
  ],
  "existingContracts": [
    {
      "address": "vYZdgzNHHp7Qh9U5Rrv5H65eSJCGQTXEC4yuQCZ7mosA",
      "bytecode": "00010700000000000118",
      "codeHash": "c49d951065f85d0c673d33930e8476240c010a52313f99889ae06d9f0d92d2f9",
      "initialStateHash": "e195a4e597e62a6802a456224008b896566b7c961023954fab808a0f83d8ad63",
      "immFields": [
        {
          "type": "U256",
          "value": "1000000000000000000"
        }
      ],
      "mutFields": [
        {
          "type": "U256",
          "value": "2000000000000000000"
        }
      ],
      "asset": {
        "attoAlphAmount": "2000000000000000000",
        "tokens": [
          {
            "id": "bd165d20bd063c7a023d22232a1e75bf46e904067f92b49323fe89fa0fd586bf",
            "amount": "2000000000"
          }
        ]
      }
    }
  ],
  "inputAssets": [
    {
      "address": "1AujpupFP4KWeZvqA7itsHY9cLJmx4qTzojVZrg8W9y",
      "asset": {
        "attoAlphAmount": "3000000000000000000",
        "tokens": [
          {
            "id": "20aa1fcc865087d7788302d087e4bc76691218ce5d5013dd1cedaabfac19cca4",
            "amount": "3000000000"
          }
        ]
      }
    }
  ]
}

response = requests.post('https://alephium.nownodes.io/contracts/test-contract', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/contracts/test-contract')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "group": 0,
    "address": "tgx7VNFoP9DJiFMFgXXtafQZkUvyEdDHT9ryamHJYrjq",
    "bytecode": "00010700000000000118",
    "initialImmFields": [
      {
        "type": "U256",
        "value": "1000000000000000000"
      }
    ],
    "initialMutFields": [
      {
        "type": "U256",
        "value": "2000000000000000000"
      }
    ],
    "initialAsset": {
      "attoAlphAmount": "1000000000000000000",
      "tokens": [
        {
          "id": "2d11fd6c12435ffb07aaed4d190a505b621b927a5f6e51b61ce0ebe186397bdd",
          "amount": "1000000000"
        }
      ]
    },
    "methodIndex": 0,
    "args": [
      {
        "type": "U256",
        "value": "1000000000000000000"
      }
    ],
    "existingContracts": [
      {
        "address": "vYZdgzNHHp7Qh9U5Rrv5H65eSJCGQTXEC4yuQCZ7mosA",
        "bytecode": "00010700000000000118",
        "codeHash": "c49d951065f85d0c673d33930e8476240c010a52313f99889ae06d9f0d92d2f9",
        "initialStateHash": "e195a4e597e62a6802a456224008b896566b7c961023954fab808a0f83d8ad63",
        "immFields": [
          {
            "type": "U256",
            "value": "1000000000000000000"
          }
        ],
        "mutFields": [
          {
            "type": "U256",
            "value": "2000000000000000000"
          }
        ],
        "asset": {
          "attoAlphAmount": "2000000000000000000",
          "tokens": [
            {
              "id": "bd165d20bd063c7a023d22232a1e75bf46e904067f92b49323fe89fa0fd586bf",
              "amount": "2000000000"
            }
          ]
        }
      }
    ],
    "inputAssets": [
      {
        "address": "1AujpupFP4KWeZvqA7itsHY9cLJmx4qTzojVZrg8W9y",
        "asset": {
          "attoAlphAmount": "3000000000000000000",
          "tokens": [
            {
              "id": "20aa1fcc865087d7788302d087e4bc76691218ce5d5013dd1cedaabfac19cca4",
              "amount": "3000000000"
            }
          ]
        }
      }
    ]
  }'

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

Request Body

{
  "group": 0,
  "address": "tgx7VNFoP9DJiFMFgXXtafQZkUvyEdDHT9ryamHJYrjq",
  "bytecode": "00010700000000000118",
  "initialImmFields": [
    {
      "type": "U256",
      "value": "1000000000000000000"
    }
  ],
  "initialMutFields": [
    {
      "type": "U256",
      "value": "2000000000000000000"
    }
  ],
  "initialAsset": {
    "attoAlphAmount": "1000000000000000000",
    "tokens": [
      {
        "id": "2d11fd6c12435ffb07aaed4d190a505b621b927a5f6e51b61ce0ebe186397bdd",
        "amount": "1000000000"
      }
    ]
  },
  "methodIndex": 0,
  "args": [
    {
      "type": "U256",
      "value": "1000000000000000000"
    }
  ],
  "existingContracts": [
    {
      "address": "vYZdgzNHHp7Qh9U5Rrv5H65eSJCGQTXEC4yuQCZ7mosA",
      "bytecode": "00010700000000000118",
      "codeHash": "c49d951065f85d0c673d33930e8476240c010a52313f99889ae06d9f0d92d2f9",
      "initialStateHash": "e195a4e597e62a6802a456224008b896566b7c961023954fab808a0f83d8ad63",
      "immFields": [
        {
          "type": "U256",
          "value": "1000000000000000000"
        }
      ],
      "mutFields": [
        {
          "type": "U256",
          "value": "2000000000000000000"
        }
      ],
      "asset": {
        "attoAlphAmount": "2000000000000000000",
        "tokens": [
          {
            "id": "bd165d20bd063c7a023d22232a1e75bf46e904067f92b49323fe89fa0fd586bf",
            "amount": "2000000000"
          }
        ]
      }
    }
  ],
  "inputAssets": [
    {
      "address": "1AujpupFP4KWeZvqA7itsHY9cLJmx4qTzojVZrg8W9y",
      "asset": {
        "attoAlphAmount": "3000000000000000000",
        "tokens": [
          {
            "id": "20aa1fcc865087d7788302d087e4bc76691218ce5d5013dd1cedaabfac19cca4",
            "amount": "3000000000"
          }
        ]
      }
    }
  ]
}

{
  "address": "uomjgUz6D4tLejTkQtbNJMY8apAjTm1bgQf7em1wDV7S",
  "codeHash": "798e9e137aec7c2d59d9655b4ffa640f301f628bf7c365083bb255f6aa5f89ef",
  "returns": [
    {
      "type": "U256",
      "value": "1000000000000000000"
    }
  ],
  "gasUsed": 20000,
  "contracts": [
    {
      "address": "vYZdgzNHHp7Qh9U5Rrv5H65eSJCGQTXEC4yuQCZ7mosA",
      "bytecode": "00010700000000000118",
      "codeHash": "c49d951065f85d0c673d33930e8476240c010a52313f99889ae06d9f0d92d2f9",
      "initialStateHash": "e195a4e597e62a6802a456224008b896566b7c961023954fab808a0f83d8ad63",
      "immFields": [
        {
          "type": "U256",
          "value": "1000000000000000000"
        }
      ],
      "mutFields": [
        {
          "type": "U256",
          "value": "2000000000000000000"
        }
      ],
      "asset": {
        "attoAlphAmount": "2000000000000000000",
        "tokens": [
          {
            "id": "bd165d20bd063c7a023d22232a1e75bf46e904067f92b49323fe89fa0fd586bf",
            "amount": "2000000000"
          }
        ]
      }
    }
  ],
  "txInputs": [
    "uomjgUz6D4tLejTkQtbNJMY8apAjTm1bgQf7em1wDV7S"
  ],
  "txOutputs": [
    {
      "type": "ContractOutput",
      "hint": 1234,
      "key": "798e9e137aec7c2d59d9655b4ffa640f301f628bf7c365083bb255f6aa5f89ef",
      "attoAlphAmount": "1000000000000000000",
      "address": "uomjgUz6D4tLejTkQtbNJMY8apAjTm1bgQf7em1wDV7S",
      "tokens": [
        {
          "id": "2d11fd6c12435ffb07aaed4d190a505b621b927a5f6e51b61ce0ebe186397bdd",
          "amount": "42000000000000000000"
        },
        {
          "id": "bd165d20bd063c7a023d22232a1e75bf46e904067f92b49323fe89fa0fd586bf",
          "amount": "1000000000000000000000"
        }
      ]
    }
  ],
  "events": [
    {
      "blockHash": "bdaf9dc514ce7d34b6474b8ca10a3dfb93ba997cb9d5ff1ea724ebe2af48abe5",
      "contractAddress": "vSxdLL2kE3o6vJBdKkdgmS3W39G3ZEmFHpo2y1jnbzBq",
      "eventIndex": 1,
      "fields": [
        {
          "type": "Address",
          "value": "1AujpupFP4KWeZvqA7itsHY9cLJmx4qTzojVZrg8W9y"
        },
        {
          "type": "U256",
          "value": "10"
        }
      ]
    }
  ],
  "debugMessages": [
    {
      "contractAddress": "uomjgUz6D4tLejTkQtbNJMY8apAjTm1bgQf7em1wDV7S",
      "message": "Debugging!"
    }
  ]
}

{
  "detail": "string"
}

{
  "detail": "string"
}

{
  "resource": "wallet-name",
  "detail": "wallet-name not found"
}

{
  "detail": "string"
}

{
  "detail": "string"
}

Call contract

POST

https://alephium.nownodes.io/contracts/call-contract

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Body

application/json

CallContract

Response

200OK

Valid response

400Bad Request

BadRequest

401Unauthorized

Unauthorized

404Not Found

NotFound

500Internal Server Error

InternalServerError

503Service Unavailable

ServiceUnavailable

Call contract

curl -X POST 'https://alephium.nownodes.io/contracts/call-contract' \
  -H 'Content-Type: application/json' \
  -d '{
    "group": 0,
    "worldStateBlockHash": "bdaf9dc514ce7d34b6474b8ca10a3dfb93ba997cb9d5ff1ea724ebe2af48abe5",
    "txId": "503bfb16230888af4924aa8f8250d7d348b862e267d75d3147f1998050b6da69",
    "address": "tgx7VNFoP9DJiFMFgXXtafQZkUvyEdDHT9ryamHJYrjq",
    "methodIndex": 0,
    "args": [
      {
        "type": "U256",
        "value": "0"
      }
    ],
    "interestedContracts": [
      "uomjgUz6D4tLejTkQtbNJMY8apAjTm1bgQf7em1wDV7S"
    ],
    "inputAssets": [
      {
        "address": "1AujpupFP4KWeZvqA7itsHY9cLJmx4qTzojVZrg8W9y",
        "asset": {
          "attoAlphAmount": "3000000000000000000",
          "tokens": [
            {
              "id": "20aa1fcc865087d7788302d087e4bc76691218ce5d5013dd1cedaabfac19cca4",
              "amount": "3000000000"
            }
          ]
        }
      }
    ]
  }'

const response = await fetch('https://alephium.nownodes.io/contracts/call-contract', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "group": 0,
      "worldStateBlockHash": "bdaf9dc514ce7d34b6474b8ca10a3dfb93ba997cb9d5ff1ea724ebe2af48abe5",
      "txId": "503bfb16230888af4924aa8f8250d7d348b862e267d75d3147f1998050b6da69",
      "address": "tgx7VNFoP9DJiFMFgXXtafQZkUvyEdDHT9ryamHJYrjq",
      "methodIndex": 0,
      "args": [
        {
          "type": "U256",
          "value": "0"
        }
      ],
      "interestedContracts": [
        "uomjgUz6D4tLejTkQtbNJMY8apAjTm1bgQf7em1wDV7S"
      ],
      "inputAssets": [
        {
          "address": "1AujpupFP4KWeZvqA7itsHY9cLJmx4qTzojVZrg8W9y",
          "asset": {
            "attoAlphAmount": "3000000000000000000",
            "tokens": [
              {
                "id": "20aa1fcc865087d7788302d087e4bc76691218ce5d5013dd1cedaabfac19cca4",
                "amount": "3000000000"
              }
            ]
          }
        }
      ]
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/contracts/call-contract')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "group": 0,
    "worldStateBlockHash": "bdaf9dc514ce7d34b6474b8ca10a3dfb93ba997cb9d5ff1ea724ebe2af48abe5",
    "txId": "503bfb16230888af4924aa8f8250d7d348b862e267d75d3147f1998050b6da69",
    "address": "tgx7VNFoP9DJiFMFgXXtafQZkUvyEdDHT9ryamHJYrjq",
    "methodIndex": 0,
    "args": [
      {
        "type": "U256",
        "value": "0"
      }
    ],
    "interestedContracts": [
      "uomjgUz6D4tLejTkQtbNJMY8apAjTm1bgQf7em1wDV7S"
    ],
    "inputAssets": [
      {
        "address": "1AujpupFP4KWeZvqA7itsHY9cLJmx4qTzojVZrg8W9y",
        "asset": {
          "attoAlphAmount": "3000000000000000000",
          "tokens": [
            {
              "id": "20aa1fcc865087d7788302d087e4bc76691218ce5d5013dd1cedaabfac19cca4",
              "amount": "3000000000"
            }
          ]
        }
      }
    ]
  }'

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

import requests

payload = {
  "group": 0,
  "worldStateBlockHash": "bdaf9dc514ce7d34b6474b8ca10a3dfb93ba997cb9d5ff1ea724ebe2af48abe5",
  "txId": "503bfb16230888af4924aa8f8250d7d348b862e267d75d3147f1998050b6da69",
  "address": "tgx7VNFoP9DJiFMFgXXtafQZkUvyEdDHT9ryamHJYrjq",
  "methodIndex": 0,
  "args": [
    {
      "type": "U256",
      "value": "0"
    }
  ],
  "interestedContracts": [
    "uomjgUz6D4tLejTkQtbNJMY8apAjTm1bgQf7em1wDV7S"
  ],
  "inputAssets": [
    {
      "address": "1AujpupFP4KWeZvqA7itsHY9cLJmx4qTzojVZrg8W9y",
      "asset": {
        "attoAlphAmount": "3000000000000000000",
        "tokens": [
          {
            "id": "20aa1fcc865087d7788302d087e4bc76691218ce5d5013dd1cedaabfac19cca4",
            "amount": "3000000000"
          }
        ]
      }
    }
  ]
}

response = requests.post('https://alephium.nownodes.io/contracts/call-contract', json=payload)
data = response.json()

const response = await fetch('https://alephium.nownodes.io/contracts/call-contract', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "group": 0,
      "worldStateBlockHash": "bdaf9dc514ce7d34b6474b8ca10a3dfb93ba997cb9d5ff1ea724ebe2af48abe5",
      "txId": "503bfb16230888af4924aa8f8250d7d348b862e267d75d3147f1998050b6da69",
      "address": "tgx7VNFoP9DJiFMFgXXtafQZkUvyEdDHT9ryamHJYrjq",
      "methodIndex": 0,
      "args": [
        {
          "type": "U256",
          "value": "0"
        }
      ],
      "interestedContracts": [
        "uomjgUz6D4tLejTkQtbNJMY8apAjTm1bgQf7em1wDV7S"
      ],
      "inputAssets": [
        {
          "address": "1AujpupFP4KWeZvqA7itsHY9cLJmx4qTzojVZrg8W9y",
          "asset": {
            "attoAlphAmount": "3000000000000000000",
            "tokens": [
              {
                "id": "20aa1fcc865087d7788302d087e4bc76691218ce5d5013dd1cedaabfac19cca4",
                "amount": "3000000000"
              }
            ]
          }
        }
      ]
    }),
});

const data = await response.json();

const endpoint = "https://alephium.nownodes.io/contracts/call-contract";
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({
    "group": 0,
    "worldStateBlockHash": "bdaf9dc514ce7d34b6474b8ca10a3dfb93ba997cb9d5ff1ea724ebe2af48abe5",
    "txId": "503bfb16230888af4924aa8f8250d7d348b862e267d75d3147f1998050b6da69",
    "address": "tgx7VNFoP9DJiFMFgXXtafQZkUvyEdDHT9ryamHJYrjq",
    "methodIndex": 0,
    "args": [
      {
        "type": "U256",
        "value": "0"
      }
    ],
    "interestedContracts": [
      "uomjgUz6D4tLejTkQtbNJMY8apAjTm1bgQf7em1wDV7S"
    ],
    "inputAssets": [
      {
        "address": "1AujpupFP4KWeZvqA7itsHY9cLJmx4qTzojVZrg8W9y",
        "asset": {
          "attoAlphAmount": "3000000000000000000",
          "tokens": [
            {
              "id": "20aa1fcc865087d7788302d087e4bc76691218ce5d5013dd1cedaabfac19cca4",
              "amount": "3000000000"
            }
          ]
        }
      }
    ]
  });
console.log(result);

const response = await fetch('https://alephium.nownodes.io/contracts/call-contract', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "group": 0,
      "worldStateBlockHash": "bdaf9dc514ce7d34b6474b8ca10a3dfb93ba997cb9d5ff1ea724ebe2af48abe5",
      "txId": "503bfb16230888af4924aa8f8250d7d348b862e267d75d3147f1998050b6da69",
      "address": "tgx7VNFoP9DJiFMFgXXtafQZkUvyEdDHT9ryamHJYrjq",
      "methodIndex": 0,
      "args": [
        {
          "type": "U256",
          "value": "0"
        }
      ],
      "interestedContracts": [
        "uomjgUz6D4tLejTkQtbNJMY8apAjTm1bgQf7em1wDV7S"
      ],
      "inputAssets": [
        {
          "address": "1AujpupFP4KWeZvqA7itsHY9cLJmx4qTzojVZrg8W9y",
          "asset": {
            "attoAlphAmount": "3000000000000000000",
            "tokens": [
              {
                "id": "20aa1fcc865087d7788302d087e4bc76691218ce5d5013dd1cedaabfac19cca4",
                "amount": "3000000000"
              }
            ]
          }
        }
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "group": 0,
  "worldStateBlockHash": "bdaf9dc514ce7d34b6474b8ca10a3dfb93ba997cb9d5ff1ea724ebe2af48abe5",
  "txId": "503bfb16230888af4924aa8f8250d7d348b862e267d75d3147f1998050b6da69",
  "address": "tgx7VNFoP9DJiFMFgXXtafQZkUvyEdDHT9ryamHJYrjq",
  "methodIndex": 0,
  "args": [
    {
      "type": "U256",
      "value": "0"
    }
  ],
  "interestedContracts": [
    "uomjgUz6D4tLejTkQtbNJMY8apAjTm1bgQf7em1wDV7S"
  ],
  "inputAssets": [
    {
      "address": "1AujpupFP4KWeZvqA7itsHY9cLJmx4qTzojVZrg8W9y",
      "asset": {
        "attoAlphAmount": "3000000000000000000",
        "tokens": [
          {
            "id": "20aa1fcc865087d7788302d087e4bc76691218ce5d5013dd1cedaabfac19cca4",
            "amount": "3000000000"
          }
        ]
      }
    }
  ]
}

response = requests.post('https://alephium.nownodes.io/contracts/call-contract', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/contracts/call-contract')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "group": 0,
    "worldStateBlockHash": "bdaf9dc514ce7d34b6474b8ca10a3dfb93ba997cb9d5ff1ea724ebe2af48abe5",
    "txId": "503bfb16230888af4924aa8f8250d7d348b862e267d75d3147f1998050b6da69",
    "address": "tgx7VNFoP9DJiFMFgXXtafQZkUvyEdDHT9ryamHJYrjq",
    "methodIndex": 0,
    "args": [
      {
        "type": "U256",
        "value": "0"
      }
    ],
    "interestedContracts": [
      "uomjgUz6D4tLejTkQtbNJMY8apAjTm1bgQf7em1wDV7S"
    ],
    "inputAssets": [
      {
        "address": "1AujpupFP4KWeZvqA7itsHY9cLJmx4qTzojVZrg8W9y",
        "asset": {
          "attoAlphAmount": "3000000000000000000",
          "tokens": [
            {
              "id": "20aa1fcc865087d7788302d087e4bc76691218ce5d5013dd1cedaabfac19cca4",
              "amount": "3000000000"
            }
          ]
        }
      }
    ]
  }'

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

Request Body

{
  "group": 0,
  "worldStateBlockHash": "bdaf9dc514ce7d34b6474b8ca10a3dfb93ba997cb9d5ff1ea724ebe2af48abe5",
  "txId": "503bfb16230888af4924aa8f8250d7d348b862e267d75d3147f1998050b6da69",
  "address": "tgx7VNFoP9DJiFMFgXXtafQZkUvyEdDHT9ryamHJYrjq",
  "methodIndex": 0,
  "args": [
    {
      "type": "U256",
      "value": "0"
    }
  ],
  "interestedContracts": [
    "uomjgUz6D4tLejTkQtbNJMY8apAjTm1bgQf7em1wDV7S"
  ],
  "inputAssets": [
    {
      "address": "1AujpupFP4KWeZvqA7itsHY9cLJmx4qTzojVZrg8W9y",
      "asset": {
        "attoAlphAmount": "3000000000000000000",
        "tokens": [
          {
            "id": "20aa1fcc865087d7788302d087e4bc76691218ce5d5013dd1cedaabfac19cca4",
            "amount": "3000000000"
          }
        ]
      }
    }
  ]
}

{
  "type": "CallContractSucceeded",
  "returns": [
    {
      "type": "U256",
      "value": "0"
    }
  ],
  "gasUsed": 20000,
  "contracts": [
    {
      "address": "vYZdgzNHHp7Qh9U5Rrv5H65eSJCGQTXEC4yuQCZ7mosA",
      "bytecode": "00010700000000000118",
      "codeHash": "c49d951065f85d0c673d33930e8476240c010a52313f99889ae06d9f0d92d2f9",
      "initialStateHash": "e195a4e597e62a6802a456224008b896566b7c961023954fab808a0f83d8ad63",
      "immFields": [
        {
          "type": "U256",
          "value": "1000000000000000000"
        }
      ],
      "mutFields": [
        {
          "type": "U256",
          "value": "2000000000000000000"
        }
      ],
      "asset": {
        "attoAlphAmount": "2000000000000000000",
        "tokens": [
          {
            "id": "bd165d20bd063c7a023d22232a1e75bf46e904067f92b49323fe89fa0fd586bf",
            "amount": "2000000000"
          }
        ]
      }
    }
  ],
  "txInputs": [
    "uomjgUz6D4tLejTkQtbNJMY8apAjTm1bgQf7em1wDV7S"
  ],
  "txOutputs": [
    {
      "type": "ContractOutput",
      "hint": 1,
      "key": "798e9e137aec7c2d59d9655b4ffa640f301f628bf7c365083bb255f6aa5f89ef",
      "attoAlphAmount": "1000000000000000000",
      "address": "uomjgUz6D4tLejTkQtbNJMY8apAjTm1bgQf7em1wDV7S",
      "tokens": [
        {
          "id": "2d11fd6c12435ffb07aaed4d190a505b621b927a5f6e51b61ce0ebe186397bdd",
          "amount": "42000000000000000000"
        },
        {
          "id": "bd165d20bd063c7a023d22232a1e75bf46e904067f92b49323fe89fa0fd586bf",
          "amount": "1000000000000000000000"
        }
      ]
    }
  ],
  "events": [
    {
      "blockHash": "bdaf9dc514ce7d34b6474b8ca10a3dfb93ba997cb9d5ff1ea724ebe2af48abe5",
      "contractAddress": "vSxdLL2kE3o6vJBdKkdgmS3W39G3ZEmFHpo2y1jnbzBq",
      "eventIndex": 1,
      "fields": [
        {
          "type": "Address",
          "value": "1AujpupFP4KWeZvqA7itsHY9cLJmx4qTzojVZrg8W9y"
        },
        {
          "type": "U256",
          "value": "10"
        }
      ]
    }
  ],
  "debugMessages": [
    {
      "contractAddress": "uomjgUz6D4tLejTkQtbNJMY8apAjTm1bgQf7em1wDV7S",
      "message": "Debugging!"
    }
  ]
}

{
  "detail": "string"
}

{
  "detail": "string"
}

{
  "resource": "wallet-name",
  "detail": "wallet-name not found"
}

{
  "detail": "string"
}

{
  "detail": "string"
}

Multiple call contract

POST

https://alephium.nownodes.io/contracts/multicall-contract

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Body

application/json

any

Response

200OK

Valid response

400Bad Request

BadRequest

401Unauthorized

Unauthorized

404Not Found

NotFound

500Internal Server Error

InternalServerError

503Service Unavailable

ServiceUnavailable

Multiple call contract

curl -X POST 'https://alephium.nownodes.io/contracts/multicall-contract' \
  -H 'Content-Type: application/json' \
  -d '{
    "calls": [
      {
        "group": 0,
        "worldStateBlockHash": "bdaf9dc514ce7d34b6474b8ca10a3dfb93ba997cb9d5ff1ea724ebe2af48abe5",
        "txId": "503bfb16230888af4924aa8f8250d7d348b862e267d75d3147f1998050b6da69",
        "address": "tgx7VNFoP9DJiFMFgXXtafQZkUvyEdDHT9ryamHJYrjq",
        "methodIndex": 0,
        "args": [
          {
            "type": "U256",
            "value": "0"
          }
        ],
        "interestedContracts": [
          "uomjgUz6D4tLejTkQtbNJMY8apAjTm1bgQf7em1wDV7S"
        ],
        "inputAssets": [
          {
            "address": "1AujpupFP4KWeZvqA7itsHY9cLJmx4qTzojVZrg8W9y",
            "asset": {
              "attoAlphAmount": "3000000000000000000",
              "tokens": [
                {
                  "id": "20aa1fcc865087d7788302d087e4bc76691218ce5d5013dd1cedaabfac19cca4",
                  "amount": "3000000000"
                }
              ]
            }
          }
        ]
      }
    ]
  }'

const response = await fetch('https://alephium.nownodes.io/contracts/multicall-contract', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "calls": [
        {
          "group": 0,
          "worldStateBlockHash": "bdaf9dc514ce7d34b6474b8ca10a3dfb93ba997cb9d5ff1ea724ebe2af48abe5",
          "txId": "503bfb16230888af4924aa8f8250d7d348b862e267d75d3147f1998050b6da69",
          "address": "tgx7VNFoP9DJiFMFgXXtafQZkUvyEdDHT9ryamHJYrjq",
          "methodIndex": 0,
          "args": [
            {
              "type": "U256",
              "value": "0"
            }
          ],
          "interestedContracts": [
            "uomjgUz6D4tLejTkQtbNJMY8apAjTm1bgQf7em1wDV7S"
          ],
          "inputAssets": [
            {
              "address": "1AujpupFP4KWeZvqA7itsHY9cLJmx4qTzojVZrg8W9y",
              "asset": {
                "attoAlphAmount": "3000000000000000000",
                "tokens": [
                  {
                    "id": "20aa1fcc865087d7788302d087e4bc76691218ce5d5013dd1cedaabfac19cca4",
                    "amount": "3000000000"
                  }
                ]
              }
            }
          ]
        }
      ]
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/contracts/multicall-contract')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "calls": [
      {
        "group": 0,
        "worldStateBlockHash": "bdaf9dc514ce7d34b6474b8ca10a3dfb93ba997cb9d5ff1ea724ebe2af48abe5",
        "txId": "503bfb16230888af4924aa8f8250d7d348b862e267d75d3147f1998050b6da69",
        "address": "tgx7VNFoP9DJiFMFgXXtafQZkUvyEdDHT9ryamHJYrjq",
        "methodIndex": 0,
        "args": [
          {
            "type": "U256",
            "value": "0"
          }
        ],
        "interestedContracts": [
          "uomjgUz6D4tLejTkQtbNJMY8apAjTm1bgQf7em1wDV7S"
        ],
        "inputAssets": [
          {
            "address": "1AujpupFP4KWeZvqA7itsHY9cLJmx4qTzojVZrg8W9y",
            "asset": {
              "attoAlphAmount": "3000000000000000000",
              "tokens": [
                {
                  "id": "20aa1fcc865087d7788302d087e4bc76691218ce5d5013dd1cedaabfac19cca4",
                  "amount": "3000000000"
                }
              ]
            }
          }
        ]
      }
    ]
  }'

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

import requests

payload = {
  "calls": [
    {
      "group": 0,
      "worldStateBlockHash": "bdaf9dc514ce7d34b6474b8ca10a3dfb93ba997cb9d5ff1ea724ebe2af48abe5",
      "txId": "503bfb16230888af4924aa8f8250d7d348b862e267d75d3147f1998050b6da69",
      "address": "tgx7VNFoP9DJiFMFgXXtafQZkUvyEdDHT9ryamHJYrjq",
      "methodIndex": 0,
      "args": [
        {
          "type": "U256",
          "value": "0"
        }
      ],
      "interestedContracts": [
        "uomjgUz6D4tLejTkQtbNJMY8apAjTm1bgQf7em1wDV7S"
      ],
      "inputAssets": [
        {
          "address": "1AujpupFP4KWeZvqA7itsHY9cLJmx4qTzojVZrg8W9y",
          "asset": {
            "attoAlphAmount": "3000000000000000000",
            "tokens": [
              {
                "id": "20aa1fcc865087d7788302d087e4bc76691218ce5d5013dd1cedaabfac19cca4",
                "amount": "3000000000"
              }
            ]
          }
        }
      ]
    }
  ]
}

response = requests.post('https://alephium.nownodes.io/contracts/multicall-contract', json=payload)
data = response.json()

const response = await fetch('https://alephium.nownodes.io/contracts/multicall-contract', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "calls": [
        {
          "group": 0,
          "worldStateBlockHash": "bdaf9dc514ce7d34b6474b8ca10a3dfb93ba997cb9d5ff1ea724ebe2af48abe5",
          "txId": "503bfb16230888af4924aa8f8250d7d348b862e267d75d3147f1998050b6da69",
          "address": "tgx7VNFoP9DJiFMFgXXtafQZkUvyEdDHT9ryamHJYrjq",
          "methodIndex": 0,
          "args": [
            {
              "type": "U256",
              "value": "0"
            }
          ],
          "interestedContracts": [
            "uomjgUz6D4tLejTkQtbNJMY8apAjTm1bgQf7em1wDV7S"
          ],
          "inputAssets": [
            {
              "address": "1AujpupFP4KWeZvqA7itsHY9cLJmx4qTzojVZrg8W9y",
              "asset": {
                "attoAlphAmount": "3000000000000000000",
                "tokens": [
                  {
                    "id": "20aa1fcc865087d7788302d087e4bc76691218ce5d5013dd1cedaabfac19cca4",
                    "amount": "3000000000"
                  }
                ]
              }
            }
          ]
        }
      ]
    }),
});

const data = await response.json();

const endpoint = "https://alephium.nownodes.io/contracts/multicall-contract";
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({
    "calls": [
      {
        "group": 0,
        "worldStateBlockHash": "bdaf9dc514ce7d34b6474b8ca10a3dfb93ba997cb9d5ff1ea724ebe2af48abe5",
        "txId": "503bfb16230888af4924aa8f8250d7d348b862e267d75d3147f1998050b6da69",
        "address": "tgx7VNFoP9DJiFMFgXXtafQZkUvyEdDHT9ryamHJYrjq",
        "methodIndex": 0,
        "args": [
          {
            "type": "U256",
            "value": "0"
          }
        ],
        "interestedContracts": [
          "uomjgUz6D4tLejTkQtbNJMY8apAjTm1bgQf7em1wDV7S"
        ],
        "inputAssets": [
          {
            "address": "1AujpupFP4KWeZvqA7itsHY9cLJmx4qTzojVZrg8W9y",
            "asset": {
              "attoAlphAmount": "3000000000000000000",
              "tokens": [
                {
                  "id": "20aa1fcc865087d7788302d087e4bc76691218ce5d5013dd1cedaabfac19cca4",
                  "amount": "3000000000"
                }
              ]
            }
          }
        ]
      }
    ]
  });
console.log(result);

const response = await fetch('https://alephium.nownodes.io/contracts/multicall-contract', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "calls": [
        {
          "group": 0,
          "worldStateBlockHash": "bdaf9dc514ce7d34b6474b8ca10a3dfb93ba997cb9d5ff1ea724ebe2af48abe5",
          "txId": "503bfb16230888af4924aa8f8250d7d348b862e267d75d3147f1998050b6da69",
          "address": "tgx7VNFoP9DJiFMFgXXtafQZkUvyEdDHT9ryamHJYrjq",
          "methodIndex": 0,
          "args": [
            {
              "type": "U256",
              "value": "0"
            }
          ],
          "interestedContracts": [
            "uomjgUz6D4tLejTkQtbNJMY8apAjTm1bgQf7em1wDV7S"
          ],
          "inputAssets": [
            {
              "address": "1AujpupFP4KWeZvqA7itsHY9cLJmx4qTzojVZrg8W9y",
              "asset": {
                "attoAlphAmount": "3000000000000000000",
                "tokens": [
                  {
                    "id": "20aa1fcc865087d7788302d087e4bc76691218ce5d5013dd1cedaabfac19cca4",
                    "amount": "3000000000"
                  }
                ]
              }
            }
          ]
        }
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "calls": [
    {
      "group": 0,
      "worldStateBlockHash": "bdaf9dc514ce7d34b6474b8ca10a3dfb93ba997cb9d5ff1ea724ebe2af48abe5",
      "txId": "503bfb16230888af4924aa8f8250d7d348b862e267d75d3147f1998050b6da69",
      "address": "tgx7VNFoP9DJiFMFgXXtafQZkUvyEdDHT9ryamHJYrjq",
      "methodIndex": 0,
      "args": [
        {
          "type": "U256",
          "value": "0"
        }
      ],
      "interestedContracts": [
        "uomjgUz6D4tLejTkQtbNJMY8apAjTm1bgQf7em1wDV7S"
      ],
      "inputAssets": [
        {
          "address": "1AujpupFP4KWeZvqA7itsHY9cLJmx4qTzojVZrg8W9y",
          "asset": {
            "attoAlphAmount": "3000000000000000000",
            "tokens": [
              {
                "id": "20aa1fcc865087d7788302d087e4bc76691218ce5d5013dd1cedaabfac19cca4",
                "amount": "3000000000"
              }
            ]
          }
        }
      ]
    }
  ]
}

response = requests.post('https://alephium.nownodes.io/contracts/multicall-contract', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/contracts/multicall-contract')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "calls": [
      {
        "group": 0,
        "worldStateBlockHash": "bdaf9dc514ce7d34b6474b8ca10a3dfb93ba997cb9d5ff1ea724ebe2af48abe5",
        "txId": "503bfb16230888af4924aa8f8250d7d348b862e267d75d3147f1998050b6da69",
        "address": "tgx7VNFoP9DJiFMFgXXtafQZkUvyEdDHT9ryamHJYrjq",
        "methodIndex": 0,
        "args": [
          {
            "type": "U256",
            "value": "0"
          }
        ],
        "interestedContracts": [
          "uomjgUz6D4tLejTkQtbNJMY8apAjTm1bgQf7em1wDV7S"
        ],
        "inputAssets": [
          {
            "address": "1AujpupFP4KWeZvqA7itsHY9cLJmx4qTzojVZrg8W9y",
            "asset": {
              "attoAlphAmount": "3000000000000000000",
              "tokens": [
                {
                  "id": "20aa1fcc865087d7788302d087e4bc76691218ce5d5013dd1cedaabfac19cca4",
                  "amount": "3000000000"
                }
              ]
            }
          }
        ]
      }
    ]
  }'

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

Request Body

{
  "calls": [
    {
      "group": 0,
      "worldStateBlockHash": "bdaf9dc514ce7d34b6474b8ca10a3dfb93ba997cb9d5ff1ea724ebe2af48abe5",
      "txId": "503bfb16230888af4924aa8f8250d7d348b862e267d75d3147f1998050b6da69",
      "address": "tgx7VNFoP9DJiFMFgXXtafQZkUvyEdDHT9ryamHJYrjq",
      "methodIndex": 0,
      "args": [
        {
          "type": "U256",
          "value": "0"
        }
      ],
      "interestedContracts": [
        "uomjgUz6D4tLejTkQtbNJMY8apAjTm1bgQf7em1wDV7S"
      ],
      "inputAssets": [
        {
          "address": "1AujpupFP4KWeZvqA7itsHY9cLJmx4qTzojVZrg8W9y",
          "asset": {
            "attoAlphAmount": "3000000000000000000",
            "tokens": [
              {
                "id": "20aa1fcc865087d7788302d087e4bc76691218ce5d5013dd1cedaabfac19cca4",
                "amount": "3000000000"
              }
            ]
          }
        }
      ]
    }
  ]
}

{
  "results": [
    {
      "type": "CallContractSucceeded",
      "returns": [
        {
          "type": "U256",
          "value": "0"
        }
      ],
      "gasUsed": 20000,
      "contracts": [
        {
          "address": "vYZdgzNHHp7Qh9U5Rrv5H65eSJCGQTXEC4yuQCZ7mosA",
          "bytecode": "00010700000000000118",
          "codeHash": "c49d951065f85d0c673d33930e8476240c010a52313f99889ae06d9f0d92d2f9",
          "initialStateHash": "e195a4e597e62a6802a456224008b896566b7c961023954fab808a0f83d8ad63",
          "immFields": [
            {
              "type": "U256",
              "value": "1000000000000000000"
            }
          ],
          "mutFields": [
            {
              "type": "U256",
              "value": "2000000000000000000"
            }
          ],
          "asset": {
            "attoAlphAmount": "2000000000000000000",
            "tokens": [
              {
                "id": "bd165d20bd063c7a023d22232a1e75bf46e904067f92b49323fe89fa0fd586bf",
                "amount": "2000000000"
              }
            ]
          }
        }
      ],
      "txInputs": [
        "uomjgUz6D4tLejTkQtbNJMY8apAjTm1bgQf7em1wDV7S"
      ],
      "txOutputs": [
        {
          "type": "ContractOutput",
          "hint": 1,
          "key": "798e9e137aec7c2d59d9655b4ffa640f301f628bf7c365083bb255f6aa5f89ef",
          "attoAlphAmount": "1000000000000000000",
          "address": "uomjgUz6D4tLejTkQtbNJMY8apAjTm1bgQf7em1wDV7S",
          "tokens": [
            {
              "id": "2d11fd6c12435ffb07aaed4d190a505b621b927a5f6e51b61ce0ebe186397bdd",
              "amount": "42000000000000000000"
            },
            {
              "id": "bd165d20bd063c7a023d22232a1e75bf46e904067f92b49323fe89fa0fd586bf",
              "amount": "1000000000000000000000"
            }
          ]
        }
      ],
      "events": [
        {
          "blockHash": "bdaf9dc514ce7d34b6474b8ca10a3dfb93ba997cb9d5ff1ea724ebe2af48abe5",
          "contractAddress": "vSxdLL2kE3o6vJBdKkdgmS3W39G3ZEmFHpo2y1jnbzBq",
          "eventIndex": 1,
          "fields": [
            {
              "type": "Address",
              "value": "1AujpupFP4KWeZvqA7itsHY9cLJmx4qTzojVZrg8W9y"
            },
            {
              "type": "U256",
              "value": "10"
            }
          ]
        }
      ],
      "debugMessages": [
        {
          "contractAddress": "uomjgUz6D4tLejTkQtbNJMY8apAjTm1bgQf7em1wDV7S",
          "message": "Debugging!"
        }
      ]
    }
  ]
}

{
  "detail": "string"
}

{
  "detail": "string"
}

{
  "resource": "wallet-name",
  "detail": "wallet-name not found"
}

{
  "detail": "string"
}

{
  "detail": "string"
}

Call TxScript

POST

https://alephium.nownodes.io/contracts/call-tx-script

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Body

application/json

groupinteger<int32>required

bytecodestring<hex-string>required

callerAddressstring<address>

worldStateBlockHashstring<block-hash>

txIdstring<32-byte-hash>

inputAssetsArray<TestInputAsset>

Show child attributes

addressstring<address>required

assetAssetStaterequired

Show child attributes

attoAlphAmountstring<uint256>required

tokensArray<Token>

Show child attributes

idstring<32-byte-hash>required

amountstring<uint256>required

interestedContractsArray<string>

Response

200OK

Valid response

400Bad Request

BadRequest

401Unauthorized

Unauthorized

404Not Found

NotFound

500Internal Server Error

InternalServerError

503Service Unavailable

ServiceUnavailable

Call TxScript

curl -X POST 'https://alephium.nownodes.io/contracts/call-tx-script' \
  -H 'Content-Type: application/json' \
  -d '{
    "group": 0,
    "bytecode": "0011"
  }'

const response = await fetch('https://alephium.nownodes.io/contracts/call-tx-script', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "group": 0,
      "bytecode": "0011"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/contracts/call-tx-script')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "group": 0,
    "bytecode": "0011"
  }'

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

import requests

payload = {
  "group": 0,
  "bytecode": "0011"
}

response = requests.post('https://alephium.nownodes.io/contracts/call-tx-script', json=payload)
data = response.json()

const response = await fetch('https://alephium.nownodes.io/contracts/call-tx-script', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "group": 0,
      "bytecode": "0011"
    }),
});

const data = await response.json();

const endpoint = "https://alephium.nownodes.io/contracts/call-tx-script";
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({
    "group": 0,
    "bytecode": "0011"
  });
console.log(result);

const response = await fetch('https://alephium.nownodes.io/contracts/call-tx-script', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "group": 0,
      "bytecode": "0011"
    }),
});

const data = await response.json();

import requests

payload = {
  "group": 0,
  "bytecode": "0011"
}

response = requests.post('https://alephium.nownodes.io/contracts/call-tx-script', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/contracts/call-tx-script')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "group": 0,
    "bytecode": "0011"
  }'

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

Request Body

{
  "group": 0,
  "bytecode": "0011"
}

{
  "returns": [
    {
      "type": "U256",
      "value": "1"
    },
    {
      "type": "Bool",
      "value": false
    }
  ],
  "gasUsed": 100000,
  "contracts": [
    {
      "address": "vYZdgzNHHp7Qh9U5Rrv5H65eSJCGQTXEC4yuQCZ7mosA",
      "bytecode": "00010700000000000118",
      "codeHash": "c49d951065f85d0c673d33930e8476240c010a52313f99889ae06d9f0d92d2f9",
      "initialStateHash": "e195a4e597e62a6802a456224008b896566b7c961023954fab808a0f83d8ad63",
      "immFields": [
        {
          "type": "U256",
          "value": "1000000000000000000"
        }
      ],
      "mutFields": [
        {
          "type": "U256",
          "value": "2000000000000000000"
        }
      ],
      "asset": {
        "attoAlphAmount": "2000000000000000000",
        "tokens": [
          {
            "id": "bd165d20bd063c7a023d22232a1e75bf46e904067f92b49323fe89fa0fd586bf",
            "amount": "2000000000"
          }
        ]
      }
    }
  ],
  "txInputs": [
    "uomjgUz6D4tLejTkQtbNJMY8apAjTm1bgQf7em1wDV7S"
  ],
  "txOutputs": [
    {
      "type": "ContractOutput",
      "hint": 1,
      "key": "798e9e137aec7c2d59d9655b4ffa640f301f628bf7c365083bb255f6aa5f89ef",
      "attoAlphAmount": "1000000000000000000",
      "address": "uomjgUz6D4tLejTkQtbNJMY8apAjTm1bgQf7em1wDV7S",
      "tokens": [
        {
          "id": "2d11fd6c12435ffb07aaed4d190a505b621b927a5f6e51b61ce0ebe186397bdd",
          "amount": "42000000000000000000"
        },
        {
          "id": "bd165d20bd063c7a023d22232a1e75bf46e904067f92b49323fe89fa0fd586bf",
          "amount": "1000000000000000000000"
        }
      ]
    }
  ],
  "events": [],
  "debugMessages": []
}

{
  "detail": "string"
}

{
  "detail": "string"
}

{
  "resource": "wallet-name",
  "detail": "wallet-name not found"
}

{
  "detail": "string"
}

{
  "detail": "string"
}

Multi-signature

Create the multisig address and unlock script

POST

https://alephium.nownodes.io/multisig/address

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Body

application/json

Format 1: 1000000000000000000

Format 2: x.y ALPH, where `1 ALPH = 1000000000000000000

Field fromPublicKeyType can be default or bip340-schnorr

keysArray<string>required

mrequiredinteger<int32>required

Response

200OK

Valid response

400Bad Request

BadRequest

401Unauthorized

Unauthorized

404Not Found

NotFound

500Internal Server Error

InternalServerError

503Service Unavailable

ServiceUnavailable

Create the multisig address and unlock script

curl -X POST 'https://alephium.nownodes.io/multisig/address' \
  -H 'Content-Type: application/json' \
  -d '{
    "keys": [
      "d1b70d2226308b46da297486adb6b4f1a8c1842cb159ac5ec04f384fe2d6f5da28",
      "d1b70d2226308b46da297486adb6b4f1a8c1842cb159ac5ec04f384fe2d6f5da28"
    ],
    "mrequired": 1
  }'

const response = await fetch('https://alephium.nownodes.io/multisig/address', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "keys": [
        "d1b70d2226308b46da297486adb6b4f1a8c1842cb159ac5ec04f384fe2d6f5da28",
        "d1b70d2226308b46da297486adb6b4f1a8c1842cb159ac5ec04f384fe2d6f5da28"
      ],
      "mrequired": 1
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/multisig/address')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "keys": [
      "d1b70d2226308b46da297486adb6b4f1a8c1842cb159ac5ec04f384fe2d6f5da28",
      "d1b70d2226308b46da297486adb6b4f1a8c1842cb159ac5ec04f384fe2d6f5da28"
    ],
    "mrequired": 1
  }'

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

import requests

payload = {
  "keys": [
    "d1b70d2226308b46da297486adb6b4f1a8c1842cb159ac5ec04f384fe2d6f5da28",
    "d1b70d2226308b46da297486adb6b4f1a8c1842cb159ac5ec04f384fe2d6f5da28"
  ],
  "mrequired": 1
}

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

const response = await fetch('https://alephium.nownodes.io/multisig/address', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "keys": [
        "d1b70d2226308b46da297486adb6b4f1a8c1842cb159ac5ec04f384fe2d6f5da28",
        "d1b70d2226308b46da297486adb6b4f1a8c1842cb159ac5ec04f384fe2d6f5da28"
      ],
      "mrequired": 1
    }),
});

const data = await response.json();

const endpoint = "https://alephium.nownodes.io/multisig/address";
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({
    "keys": [
      "d1b70d2226308b46da297486adb6b4f1a8c1842cb159ac5ec04f384fe2d6f5da28",
      "d1b70d2226308b46da297486adb6b4f1a8c1842cb159ac5ec04f384fe2d6f5da28"
    ],
    "mrequired": 1
  });
console.log(result);

const response = await fetch('https://alephium.nownodes.io/multisig/address', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "keys": [
        "d1b70d2226308b46da297486adb6b4f1a8c1842cb159ac5ec04f384fe2d6f5da28",
        "d1b70d2226308b46da297486adb6b4f1a8c1842cb159ac5ec04f384fe2d6f5da28"
      ],
      "mrequired": 1
    }),
});

const data = await response.json();

import requests

payload = {
  "keys": [
    "d1b70d2226308b46da297486adb6b4f1a8c1842cb159ac5ec04f384fe2d6f5da28",
    "d1b70d2226308b46da297486adb6b4f1a8c1842cb159ac5ec04f384fe2d6f5da28"
  ],
  "mrequired": 1
}

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

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/multisig/address')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "keys": [
      "d1b70d2226308b46da297486adb6b4f1a8c1842cb159ac5ec04f384fe2d6f5da28",
      "d1b70d2226308b46da297486adb6b4f1a8c1842cb159ac5ec04f384fe2d6f5da28"
    ],
    "mrequired": 1
  }'

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

Request Body

{
  "keys": [
    "d1b70d2226308b46da297486adb6b4f1a8c1842cb159ac5ec04f384fe2d6f5da28",
    "d1b70d2226308b46da297486adb6b4f1a8c1842cb159ac5ec04f384fe2d6f5da28"
  ],
  "mrequired": 1
}

{
  "address": "1AujpupFP4KWeZvqA7itsHY9cLJmx4qTzojVZrg8W9y"
}

{
  "detail": "string"
}

{
  "detail": "string"
}

{
  "resource": "wallet-name",
  "detail": "wallet-name not found"
}

{
  "detail": "string"
}

{
  "detail": "string"
}

Build a multisig unsigned transaction

POST

https://alephium.nownodes.io/multisig/build

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Body

application/json

fromAddressstring<address>required

fromPublicKeysArray<string>required

destinationsArray<Destination>required

Show child attributes

addressstring<address>required

attoAlphAmountstring<uint256>required

tokensArray<Token>

Show child attributes

idstring<32-byte-hash>required

amountstring<uint256>required

lockTimeinteger<int64>

messagestring<hex-string>

gasinteger<gas>

gasPricestring<uint256>

Response

200OK

Valid response

400Bad Request

BadRequest

401Unauthorized

Unauthorized

404Not Found

NotFound

500Internal Server Error

InternalServerError

503Service Unavailable

ServiceUnavailable

Build a multisig unsigned transaction

curl -X POST 'https://alephium.nownodes.io/multisig/build' \
  -H 'Content-Type: application/json' \
  -d '{
    "fromAddress": "string",
    "fromPublicKeys": [
      "string"
    ],
    "destinations": [
      {
        "address": "string",
        "attoAlphAmount": "string",
        "tokens": [
          {
            "id": "string",
            "amount": "string"
          }
        ],
        "lockTime": 0,
        "message": "string"
      }
    ],
    "gas": 0,
    "gasPrice": "string"
  }'

const response = await fetch('https://alephium.nownodes.io/multisig/build', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "fromAddress": "string",
      "fromPublicKeys": [
        "string"
      ],
      "destinations": [
        {
          "address": "string",
          "attoAlphAmount": "string",
          "tokens": [
            {
              "id": "string",
              "amount": "string"
            }
          ],
          "lockTime": 0,
          "message": "string"
        }
      ],
      "gas": 0,
      "gasPrice": "string"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/multisig/build')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "fromAddress": "string",
    "fromPublicKeys": [
      "string"
    ],
    "destinations": [
      {
        "address": "string",
        "attoAlphAmount": "string",
        "tokens": [
          {
            "id": "string",
            "amount": "string"
          }
        ],
        "lockTime": 0,
        "message": "string"
      }
    ],
    "gas": 0,
    "gasPrice": "string"
  }'

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

import requests

payload = {
  "fromAddress": "string",
  "fromPublicKeys": [
    "string"
  ],
  "destinations": [
    {
      "address": "string",
      "attoAlphAmount": "string",
      "tokens": [
        {
          "id": "string",
          "amount": "string"
        }
      ],
      "lockTime": 0,
      "message": "string"
    }
  ],
  "gas": 0,
  "gasPrice": "string"
}

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

const response = await fetch('https://alephium.nownodes.io/multisig/build', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "fromAddress": "string",
      "fromPublicKeys": [
        "string"
      ],
      "destinations": [
        {
          "address": "string",
          "attoAlphAmount": "string",
          "tokens": [
            {
              "id": "string",
              "amount": "string"
            }
          ],
          "lockTime": 0,
          "message": "string"
        }
      ],
      "gas": 0,
      "gasPrice": "string"
    }),
});

const data = await response.json();

const endpoint = "https://alephium.nownodes.io/multisig/build";
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({
    "fromAddress": "string",
    "fromPublicKeys": [
      "string"
    ],
    "destinations": [
      {
        "address": "string",
        "attoAlphAmount": "string",
        "tokens": [
          {
            "id": "string",
            "amount": "string"
          }
        ],
        "lockTime": 0,
        "message": "string"
      }
    ],
    "gas": 0,
    "gasPrice": "string"
  });
console.log(result);

const response = await fetch('https://alephium.nownodes.io/multisig/build', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "fromAddress": "string",
      "fromPublicKeys": [
        "string"
      ],
      "destinations": [
        {
          "address": "string",
          "attoAlphAmount": "string",
          "tokens": [
            {
              "id": "string",
              "amount": "string"
            }
          ],
          "lockTime": 0,
          "message": "string"
        }
      ],
      "gas": 0,
      "gasPrice": "string"
    }),
});

const data = await response.json();

import requests

payload = {
  "fromAddress": "string",
  "fromPublicKeys": [
    "string"
  ],
  "destinations": [
    {
      "address": "string",
      "attoAlphAmount": "string",
      "tokens": [
        {
          "id": "string",
          "amount": "string"
        }
      ],
      "lockTime": 0,
      "message": "string"
    }
  ],
  "gas": 0,
  "gasPrice": "string"
}

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

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/multisig/build')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "fromAddress": "string",
    "fromPublicKeys": [
      "string"
    ],
    "destinations": [
      {
        "address": "string",
        "attoAlphAmount": "string",
        "tokens": [
          {
            "id": "string",
            "amount": "string"
          }
        ],
        "lockTime": 0,
        "message": "string"
      }
    ],
    "gas": 0,
    "gasPrice": "string"
  }'

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

Request Body

{
  "fromAddress": "1AujpupFP4KWeZvqA7itsHY9cLJmx4qTzojVZrg8W9y",
  "fromPublicKeys": [
    "d1b70d2226308b46da297486adb6b4f1a8c1842cb159ac5ec04f384fe2d6f5da28"
  ],
  "destinations": [
    {
      "address": "1AujpupFP4KWeZvqA7itsHY9cLJmx4qTzojVZrg8W9y",
      "attoAlphAmount": "2000000000000000000"
    }
  ]
}

{
  "fromAddress": "1AujpupFP4KWeZvqA7itsHY9cLJmx4qTzojVZrg8W9y",
  "fromPublicKeys": [
    "d1b70d2226308b46da297486adb6b4f1a8c1842cb159ac5ec04f384fe2d6f5da28"
  ],
  "destinations": [
    {
      "address": "1AujpupFP4KWeZvqA7itsHY9cLJmx4qTzojVZrg8W9y",
      "attoAlphAmount": "2000000000000000000",
      "tokens": [
        {
          "id": "2d11fd6c12435ffb07aaed4d190a505b621b927a5f6e51b61ce0ebe186397bdd",
          "amount": "42000000000000000000"
        },
        {
          "id": "bd165d20bd063c7a023d22232a1e75bf46e904067f92b49323fe89fa0fd586bf",
          "amount": "1000000000000000000000"
        }
      ],
      "lockTime": 1611041396892
    }
  ],
  "gas": 20000,
  "gasPrice": "100000000000"
}

{
  "unsignedTx": "35d1b2a520a0da34c5eb8d712aa9cc",
  "gasAmount": 20000,
  "gasPrice": "100000000000",
  "txId": "503bfb16230888af4924aa8f8250d7d348b862e267d75d3147f1998050b6da69",
  "fromGroup": 2,
  "toGroup": 1
}

{
  "detail": "string"
}

{
  "detail": "string"
}

{
  "resource": "wallet-name",
  "detail": "wallet-name not found"
}

{
  "detail": "string"
}

{
  "detail": "string"
}

Sweep all unlocked ALPH and token balances of a multisig address to another address

POST

https://alephium.nownodes.io/multisig/sweep

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Body

application/json

fromAddressstring<address>required

fromPublicKeysArray<string>required

toAddressstring<address>required

maxAttoAlphPerUTXOstring<uint256>

lockTimeinteger<int64>

gasAmountinteger<gas>

gasPricestring<uint256>

utxosLimitinteger<int32>

targetBlockHashstring<block-hash>

Response

200OK

Valid response

400Bad Request

BadRequest

401Unauthorized

Unauthorized

404Not Found

NotFound

500Internal Server Error

InternalServerError

503Service Unavailable

ServiceUnavailable

Sweep all unlocked ALPH and token balances of a multisig address to another address

curl -X POST 'https://alephium.nownodes.io/multisig/sweep' \
  -H 'Content-Type: application/json' \
  -d '{
    "fromAddress": "string",
    "fromPublicKeys": [
      "string"
    ],
    "toAddress": "string",
    "maxAttoAlphPerUTXO": "string",
    "lockTime": 0,
    "gasAmount": 0,
    "gasPrice": "string",
    "utxosLimit": 0,
    "targetBlockHash": "string"
  }'

const response = await fetch('https://alephium.nownodes.io/multisig/sweep', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "fromAddress": "string",
      "fromPublicKeys": [
        "string"
      ],
      "toAddress": "string",
      "maxAttoAlphPerUTXO": "string",
      "lockTime": 0,
      "gasAmount": 0,
      "gasPrice": "string",
      "utxosLimit": 0,
      "targetBlockHash": "string"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/multisig/sweep')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "fromAddress": "string",
    "fromPublicKeys": [
      "string"
    ],
    "toAddress": "string",
    "maxAttoAlphPerUTXO": "string",
    "lockTime": 0,
    "gasAmount": 0,
    "gasPrice": "string",
    "utxosLimit": 0,
    "targetBlockHash": "string"
  }'

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

import requests

payload = {
  "fromAddress": "string",
  "fromPublicKeys": [
    "string"
  ],
  "toAddress": "string",
  "maxAttoAlphPerUTXO": "string",
  "lockTime": 0,
  "gasAmount": 0,
  "gasPrice": "string",
  "utxosLimit": 0,
  "targetBlockHash": "string"
}

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

const response = await fetch('https://alephium.nownodes.io/multisig/sweep', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "fromAddress": "string",
      "fromPublicKeys": [
        "string"
      ],
      "toAddress": "string",
      "maxAttoAlphPerUTXO": "string",
      "lockTime": 0,
      "gasAmount": 0,
      "gasPrice": "string",
      "utxosLimit": 0,
      "targetBlockHash": "string"
    }),
});

const data = await response.json();

const endpoint = "https://alephium.nownodes.io/multisig/sweep";
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({
    "fromAddress": "string",
    "fromPublicKeys": [
      "string"
    ],
    "toAddress": "string",
    "maxAttoAlphPerUTXO": "string",
    "lockTime": 0,
    "gasAmount": 0,
    "gasPrice": "string",
    "utxosLimit": 0,
    "targetBlockHash": "string"
  });
console.log(result);

const response = await fetch('https://alephium.nownodes.io/multisig/sweep', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "fromAddress": "string",
      "fromPublicKeys": [
        "string"
      ],
      "toAddress": "string",
      "maxAttoAlphPerUTXO": "string",
      "lockTime": 0,
      "gasAmount": 0,
      "gasPrice": "string",
      "utxosLimit": 0,
      "targetBlockHash": "string"
    }),
});

const data = await response.json();

import requests

payload = {
  "fromAddress": "string",
  "fromPublicKeys": [
    "string"
  ],
  "toAddress": "string",
  "maxAttoAlphPerUTXO": "string",
  "lockTime": 0,
  "gasAmount": 0,
  "gasPrice": "string",
  "utxosLimit": 0,
  "targetBlockHash": "string"
}

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

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/multisig/sweep')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "fromAddress": "string",
    "fromPublicKeys": [
      "string"
    ],
    "toAddress": "string",
    "maxAttoAlphPerUTXO": "string",
    "lockTime": 0,
    "gasAmount": 0,
    "gasPrice": "string",
    "utxosLimit": 0,
    "targetBlockHash": "string"
  }'

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

Request Body

{
  "fromAddress": "1AujpupFP4KWeZvqA7itsHY9cLJmx4qTzojVZrg8W9y",
  "fromPublicKeys": [
    "d1b70d2226308b46da297486adb6b4f1a8c1842cb159ac5ec04f384fe2d6f5da28"
  ],
  "toAddress": "1AujpupFP4KWeZvqA7itsHY9cLJmx4qTzojVZrg8W9y"
}

{
  "fromAddress": "1AujpupFP4KWeZvqA7itsHY9cLJmx4qTzojVZrg8W9y",
  "fromPublicKeys": [
    "d1b70d2226308b46da297486adb6b4f1a8c1842cb159ac5ec04f384fe2d6f5da28"
  ],
  "toAddress": "1AujpupFP4KWeZvqA7itsHY9cLJmx4qTzojVZrg8W9y",
  "maxAttoAlphPerUTXO": "1000000000000000000",
  "lockTime": 1611041396892,
  "gasAmount": 20000,
  "gasPrice": "100000000000",
  "utxosLimit": 10,
  "targetBlockHash": "bdaf9dc514ce7d34b6474b8ca10a3dfb93ba997cb9d5ff1ea724ebe2af48abe5"
}

{
  "unsignedTxs": [
    {
      "txId": "503bfb16230888af4924aa8f8250d7d348b862e267d75d3147f1998050b6da69",
      "unsignedTx": "35d1b2a520a0da34c5eb8d712aa9cc",
      "gasAmount": 20000,
      "gasPrice": "100000000000"
    }
  ],
  "fromGroup": 2,
  "toGroup": 1
}

{
  "detail": "string"
}

{
  "detail": "string"
}

{
  "resource": "wallet-name",
  "detail": "wallet-name not found"
}

{
  "detail": "string"
}

{
  "detail": "string"
}

Submit a multi-signed transaction

POST

https://alephium.nownodes.io/multisig/submit

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Body

application/json

unsignedTxstringrequired

signaturesArray<string>required

Response

200OK

Valid response

400Bad Request

BadRequest

401Unauthorized

Unauthorized

404Not Found

NotFound

500Internal Server Error

InternalServerError

503Service Unavailable

ServiceUnavailable

Submit a multi-signed transaction

curl -X POST 'https://alephium.nownodes.io/multisig/submit' \
  -H 'Content-Type: application/json' \
  -d '{
    "unsignedTx": "35d1b2a520a0da34c5eb8d712aa9cc",
    "signatures": [
      "9e1a35b2931bd04e6780d01c36e3e5337941aa80f173cfe4f4e249c44ab135272b834c1a639db9c89d673a8a30524042b0469672ca845458a5a0cf2cad53221b"
    ]
  }'

const response = await fetch('https://alephium.nownodes.io/multisig/submit', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "unsignedTx": "35d1b2a520a0da34c5eb8d712aa9cc",
      "signatures": [
        "9e1a35b2931bd04e6780d01c36e3e5337941aa80f173cfe4f4e249c44ab135272b834c1a639db9c89d673a8a30524042b0469672ca845458a5a0cf2cad53221b"
      ]
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/multisig/submit')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "unsignedTx": "35d1b2a520a0da34c5eb8d712aa9cc",
    "signatures": [
      "9e1a35b2931bd04e6780d01c36e3e5337941aa80f173cfe4f4e249c44ab135272b834c1a639db9c89d673a8a30524042b0469672ca845458a5a0cf2cad53221b"
    ]
  }'

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

import requests

payload = {
  "unsignedTx": "35d1b2a520a0da34c5eb8d712aa9cc",
  "signatures": [
    "9e1a35b2931bd04e6780d01c36e3e5337941aa80f173cfe4f4e249c44ab135272b834c1a639db9c89d673a8a30524042b0469672ca845458a5a0cf2cad53221b"
  ]
}

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

const response = await fetch('https://alephium.nownodes.io/multisig/submit', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "unsignedTx": "35d1b2a520a0da34c5eb8d712aa9cc",
      "signatures": [
        "9e1a35b2931bd04e6780d01c36e3e5337941aa80f173cfe4f4e249c44ab135272b834c1a639db9c89d673a8a30524042b0469672ca845458a5a0cf2cad53221b"
      ]
    }),
});

const data = await response.json();

const endpoint = "https://alephium.nownodes.io/multisig/submit";
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({
    "unsignedTx": "35d1b2a520a0da34c5eb8d712aa9cc",
    "signatures": [
      "9e1a35b2931bd04e6780d01c36e3e5337941aa80f173cfe4f4e249c44ab135272b834c1a639db9c89d673a8a30524042b0469672ca845458a5a0cf2cad53221b"
    ]
  });
console.log(result);

const response = await fetch('https://alephium.nownodes.io/multisig/submit', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "unsignedTx": "35d1b2a520a0da34c5eb8d712aa9cc",
      "signatures": [
        "9e1a35b2931bd04e6780d01c36e3e5337941aa80f173cfe4f4e249c44ab135272b834c1a639db9c89d673a8a30524042b0469672ca845458a5a0cf2cad53221b"
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "unsignedTx": "35d1b2a520a0da34c5eb8d712aa9cc",
  "signatures": [
    "9e1a35b2931bd04e6780d01c36e3e5337941aa80f173cfe4f4e249c44ab135272b834c1a639db9c89d673a8a30524042b0469672ca845458a5a0cf2cad53221b"
  ]
}

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

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/multisig/submit')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "unsignedTx": "35d1b2a520a0da34c5eb8d712aa9cc",
    "signatures": [
      "9e1a35b2931bd04e6780d01c36e3e5337941aa80f173cfe4f4e249c44ab135272b834c1a639db9c89d673a8a30524042b0469672ca845458a5a0cf2cad53221b"
    ]
  }'

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

Request Body

{
  "unsignedTx": "35d1b2a520a0da34c5eb8d712aa9cc",
  "signatures": [
    "9e1a35b2931bd04e6780d01c36e3e5337941aa80f173cfe4f4e249c44ab135272b834c1a639db9c89d673a8a30524042b0469672ca845458a5a0cf2cad53221b"
  ]
}

{
  "txId": "503bfb16230888af4924aa8f8250d7d348b862e267d75d3147f1998050b6da69",
  "fromGroup": 2,
  "toGroup": 1
}

{
  "detail": "string"
}

{
  "detail": "string"
}

{
  "resource": "wallet-name",
  "detail": "wallet-name not found"
}

{
  "detail": "string"
}

{
  "detail": "string"
}

Events

Get events for a contract within a counter range

GET

https://alephium.nownodes.io/events/contract/{contractAddress}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

contractAddressstring<address>requiredpath

startinteger<int32>requiredquery

limitinteger<int32>query

groupinteger<int32>query

Response

200OK

Valid response

400Bad Request

BadRequest

401Unauthorized

Unauthorized

404Not Found

NotFound

500Internal Server Error

InternalServerError

503Service Unavailable

ServiceUnavailable

Get events for a contract within a counter range

curl -X GET 'https://alephium.nownodes.io/events/contract/{contractAddress}'

const response = await fetch('https://alephium.nownodes.io/events/contract/{contractAddress}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/events/contract/{contractAddress}')
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://alephium.nownodes.io/events/contract/{contractAddress}')
data = response.json()

const response = await fetch('https://alephium.nownodes.io/events/contract/{contractAddress}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://alephium.nownodes.io/events/contract/{contractAddress}";
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://alephium.nownodes.io/events/contract/{contractAddress}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://alephium.nownodes.io/events/contract/{contractAddress}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/events/contract/{contractAddress}')
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)

{
  "events": [
    {
      "blockHash": "bdaf9dc514ce7d34b6474b8ca10a3dfb93ba997cb9d5ff1ea724ebe2af48abe5",
      "txId": "503bfb16230888af4924aa8f8250d7d348b862e267d75d3147f1998050b6da69",
      "eventIndex": 1,
      "fields": [
        {
          "type": "Address",
          "value": "1AujpupFP4KWeZvqA7itsHY9cLJmx4qTzojVZrg8W9y"
        },
        {
          "type": "U256",
          "value": "10"
        }
      ]
    }
  ],
  "nextStart": 2
}

{
  "detail": "string"
}

{
  "detail": "string"
}

{
  "resource": "wallet-name",
  "detail": "wallet-name not found"
}

{
  "detail": "string"
}

{
  "detail": "string"
}

Get current value of the events counter for a contract

GET

https://alephium.nownodes.io/events/contract/{contractAddress}/current-count

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

contractAddressstring<address>requiredpath

Response

200OK

Valid response

400Bad Request

BadRequest

401Unauthorized

Unauthorized

404Not Found

NotFound

500Internal Server Error

InternalServerError

503Service Unavailable

ServiceUnavailable

Get current value of the events counter for a contract

curl -X GET 'https://alephium.nownodes.io/events/contract/{contractAddress}/current-count'

const response = await fetch('https://alephium.nownodes.io/events/contract/{contractAddress}/current-count', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/events/contract/{contractAddress}/current-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://alephium.nownodes.io/events/contract/{contractAddress}/current-count')
data = response.json()

const response = await fetch('https://alephium.nownodes.io/events/contract/{contractAddress}/current-count', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://alephium.nownodes.io/events/contract/{contractAddress}/current-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://alephium.nownodes.io/events/contract/{contractAddress}/current-count', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://alephium.nownodes.io/events/contract/{contractAddress}/current-count')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/events/contract/{contractAddress}/current-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)

{
  "detail": "string"
}

{
  "detail": "string"
}

{
  "resource": "wallet-name",
  "detail": "wallet-name not found"
}

{
  "detail": "string"
}

{
  "detail": "string"
}

Get contract events for a transaction

GET

https://alephium.nownodes.io/events/tx-id/{txId}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

txIdstring<32-byte-hash>requiredpath

groupinteger<int32>query

Response

200OK

Valid response

400Bad Request

BadRequest

401Unauthorized

Unauthorized

404Not Found

NotFound

500Internal Server Error

InternalServerError

503Service Unavailable

ServiceUnavailable

Get contract events for a transaction

curl -X GET 'https://alephium.nownodes.io/events/tx-id/{txId}'

const response = await fetch('https://alephium.nownodes.io/events/tx-id/{txId}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/events/tx-id/{txId}')
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://alephium.nownodes.io/events/tx-id/{txId}')
data = response.json()

const response = await fetch('https://alephium.nownodes.io/events/tx-id/{txId}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://alephium.nownodes.io/events/tx-id/{txId}";
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://alephium.nownodes.io/events/tx-id/{txId}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://alephium.nownodes.io/events/tx-id/{txId}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/events/tx-id/{txId}')
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)

{
  "events": [
    {
      "blockHash": "bdaf9dc514ce7d34b6474b8ca10a3dfb93ba997cb9d5ff1ea724ebe2af48abe5",
      "contractAddress": "vSxdLL2kE3o6vJBdKkdgmS3W39G3ZEmFHpo2y1jnbzBq",
      "eventIndex": 1,
      "fields": [
        {
          "type": "Address",
          "value": "1AujpupFP4KWeZvqA7itsHY9cLJmx4qTzojVZrg8W9y"
        },
        {
          "type": "U256",
          "value": "10"
        }
      ]
    }
  ]
}

{
  "detail": "string"
}

{
  "detail": "string"
}

{
  "resource": "wallet-name",
  "detail": "wallet-name not found"
}

{
  "detail": "string"
}

{
  "detail": "string"
}

Get contract events for a block

GET

https://alephium.nownodes.io/events/block-hash/{blockHash}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

blockHashstring<block-hash>requiredpath

groupinteger<int32>query

Response

200OK

Valid response

400Bad Request

BadRequest

401Unauthorized

Unauthorized

404Not Found

NotFound

500Internal Server Error

InternalServerError

503Service Unavailable

ServiceUnavailable

Get contract events for a block

curl -X GET 'https://alephium.nownodes.io/events/block-hash/{blockHash}'

const response = await fetch('https://alephium.nownodes.io/events/block-hash/{blockHash}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/events/block-hash/{blockHash}')
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://alephium.nownodes.io/events/block-hash/{blockHash}')
data = response.json()

const response = await fetch('https://alephium.nownodes.io/events/block-hash/{blockHash}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://alephium.nownodes.io/events/block-hash/{blockHash}";
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://alephium.nownodes.io/events/block-hash/{blockHash}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://alephium.nownodes.io/events/block-hash/{blockHash}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/events/block-hash/{blockHash}')
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)

{
  "events": [
    {
      "txId": "503bfb16230888af4924aa8f8250d7d348b862e267d75d3147f1998050b6da69",
      "contractAddress": "vSxdLL2kE3o6vJBdKkdgmS3W39G3ZEmFHpo2y1jnbzBq",
      "eventIndex": 1,
      "fields": [
        {
          "type": "Address",
          "value": "1AujpupFP4KWeZvqA7itsHY9cLJmx4qTzojVZrg8W9y"
        },
        {
          "type": "U256",
          "value": "10"
        }
      ]
    }
  ]
}

{
  "detail": "string"
}

{
  "detail": "string"
}

{
  "resource": "wallet-name",
  "detail": "wallet-name not found"
}

{
  "detail": "string"
}

{
  "detail": "string"
}

Utils

Verify the SecP256K1 signature of some data

POST

https://alephium.nownodes.io/utils/verify-signature

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Body

application/json

datastring<hex-string>required

signaturestring<signature>required

publicKeystring<public-key>required

Response

200OK

Valid response

400Bad Request

BadRequest

401Unauthorized

Unauthorized

404Not Found

NotFound

500Internal Server Error

InternalServerError

503Service Unavailable

ServiceUnavailable

Verify the SecP256K1 signature of some data

curl -X POST 'https://alephium.nownodes.io/utils/verify-signature' \
  -H 'Content-Type: application/json' \
  -d '{
    "data": "35d1b2a520a0da34c5eb8d712aa9cc",
    "signature": "9e1a35b2931bd04e6780d01c36e3e5337941aa80f173cfe4f4e249c44ab135272b834c1a639db9c89d673a8a30524042b0469672ca845458a5a0cf2cad53221b",
    "publicKey": "d1b70d2226308b46da297486adb6b4f1a8c1842cb159ac5ec04f384fe2d6f5da28"
  }'

const response = await fetch('https://alephium.nownodes.io/utils/verify-signature', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "data": "35d1b2a520a0da34c5eb8d712aa9cc",
      "signature": "9e1a35b2931bd04e6780d01c36e3e5337941aa80f173cfe4f4e249c44ab135272b834c1a639db9c89d673a8a30524042b0469672ca845458a5a0cf2cad53221b",
      "publicKey": "d1b70d2226308b46da297486adb6b4f1a8c1842cb159ac5ec04f384fe2d6f5da28"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/utils/verify-signature')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "data": "35d1b2a520a0da34c5eb8d712aa9cc",
    "signature": "9e1a35b2931bd04e6780d01c36e3e5337941aa80f173cfe4f4e249c44ab135272b834c1a639db9c89d673a8a30524042b0469672ca845458a5a0cf2cad53221b",
    "publicKey": "d1b70d2226308b46da297486adb6b4f1a8c1842cb159ac5ec04f384fe2d6f5da28"
  }'

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

import requests

payload = {
  "data": "35d1b2a520a0da34c5eb8d712aa9cc",
  "signature": "9e1a35b2931bd04e6780d01c36e3e5337941aa80f173cfe4f4e249c44ab135272b834c1a639db9c89d673a8a30524042b0469672ca845458a5a0cf2cad53221b",
  "publicKey": "d1b70d2226308b46da297486adb6b4f1a8c1842cb159ac5ec04f384fe2d6f5da28"
}

response = requests.post('https://alephium.nownodes.io/utils/verify-signature', json=payload)
data = response.json()

const response = await fetch('https://alephium.nownodes.io/utils/verify-signature', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "data": "35d1b2a520a0da34c5eb8d712aa9cc",
      "signature": "9e1a35b2931bd04e6780d01c36e3e5337941aa80f173cfe4f4e249c44ab135272b834c1a639db9c89d673a8a30524042b0469672ca845458a5a0cf2cad53221b",
      "publicKey": "d1b70d2226308b46da297486adb6b4f1a8c1842cb159ac5ec04f384fe2d6f5da28"
    }),
});

const data = await response.json();

const endpoint = "https://alephium.nownodes.io/utils/verify-signature";
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({
    "data": "35d1b2a520a0da34c5eb8d712aa9cc",
    "signature": "9e1a35b2931bd04e6780d01c36e3e5337941aa80f173cfe4f4e249c44ab135272b834c1a639db9c89d673a8a30524042b0469672ca845458a5a0cf2cad53221b",
    "publicKey": "d1b70d2226308b46da297486adb6b4f1a8c1842cb159ac5ec04f384fe2d6f5da28"
  });
console.log(result);

const response = await fetch('https://alephium.nownodes.io/utils/verify-signature', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "data": "35d1b2a520a0da34c5eb8d712aa9cc",
      "signature": "9e1a35b2931bd04e6780d01c36e3e5337941aa80f173cfe4f4e249c44ab135272b834c1a639db9c89d673a8a30524042b0469672ca845458a5a0cf2cad53221b",
      "publicKey": "d1b70d2226308b46da297486adb6b4f1a8c1842cb159ac5ec04f384fe2d6f5da28"
    }),
});

const data = await response.json();

import requests

payload = {
  "data": "35d1b2a520a0da34c5eb8d712aa9cc",
  "signature": "9e1a35b2931bd04e6780d01c36e3e5337941aa80f173cfe4f4e249c44ab135272b834c1a639db9c89d673a8a30524042b0469672ca845458a5a0cf2cad53221b",
  "publicKey": "d1b70d2226308b46da297486adb6b4f1a8c1842cb159ac5ec04f384fe2d6f5da28"
}

response = requests.post('https://alephium.nownodes.io/utils/verify-signature', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/utils/verify-signature')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "data": "35d1b2a520a0da34c5eb8d712aa9cc",
    "signature": "9e1a35b2931bd04e6780d01c36e3e5337941aa80f173cfe4f4e249c44ab135272b834c1a639db9c89d673a8a30524042b0469672ca845458a5a0cf2cad53221b",
    "publicKey": "d1b70d2226308b46da297486adb6b4f1a8c1842cb159ac5ec04f384fe2d6f5da28"
  }'

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

Request Body

{
  "data": "35d1b2a520a0da34c5eb8d712aa9cc",
  "signature": "9e1a35b2931bd04e6780d01c36e3e5337941aa80f173cfe4f4e249c44ab135272b834c1a639db9c89d673a8a30524042b0469672ca845458a5a0cf2cad53221b",
  "publicKey": "d1b70d2226308b46da297486adb6b4f1a8c1842cb159ac5ec04f384fe2d6f5da28"
}

true

{
  "detail": "string"
}

{
  "detail": "string"
}

{
  "resource": "wallet-name",
  "detail": "wallet-name not found"
}

{
  "detail": "string"
}

{
  "detail": "string"
}

Convert a target to hashrate

POST

https://alephium.nownodes.io/utils/target-to-hashrate

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Body

application/json

targetstring<hex-string>required

Response

200OK

Valid response

400Bad Request

BadRequest

401Unauthorized

Unauthorized

404Not Found

NotFound

500Internal Server Error

InternalServerError

503Service Unavailable

ServiceUnavailable

Convert a target to hashrate

curl -X POST 'https://alephium.nownodes.io/utils/target-to-hashrate' \
  -H 'Content-Type: application/json' \
  -d '{
    "target": "string"
  }'

const response = await fetch('https://alephium.nownodes.io/utils/target-to-hashrate', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "target": "string"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/utils/target-to-hashrate')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "target": "string"
  }'

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

import requests

payload = {
  "target": "string"
}

response = requests.post('https://alephium.nownodes.io/utils/target-to-hashrate', json=payload)
data = response.json()

const response = await fetch('https://alephium.nownodes.io/utils/target-to-hashrate', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "target": "string"
    }),
});

const data = await response.json();

const endpoint = "https://alephium.nownodes.io/utils/target-to-hashrate";
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({
    "target": "string"
  });
console.log(result);

const response = await fetch('https://alephium.nownodes.io/utils/target-to-hashrate', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "target": "string"
    }),
});

const data = await response.json();

import requests

payload = {
  "target": "string"
}

response = requests.post('https://alephium.nownodes.io/utils/target-to-hashrate', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://alephium.nownodes.io/utils/target-to-hashrate')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "target": "string"
  }'

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

Request Body

{
  "target": "string"
}

{
  "hashrate": "string"
}

{
  "detail": "string"
}

{
  "detail": "string"
}

{
  "resource": "wallet-name",
  "detail": "wallet-name not found"
}

{
  "detail": "string"
}

{
  "detail": "string"
}

Documentation

How to migrate to NOWNodes

Authentication

Node

Infos

Authorizations

Response

Authorizations

Response

Authorizations

Response

Authorizations

Response

Authorizations

Response

Authorizations

Response

Authorizations

Response

Authorizations

Response

Authorizations

Parameters

Response

Authorizations

Response

Authorizations

Response

Blockflow

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Addresses

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Transactions

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations