Algod REST API.

v1.0.0

Base URL

https://algo.nownodes.io

API endpoint for algod operations.

Authentication

api-keyAuthapiKey

API Key: api-key in header

API Reference

Genesis

Gets the genesis information.

GET

https://algo.nownodes.io/genesis

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the entire genesis file in json.

Response

200OK

The genesis file in json.

default

Unknown Error

Gets the genesis information.

curl -X GET 'https://algo.nownodes.io/genesis'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://algo.nownodes.io/genesis')
data = response.json()

require 'net/http'
require 'json'

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

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

200

"string"

Health

Returns OK if healthy.

GET

https://algo.nownodes.io/health

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Response

200OK

OK.

default

Unknown Error

Returns OK if healthy.

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

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

import requests

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

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

const data = await response.json();

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

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

  return response.json();
}

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

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

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

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

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

Metrics

Return metrics about algod functioning.

GET

https://algo.nownodes.io/metrics

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Response

200OK

text with #-comments and key:value lines

404Not Found

metrics were compiled out

Return metrics about algod functioning.

curl -X GET 'https://algo.nownodes.io/metrics'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://algo.nownodes.io/metrics')
data = response.json()

require 'net/http'
require 'json'

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

Ready

Returns OK if healthy and fully caught up.

GET

https://algo.nownodes.io/ready

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Response

200OK

OK.

500Internal Server Error

Internal Error

503Service Unavailable

Node not ready yet

default

Unknown Error

Returns OK if healthy and fully caught up.

curl -X GET 'https://algo.nownodes.io/ready'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://algo.nownodes.io/ready')
data = response.json()

require 'net/http'
require 'json'

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

Swagger

Gets the current swagger spec.

GET

https://algo.nownodes.io/swagger.json

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the entire swagger spec in json.

Response

200OK

The current swagger spec

default

Unknown Error

Gets the current swagger spec.

curl -X GET 'https://algo.nownodes.io/swagger.json'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://algo.nownodes.io/swagger.json')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/swagger.json')
request = Net::HTTP::Get.new(uri)

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

200

"string"

Accounts

Get account information.

GET

https://algo.nownodes.io/v2/accounts/{address}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Given a specific account public key, this call returns the accounts status, balance and spendable amounts

Parameters

formatstringjsonmsgpackquery

Configures whether the response object is JSON or MessagePack encoded. If not provided, defaults to JSON.

addressstringrequiredpath

An account public key

excludestringallnonequery

When set to all will exclude asset holdings, application local state, created asset parameters, any created application parameters. Defaults to none.

Response

200OK

AccountResponse wraps the Account type in a response.

400Bad Request

Bad request

401Unauthorized

Invalid API Token

500Internal Server Error

Internal Error

default

Unknown Error

Get account information.

curl -X GET 'https://algo.nownodes.io/v2/accounts/{address}'

const response = await fetch('https://algo.nownodes.io/v2/accounts/{address}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

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

const response = await fetch('https://algo.nownodes.io/v2/accounts/{address}', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://algo.nownodes.io/v2/accounts/{address}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v2/accounts/{address}')
request = Net::HTTP::Get.new(uri)

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

{
  "address": "string",
  "amount": 0,
  "amount-without-pending-rewards": 0,
  "apps-local-state": [
    {
      "id": 0,
      "key-value": [
        {
          "key": "string",
          "value": {
            "bytes": "string",
            "type": 0,
            "uint": 0
          }
        }
      ],
      "schema": {
        "num-byte-slice": 0,
        "num-uint": 0
      }
    }
  ],
  "apps-total-extra-pages": 0,
  "apps-total-schema": {
    "num-byte-slice": 0,
    "num-uint": 0
  },
  "assets": [
    {
      "amount": 0,
      "asset-id": 0,
      "is-frozen": true
    }
  ],
  "auth-addr": "string",
  "created-apps": [
    {
      "id": 0,
      "params": {
        "approval-program": "dGVzdA==",
        "clear-state-program": "dGVzdA==",
        "creator": "string",
        "extra-program-pages": 0,
        "global-state": [
          {
            "key": "string",
            "value": {
              "bytes": "string",
              "type": 0,
              "uint": 0
            }
          }
        ],
        "global-state-schema": {
          "num-byte-slice": 0,
          "num-uint": 0
        },
        "local-state-schema": {
          "num-byte-slice": 0,
          "num-uint": 0
        }
      }
    }
  ],
  "created-assets": [
    {
      "index": 0,
      "params": {
        "clawback": "string",
        "creator": "string",
        "decimals": 0,
        "default-frozen": true,
        "freeze": "string",
        "manager": "string",
        "metadata-hash": "dGVzdA==",
        "name": "string",
        "name-b64": "dGVzdA==",
        "reserve": "string",
        "total": 0,
        "unit-name": "string",
        "unit-name-b64": "dGVzdA==",
        "url": "string",
        "url-b64": "dGVzdA=="
      }
    }
  ],
  "min-balance": 0,
  "participation": {
    "selection-participation-key": "dGVzdA==",
    "state-proof-key": "dGVzdA==",
    "vote-first-valid": 0,
    "vote-key-dilution": 0,
    "vote-last-valid": 0,
    "vote-participation-key": "dGVzdA=="
  },
  "pending-rewards": 0,
  "reward-base": 0,
  "rewards": 0,
  "round": 0,
  "sig-type": "sig",
  "status": "string",
  "total-apps-opted-in": 0,
  "total-assets-opted-in": 0,
  "total-box-bytes": 0,
  "total-boxes": 0,
  "total-created-apps": 0,
  "total-created-assets": 0
}

{
  "address": "string",
  "amount": 0,
  "amount-without-pending-rewards": 0,
  "apps-local-state": [
    {
      "id": 0,
      "key-value": [
        {
          "key": "string",
          "value": {
            "bytes": "string",
            "type": 0,
            "uint": 0
          }
        }
      ],
      "schema": {
        "num-byte-slice": 0,
        "num-uint": 0
      }
    }
  ],
  "apps-total-extra-pages": 0,
  "apps-total-schema": {
    "num-byte-slice": 0,
    "num-uint": 0
  },
  "assets": [
    {
      "amount": 0,
      "asset-id": 0,
      "is-frozen": true
    }
  ],
  "auth-addr": "string",
  "created-apps": [
    {
      "id": 0,
      "params": {
        "approval-program": "dGVzdA==",
        "clear-state-program": "dGVzdA==",
        "creator": "string",
        "extra-program-pages": 0,
        "global-state": [
          {
            "key": "string",
            "value": {
              "bytes": "string",
              "type": 0,
              "uint": 0
            }
          }
        ],
        "global-state-schema": {
          "num-byte-slice": 0,
          "num-uint": 0
        },
        "local-state-schema": {
          "num-byte-slice": 0,
          "num-uint": 0
        }
      }
    }
  ],
  "created-assets": [
    {
      "index": 0,
      "params": {
        "clawback": "string",
        "creator": "string",
        "decimals": 0,
        "default-frozen": true,
        "freeze": "string",
        "manager": "string",
        "metadata-hash": "dGVzdA==",
        "name": "string",
        "name-b64": "dGVzdA==",
        "reserve": "string",
        "total": 0,
        "unit-name": "string",
        "unit-name-b64": "dGVzdA==",
        "url": "string",
        "url-b64": "dGVzdA=="
      }
    }
  ],
  "min-balance": 0,
  "participation": {
    "selection-participation-key": "dGVzdA==",
    "state-proof-key": "dGVzdA==",
    "vote-first-valid": 0,
    "vote-key-dilution": 0,
    "vote-last-valid": 0,
    "vote-participation-key": "dGVzdA=="
  },
  "pending-rewards": 0,
  "reward-base": 0,
  "rewards": 0,
  "round": 0,
  "sig-type": "sig",
  "status": "string",
  "total-apps-opted-in": 0,
  "total-assets-opted-in": 0,
  "total-box-bytes": 0,
  "total-boxes": 0,
  "total-created-apps": 0,
  "total-created-assets": 0
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

Get account information about a given app.

GET

https://algo.nownodes.io/v2/accounts/{address}/applications/{application-id}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Given a specific account public key and application ID, this call returns the account's application local state and global state (AppLocalState and AppParams, if either exists). Global state will only be returned if the provided address is the application's creator.

Parameters

formatstringjsonmsgpackquery

Configures whether the response object is JSON or MessagePack encoded. If not provided, defaults to JSON.

addressstringrequiredpath

An account public key

application-idintegerrequiredpath

An application identifier

Response

200OK

AccountApplicationResponse describes the account's application local state and global state (AppLocalState and AppParams, if either exists) for a specific application ID. Global state will only be returned if the provided address is the application's creator.

400Bad Request

Malformed address or application ID

401Unauthorized

Invalid API Token

500Internal Server Error

Internal Error

default

Unknown Error

Get account information about a given app.

curl -X GET 'https://algo.nownodes.io/v2/accounts/{address}/applications/{application-id}'

const response = await fetch('https://algo.nownodes.io/v2/accounts/{address}/applications/{application-id}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v2/accounts/{address}/applications/{application-id}')
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://algo.nownodes.io/v2/accounts/{address}/applications/{application-id}')
data = response.json()

const response = await fetch('https://algo.nownodes.io/v2/accounts/{address}/applications/{application-id}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://algo.nownodes.io/v2/accounts/{address}/applications/{application-id}";
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://algo.nownodes.io/v2/accounts/{address}/applications/{application-id}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://algo.nownodes.io/v2/accounts/{address}/applications/{application-id}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v2/accounts/{address}/applications/{application-id}')
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)

{
  "app-local-state": {
    "id": 0,
    "key-value": [
      {
        "key": "string",
        "value": {
          "bytes": "string",
          "type": 0,
          "uint": 0
        }
      }
    ],
    "schema": {
      "num-byte-slice": 0,
      "num-uint": 0
    }
  },
  "created-app": {
    "approval-program": "dGVzdA==",
    "clear-state-program": "dGVzdA==",
    "creator": "string",
    "extra-program-pages": 0,
    "global-state": [
      {
        "key": "string",
        "value": {
          "bytes": "string",
          "type": 0,
          "uint": 0
        }
      }
    ],
    "global-state-schema": {
      "num-byte-slice": 0,
      "num-uint": 0
    },
    "local-state-schema": {
      "num-byte-slice": 0,
      "num-uint": 0
    }
  },
  "round": 0
}

{
  "app-local-state": {
    "id": 0,
    "key-value": [
      {
        "key": "string",
        "value": {
          "bytes": "string",
          "type": 0,
          "uint": 0
        }
      }
    ],
    "schema": {
      "num-byte-slice": 0,
      "num-uint": 0
    }
  },
  "created-app": {
    "approval-program": "dGVzdA==",
    "clear-state-program": "dGVzdA==",
    "creator": "string",
    "extra-program-pages": 0,
    "global-state": [
      {
        "key": "string",
        "value": {
          "bytes": "string",
          "type": 0,
          "uint": 0
        }
      }
    ],
    "global-state-schema": {
      "num-byte-slice": 0,
      "num-uint": 0
    },
    "local-state-schema": {
      "num-byte-slice": 0,
      "num-uint": 0
    }
  },
  "round": 0
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

Get account information about a given asset.

GET

https://algo.nownodes.io/v2/accounts/{address}/assets/{asset-id}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Given a specific account public key and asset ID, this call returns the account's asset holding and asset parameters (if either exist). Asset parameters will only be returned if the provided address is the asset's creator.

Parameters

formatstringjsonmsgpackquery

Configures whether the response object is JSON or MessagePack encoded. If not provided, defaults to JSON.

addressstringrequiredpath

An account public key

asset-idintegerrequiredpath

An asset identifier

Response

200OK

AccountAssetResponse describes the account's asset holding and asset parameters (if either exist) for a specific asset ID. Asset parameters will only be returned if the provided address is the asset's creator.

400Bad Request

Malformed address or asset ID

401Unauthorized

Invalid API Token

500Internal Server Error

Internal Error

default

Unknown Error

Get account information about a given asset.

curl -X GET 'https://algo.nownodes.io/v2/accounts/{address}/assets/{asset-id}'

const response = await fetch('https://algo.nownodes.io/v2/accounts/{address}/assets/{asset-id}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v2/accounts/{address}/assets/{asset-id}')
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://algo.nownodes.io/v2/accounts/{address}/assets/{asset-id}')
data = response.json()

const response = await fetch('https://algo.nownodes.io/v2/accounts/{address}/assets/{asset-id}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://algo.nownodes.io/v2/accounts/{address}/assets/{asset-id}";
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://algo.nownodes.io/v2/accounts/{address}/assets/{asset-id}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://algo.nownodes.io/v2/accounts/{address}/assets/{asset-id}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v2/accounts/{address}/assets/{asset-id}')
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)

{
  "asset-holding": {
    "amount": 0,
    "asset-id": 0,
    "is-frozen": true
  },
  "created-asset": {
    "clawback": "string",
    "creator": "string",
    "decimals": 0,
    "default-frozen": true,
    "freeze": "string",
    "manager": "string",
    "metadata-hash": "dGVzdA==",
    "name": "string",
    "name-b64": "dGVzdA==",
    "reserve": "string",
    "total": 0,
    "unit-name": "string",
    "unit-name-b64": "dGVzdA==",
    "url": "string",
    "url-b64": "dGVzdA=="
  },
  "round": 0
}

{
  "asset-holding": {
    "amount": 0,
    "asset-id": 0,
    "is-frozen": true
  },
  "created-asset": {
    "clawback": "string",
    "creator": "string",
    "decimals": 0,
    "default-frozen": true,
    "freeze": "string",
    "manager": "string",
    "metadata-hash": "dGVzdA==",
    "name": "string",
    "name-b64": "dGVzdA==",
    "reserve": "string",
    "total": 0,
    "unit-name": "string",
    "unit-name-b64": "dGVzdA==",
    "url": "string",
    "url-b64": "dGVzdA=="
  },
  "round": 0
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

Get a list of unconfirmed transactions currently in the transaction pool by address.

GET

https://algo.nownodes.io/v2/accounts/{address}/transactions/pending

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Get the list of pending transactions by address, sorted by priority, in decreasing order, truncated at the end at MAX. If MAX = 0, returns all pending transactions.

Parameters

addressstringrequiredpath

An account public key

maxintegerquery

Truncated number of transactions to display. If max=0, returns all pending txns.

formatstringjsonmsgpackquery

Configures whether the response object is JSON or MessagePack encoded. If not provided, defaults to JSON.

Response

200OK

A potentially truncated list of transactions currently in the node's transaction pool. You can compute whether or not the list is truncated if the number of elements in the top-transactions array is fewer than total-transactions.

400Bad Request

Max must be a non-negative integer

401Unauthorized

Invalid API Token

500Internal Server Error

Internal Error

503Service Unavailable

Service Temporarily Unavailable

default

Unknown Error

Get a list of unconfirmed transactions currently in the transaction pool by address.

curl -X GET 'https://algo.nownodes.io/v2/accounts/{address}/transactions/pending'

const response = await fetch('https://algo.nownodes.io/v2/accounts/{address}/transactions/pending', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v2/accounts/{address}/transactions/pending')
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://algo.nownodes.io/v2/accounts/{address}/transactions/pending')
data = response.json()

const response = await fetch('https://algo.nownodes.io/v2/accounts/{address}/transactions/pending', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://algo.nownodes.io/v2/accounts/{address}/transactions/pending";
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://algo.nownodes.io/v2/accounts/{address}/transactions/pending', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://algo.nownodes.io/v2/accounts/{address}/transactions/pending')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v2/accounts/{address}/transactions/pending')
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)

{
  "top-transactions": [
    {}
  ],
  "total-transactions": 0
}

{
  "top-transactions": [
    {}
  ],
  "total-transactions": 0
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

Applications

Get application information.

GET

https://algo.nownodes.io/v2/applications/{application-id}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Given a application ID, it returns application information including creator, approval and clear programs, global and local schemas, and global state.

Parameters

application-idintegerrequiredpath

An application identifier

Response

200OK

Application information

400Bad Request

Bad Request

401Unauthorized

Invalid API Token

404Not Found

Application Not Found

500Internal Server Error

Internal Error

default

Unknown Error

Get application information.

curl -X GET 'https://algo.nownodes.io/v2/applications/{application-id}'

const response = await fetch('https://algo.nownodes.io/v2/applications/{application-id}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v2/applications/{application-id}')
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://algo.nownodes.io/v2/applications/{application-id}')
data = response.json()

const response = await fetch('https://algo.nownodes.io/v2/applications/{application-id}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://algo.nownodes.io/v2/applications/{application-id}";
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://algo.nownodes.io/v2/applications/{application-id}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://algo.nownodes.io/v2/applications/{application-id}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v2/applications/{application-id}')
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)

{
  "id": 0,
  "params": {
    "approval-program": "dGVzdA==",
    "clear-state-program": "dGVzdA==",
    "creator": "string",
    "extra-program-pages": 0,
    "global-state": [
      {
        "key": "string",
        "value": {
          "bytes": "string",
          "type": 0,
          "uint": 0
        }
      }
    ],
    "global-state-schema": {
      "num-byte-slice": 0,
      "num-uint": 0
    },
    "local-state-schema": {
      "num-byte-slice": 0,
      "num-uint": 0
    }
  }
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

Get box information for a given application.

GET

https://algo.nownodes.io/v2/applications/{application-id}/box

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Given an application ID and box name, it returns the round, box name, and value (each base64 encoded). Box names must be in the goal app call arg encoding form 'encoding:value'. For ints, use the form 'int:1234'. For raw bytes, use the form 'b64:A=='. For printable strings, use the form 'str:hello'. For addresses, use the form 'addr:XYZ...'.

Parameters

application-idintegerrequiredpath

An application identifier

namestringrequiredquery

A box name, in the goal app call arg form 'encoding:value'. For ints, use the form 'int:1234'. For raw bytes, use the form 'b64:A=='. For printable strings, use the form 'str:hello'. For addresses, use the form 'addr:XYZ...'.

Response

200OK

Box information

400Bad Request

Bad Request

401Unauthorized

Invalid API Token

404Not Found

Box Not Found

500Internal Server Error

Internal Error

default

Unknown Error

Get box information for a given application.

curl -X GET 'https://algo.nownodes.io/v2/applications/{application-id}/box'

const response = await fetch('https://algo.nownodes.io/v2/applications/{application-id}/box', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v2/applications/{application-id}/box')
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://algo.nownodes.io/v2/applications/{application-id}/box')
data = response.json()

const response = await fetch('https://algo.nownodes.io/v2/applications/{application-id}/box', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://algo.nownodes.io/v2/applications/{application-id}/box";
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://algo.nownodes.io/v2/applications/{application-id}/box', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://algo.nownodes.io/v2/applications/{application-id}/box')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v2/applications/{application-id}/box')
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)

{
  "name": "dGVzdA==",
  "round": 0,
  "value": "dGVzdA=="
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

Get all box names for a given application.

GET

https://algo.nownodes.io/v2/applications/{application-id}/boxes

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Given an application ID, return all Box names. No particular ordering is guaranteed. Request fails when client or server-side configured limits prevent returning all Box names.

Parameters

application-iintegerrequiredpath

An application identifierd

maxintegerquery

Max number of box names to return. If max is not set, or max == 0, returns all box-names.

Response

200OK

Box names of an application

400Bad Request

Bad Request

401Unauthorized

Invalid API Token

500Internal Server Error

Internal Error

default

Unknown Error

Get all box names for a given application.

curl -X GET 'https://algo.nownodes.io/v2/applications/{application-id}/boxes'

const response = await fetch('https://algo.nownodes.io/v2/applications/{application-id}/boxes', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v2/applications/{application-id}/boxes')
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://algo.nownodes.io/v2/applications/{application-id}/boxes')
data = response.json()

const response = await fetch('https://algo.nownodes.io/v2/applications/{application-id}/boxes', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://algo.nownodes.io/v2/applications/{application-id}/boxes";
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://algo.nownodes.io/v2/applications/{application-id}/boxes', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://algo.nownodes.io/v2/applications/{application-id}/boxes')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v2/applications/{application-id}/boxes')
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)

{
  "boxes": [
    {
      "name": "dGVzdA=="
    }
  ]
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

Assets

Get asset information.

GET

https://algo.nownodes.io/v2/assets/{asset-id}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Given a asset ID, it returns asset information including creator, name, total supply and special addresses.

Parameters

asset-idintegerrequiredpath

An asset identifier

Response

200OK

Asset information

400Bad Request

Bad Request

401Unauthorized

Invalid API Token

404Not Found

Application Not Found

500Internal Server Error

Internal Error

default

Unknown Error

Get asset information.

curl -X GET 'https://algo.nownodes.io/v2/assets/{asset-id}'

const response = await fetch('https://algo.nownodes.io/v2/assets/{asset-id}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v2/assets/{asset-id}')
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://algo.nownodes.io/v2/assets/{asset-id}')
data = response.json()

const response = await fetch('https://algo.nownodes.io/v2/assets/{asset-id}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://algo.nownodes.io/v2/assets/{asset-id}";
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://algo.nownodes.io/v2/assets/{asset-id}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://algo.nownodes.io/v2/assets/{asset-id}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v2/assets/{asset-id}')
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)

{
  "index": 0,
  "params": {
    "clawback": "string",
    "creator": "string",
    "decimals": 0,
    "default-frozen": true,
    "freeze": "string",
    "manager": "string",
    "metadata-hash": "dGVzdA==",
    "name": "string",
    "name-b64": "dGVzdA==",
    "reserve": "string",
    "total": 0,
    "unit-name": "string",
    "unit-name-b64": "dGVzdA==",
    "url": "string",
    "url-b64": "dGVzdA=="
  }
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

Blocks

Get the block for the given round.

GET

https://algo.nownodes.io/v2/blocks/{round}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

formatstringjsonmsgpackquery

Configures whether the response object is JSON or MessagePack encoded. If not provided, defaults to JSON.

roundinteger>= 0requiredpath

The round from which to fetch block information.

Response

200OK

Encoded block object.

400Bad Request

Bad Request - Non integer number

401Unauthorized

Invalid API Token

404Not Found

None existing block

500Internal Server Error

Internal Error

default

Unknown Error

Get the block for the given round.

curl -X GET 'https://algo.nownodes.io/v2/blocks/{round}'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://algo.nownodes.io/v2/blocks/{round}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v2/blocks/{round}')
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": {},
  "cert": {}
}

{
  "block": {},
  "cert": {}
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

Get the block hash for the block on the given round.

GET

https://algo.nownodes.io/v2/blocks/{round}/hash

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

roundinteger>= 0requiredpath

The round from which to fetch block hash information.

Response

200OK

Hash of a block header.

400Bad Request

Bad Request - Non integer number

401Unauthorized

Invalid API Token

404Not Found

None existing block

500Internal Server Error

Internal Error

default

Unknown Error

Get the block hash for the block on the given round.

curl -X GET 'https://algo.nownodes.io/v2/blocks/{round}/hash'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v2/blocks/{round}/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://algo.nownodes.io/v2/blocks/{round}/hash')
data = response.json()

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://algo.nownodes.io/v2/blocks/{round}/hash')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v2/blocks/{round}/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)

{
  "blockHash": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

Gets a proof for a given light block header inside a state proof commitment

GET

https://algo.nownodes.io/v2/blocks/{round}/lightheader/proof

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

roundinteger>= 0requiredpath

The round to which the light block header belongs.

Response

200OK

Proof of a light block header.

401Unauthorized

Invalid API Token

404Not Found

Could not create proof since some data is missing

408Request Timeout

timed out on request

500Internal Server Error

Internal Error

503Service Unavailable

Service Temporarily Unavailable

default

Unknown Error

Gets a proof for a given light block header inside a state proof commitment

curl -X GET 'https://algo.nownodes.io/v2/blocks/{round}/lightheader/proof'

const response = await fetch('https://algo.nownodes.io/v2/blocks/{round}/lightheader/proof', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v2/blocks/{round}/lightheader/proof')
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://algo.nownodes.io/v2/blocks/{round}/lightheader/proof')
data = response.json()

const response = await fetch('https://algo.nownodes.io/v2/blocks/{round}/lightheader/proof', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://algo.nownodes.io/v2/blocks/{round}/lightheader/proof";
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://algo.nownodes.io/v2/blocks/{round}/lightheader/proof', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://algo.nownodes.io/v2/blocks/{round}/lightheader/proof')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v2/blocks/{round}/lightheader/proof')
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)

{
  "index": 0,
  "proof": "dGVzdA==",
  "treedepth": 0
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

Get a proof for a transaction in a block.

GET

https://algo.nownodes.io/v2/blocks/{round}/transactions/{txid}/proof

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

roundintegerrequiredpath

The round in which the transaction appears.

txidstringrequiredpath

The transaction ID for which to generate a proof.

hashtypestringsha512_256sha256query

The type of hash function used to create the proof, must be one of:

sha512_256
sha256

formatstringjsonmsgpackquery

Configures whether the response object is JSON or MessagePack encoded. If not provided, defaults to JSON.

Response

200OK

Proof of transaction in a block.

400Bad Request

Malformed round number or transaction ID

401Unauthorized

Invalid API token

404Not Found

Non-existent block or transaction

500Internal Server Error

Internal error, including protocol not supporting proofs.

default

Unknown error

Get a proof for a transaction in a block.

curl -X GET 'https://algo.nownodes.io/v2/blocks/{round}/transactions/{txid}/proof'

const response = await fetch('https://algo.nownodes.io/v2/blocks/{round}/transactions/{txid}/proof', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v2/blocks/{round}/transactions/{txid}/proof')
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://algo.nownodes.io/v2/blocks/{round}/transactions/{txid}/proof')
data = response.json()

const response = await fetch('https://algo.nownodes.io/v2/blocks/{round}/transactions/{txid}/proof', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://algo.nownodes.io/v2/blocks/{round}/transactions/{txid}/proof";
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://algo.nownodes.io/v2/blocks/{round}/transactions/{txid}/proof', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://algo.nownodes.io/v2/blocks/{round}/transactions/{txid}/proof')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v2/blocks/{round}/transactions/{txid}/proof')
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)

{
  "hashtype": "sha512_256",
  "idx": 0,
  "proof": "dGVzdA==",
  "stibhash": "dGVzdA==",
  "treedepth": 0
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

Get the top level transaction IDs for the block on the given round.

GET

https://algo.nownodes.io/v2/blocks/{round}/txids

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

roundinteger>= 0requiredpath

The round from which to fetch block transaction IDs.

Response

200OK

Top level transaction IDs in a block.

400Bad Request

Bad Request - Non integer number

401Unauthorized

Invalid API Token

404Not Found

Non existing block

500Internal Server Error

Internal Error

default

Unknown Error

Get the top level transaction IDs for the block on the given round.

curl -X GET 'https://algo.nownodes.io/v2/blocks/{round}/txids'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v2/blocks/{round}/txids')
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://algo.nownodes.io/v2/blocks/{round}/txids')
data = response.json()

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://algo.nownodes.io/v2/blocks/{round}/txids')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v2/blocks/{round}/txids')
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)

{
  "blockTxids": [
    "string"
  ]
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

Starts a catchpoint catchup.

POST

https://algo.nownodes.io/v2/blocks/{round}/txids

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Given a catchpoint, it starts catching up to this catchpoint

Parameters

catchpointstring<catchpoint>requiredpath

A catch point

minintegerquery

Specify the minimum number of blocks which the ledger must be advanced by in order to start the catchup. This is useful for simplifying tools which support fast catchup, they can run the catchup unconditionally and the node will skip the catchup if it is not needed.

Response

200OK

An catchpoint start response.

201Created

An catchpoint start response.

400Bad Request

Bad Request

401Unauthorized

Invalid API Token

408Request Timeout

Request Timeout

500Internal Server Error

Internal Error

default

Unknown Error

Starts a catchpoint catchup.

curl -X POST 'https://algo.nownodes.io/v2/blocks/{round}/txids'

const response = await fetch('https://algo.nownodes.io/v2/blocks/{round}/txids', {
  method: 'POST',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v2/blocks/{round}/txids')
request = Net::HTTP::Post.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.post('https://algo.nownodes.io/v2/blocks/{round}/txids')
data = response.json()

const response = await fetch('https://algo.nownodes.io/v2/blocks/{round}/txids', {
  method: 'POST',
});

const data = await response.json();

const endpoint = "https://algo.nownodes.io/v2/blocks/{round}/txids";
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({});
console.log(result);

const response = await fetch('https://algo.nownodes.io/v2/blocks/{round}/txids', {
  method: 'POST',
});

const data = await response.json();

import requests

response = requests.post('https://algo.nownodes.io/v2/blocks/{round}/txids')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v2/blocks/{round}/txids')
request = Net::HTTP::Post.new(uri)

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

{
  "catchup-message": "string"
}

{
  "catchup-message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

Deltas

Get a LedgerStateDelta object for a given transaction group

GET

https://algo.nownodes.io/v2/deltas/txn/group/{id}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Get a ledger delta for a given transaction group.

Parameters

idstringrequiredpath

A transaction ID, or transaction group ID

formatstringjsonmsgpackquery

Configures whether the response object is JSON or MessagePack encoded. If not provided, defaults to JSON.

Response

200OK

Response containing a ledger state delta for a single transaction group.

401Unauthorized

Invalid API Token

404Not Found

Could not find a delta for transaction ID or group ID

408Request Timeout

timed out on request

500Internal Server Error

Internal Error

501Not Implemented

Not Implemented

default

Unknown Error

Get a LedgerStateDelta object for a given transaction group

curl -X GET 'https://algo.nownodes.io/v2/deltas/txn/group/{id}'

const response = await fetch('https://algo.nownodes.io/v2/deltas/txn/group/{id}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v2/deltas/txn/group/{id}')
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://algo.nownodes.io/v2/deltas/txn/group/{id}')
data = response.json()

const response = await fetch('https://algo.nownodes.io/v2/deltas/txn/group/{id}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://algo.nownodes.io/v2/deltas/txn/group/{id}";
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://algo.nownodes.io/v2/deltas/txn/group/{id}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://algo.nownodes.io/v2/deltas/txn/group/{id}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v2/deltas/txn/group/{id}')
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)

{}

{}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

Get a LedgerStateDelta object for a given round

GET

https://algo.nownodes.io/v2/deltas/{round}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Get ledger deltas for a round.

Parameters

roundinteger>= 0requiredpath

The round for which the deltas are desired.

formatstringjsonmsgpackquery

Configures whether the response object is JSON or MessagePack encoded. If not provided, defaults to JSON.

Response

200OK

Contains ledger deltas

401Unauthorized

Invalid API Token

404Not Found

Could not find a delta for round

408Request Timeout

timed out on request

500Internal Server Error

Internal Error

503Service Unavailable

Service Temporarily Unavailable

default

Unknown Error

Get a LedgerStateDelta object for a given round

curl -X GET 'https://algo.nownodes.io/v2/deltas/{round}'

const response = await fetch('https://algo.nownodes.io/v2/deltas/{round}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v2/deltas/{round}')
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://algo.nownodes.io/v2/deltas/{round}')
data = response.json()

const response = await fetch('https://algo.nownodes.io/v2/deltas/{round}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://algo.nownodes.io/v2/deltas/{round}";
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://algo.nownodes.io/v2/deltas/{round}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://algo.nownodes.io/v2/deltas/{round}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v2/deltas/{round}')
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)

{}

{}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

Get LedgerStateDelta objects for all transaction groups in a given round

GET

https://algo.nownodes.io/v2/deltas/{round}/txn/group

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Get ledger deltas for transaction groups in a given round.

Parameters

roundinteger>= 0requiredpath

The round for which the deltas are desired.

formatstringjsonmsgpackquery

Configures whether the response object is JSON or MessagePack encoded. If not provided, defaults to JSON.

Response

200OK

Response containing all ledger state deltas for transaction groups, with their associated Ids, in a single round.

401Unauthorized

Invalid API Token

404Not Found

Could not find deltas for round

408Request Timeout

timed out on request

500Internal Server Error

Internal Error

501Not Implemented

Not Implemented

default

Unknown Error

Get LedgerStateDelta objects for all transaction groups in a given round

curl -X GET 'https://algo.nownodes.io/v2/deltas/{round}/txn/group'

const response = await fetch('https://algo.nownodes.io/v2/deltas/{round}/txn/group', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v2/deltas/{round}/txn/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://algo.nownodes.io/v2/deltas/{round}/txn/group')
data = response.json()

const response = await fetch('https://algo.nownodes.io/v2/deltas/{round}/txn/group', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://algo.nownodes.io/v2/deltas/{round}/txn/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://algo.nownodes.io/v2/deltas/{round}/txn/group', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://algo.nownodes.io/v2/deltas/{round}/txn/group')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v2/deltas/{round}/txn/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)

{
  "Deltas": [
    {
      "Delta": {},
      "Ids": [
        "string"
      ]
    }
  ]
}

{
  "Deltas": [
    {
      "Delta": {},
      "Ids": [
        "string"
      ]
    }
  ]
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

Devmode

Returns the timestamp offset. Timestamp offsets can only be set in dev mode.

GET

https://algo.nownodes.io/v2/devmode/blocks/offset

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Gets the current timestamp offset.

Response

200OK

Response containing the timestamp offset in seconds

400Bad Request

TimeStamp offset not set.

default

Unknown Error

Returns the timestamp offset. Timestamp offsets can only be set in dev mode.

curl -X GET 'https://algo.nownodes.io/v2/devmode/blocks/offset'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://algo.nownodes.io/v2/devmode/blocks/offset')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v2/devmode/blocks/offset')
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)

{
  "offset": 0
}

{
  "data": {},
  "message": "string"
}

Given a timestamp offset in seconds, adds the offset to every subsequent block header's timestamp.

POST

https://algo.nownodes.io/v2/devmode/blocks/offset/{offset}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Sets the timestamp offset (seconds) for blocks in dev mode. Providing an offset of 0 will unset this value and try to use the real clock for the timestamp.

Parameters

offsetinteger>= 0requiredpath

The timestamp offset for blocks in dev mode.

Response

200OK

400Bad Request

Cannot set timestamp offset to a negative integer.

401Unauthorized

Invalid API Token

500Internal Server Error

Internal Error

default

Unknown Error

Given a timestamp offset in seconds, adds the offset to every subsequent block header's timestamp.

curl -X POST 'https://algo.nownodes.io/v2/devmode/blocks/offset/{offset}'

const response = await fetch('https://algo.nownodes.io/v2/devmode/blocks/offset/{offset}', {
  method: 'POST',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v2/devmode/blocks/offset/{offset}')
request = Net::HTTP::Post.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.post('https://algo.nownodes.io/v2/devmode/blocks/offset/{offset}')
data = response.json()

const response = await fetch('https://algo.nownodes.io/v2/devmode/blocks/offset/{offset}', {
  method: 'POST',
});

const data = await response.json();

const endpoint = "https://algo.nownodes.io/v2/devmode/blocks/offset/{offset}";
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({});
console.log(result);

const response = await fetch('https://algo.nownodes.io/v2/devmode/blocks/offset/{offset}', {
  method: 'POST',
});

const data = await response.json();

import requests

response = requests.post('https://algo.nownodes.io/v2/devmode/blocks/offset/{offset}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v2/devmode/blocks/offset/{offset}')
request = Net::HTTP::Post.new(uri)

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

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

Experimental

Returns OK if experimental API is enabled.

GET

https://algo.nownodes.io/v2/experimental

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Response

200OK

Experimental API enabled

404Not Found

Experimental API not enabled

default

Unknown Error

Returns OK if experimental API is enabled.

curl -X GET 'https://algo.nownodes.io/v2/experimental'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v2/experimental')
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://algo.nownodes.io/v2/experimental')
data = response.json()

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://algo.nownodes.io/v2/experimental')
data = response.json()

require 'net/http'
require 'json'

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

Ledger

Get the current supply reported by the ledger.

GET

https://algo.nownodes.io/v2/ledger/supply

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Response

200OK

Supply represents the current supply of MicroAlgos in the system.

401Unauthorized

Invalid API Token

default

Unknown Error

Get the current supply reported by the ledger.

curl -X GET 'https://algo.nownodes.io/v2/ledger/supply'

const response = await fetch('https://algo.nownodes.io/v2/ledger/supply', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v2/ledger/supply')
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://algo.nownodes.io/v2/ledger/supply')
data = response.json()

const response = await fetch('https://algo.nownodes.io/v2/ledger/supply', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://algo.nownodes.io/v2/ledger/supply";
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://algo.nownodes.io/v2/ledger/supply', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://algo.nownodes.io/v2/ledger/supply')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v2/ledger/supply')
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)

{
  "current_round": 0,
  "online-money": 0,
  "total-money": 0
}

{
  "data": {},
  "message": "string"
}

Returns the minimum sync round the ledger is keeping in cache.

GET

https://algo.nownodes.io/v2/ledger/sync

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Gets the minimum sync round for the ledger.

Response

200OK

Response containing the ledger's minimum sync round

400Bad Request

Sync round not set.

401Unauthorized

Invalid API Token

500Internal Server Error

Internal Error

503Service Unavailable

Service Temporarily Unavailable

default

Unknown Error

Returns the minimum sync round the ledger is keeping in cache.

curl -X GET 'https://algo.nownodes.io/v2/ledger/sync'

const response = await fetch('https://algo.nownodes.io/v2/ledger/sync', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v2/ledger/sync')
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://algo.nownodes.io/v2/ledger/sync')
data = response.json()

const response = await fetch('https://algo.nownodes.io/v2/ledger/sync', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://algo.nownodes.io/v2/ledger/sync";
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://algo.nownodes.io/v2/ledger/sync', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://algo.nownodes.io/v2/ledger/sync')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v2/ledger/sync')
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)

{
  "round": 0
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

Given a round, tells the ledger to keep that round in its cache.

POST

https://algo.nownodes.io/v2/ledger/sync/{round}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Sets the minimum sync round on the ledger.

Parameters

roundinteger>= 0requiredpath

The round for which the deltas are desired.

Response

200OK

Valid response

400Bad Request

Can not set sync round to an earlier round than the current round.

401Unauthorized

Invalid API Token

500Internal Server Error

Internal Error

503Service Unavailable

Service Temporarily Unavailable

default

Unknown Error

Given a round, tells the ledger to keep that round in its cache.

curl -X POST 'https://algo.nownodes.io/v2/ledger/sync/{round}'

const response = await fetch('https://algo.nownodes.io/v2/ledger/sync/{round}', {
  method: 'POST',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v2/ledger/sync/{round}')
request = Net::HTTP::Post.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.post('https://algo.nownodes.io/v2/ledger/sync/{round}')
data = response.json()

const response = await fetch('https://algo.nownodes.io/v2/ledger/sync/{round}', {
  method: 'POST',
});

const data = await response.json();

const endpoint = "https://algo.nownodes.io/v2/ledger/sync/{round}";
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({});
console.log(result);

const response = await fetch('https://algo.nownodes.io/v2/ledger/sync/{round}', {
  method: 'POST',
});

const data = await response.json();

import requests

response = requests.post('https://algo.nownodes.io/v2/ledger/sync/{round}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v2/ledger/sync/{round}')
request = Net::HTTP::Post.new(uri)

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

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

Participation

Return a list of participation keys

GET

https://algo.nownodes.io/v2/participation

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Return a list of participation keys

Response

200OK

A list of participation keys

400Bad Request

Bad Request

401Unauthorized

Invalid API Token

404Not Found

Participation Key Not Found

500Internal Server Error

Internal Error

default

Unknown Error

Return a list of participation keys

curl -X GET 'https://algo.nownodes.io/v2/participation'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v2/participation')
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://algo.nownodes.io/v2/participation')
data = response.json()

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://algo.nownodes.io/v2/participation')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v2/participation')
request = Net::HTTP::Get.new(uri)

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

[
  {
    "address": "string",
    "effective-first-valid": 0,
    "effective-last-valid": 0,
    "id": "string",
    "key": {
      "selection-participation-key": "dGVzdA==",
      "state-proof-key": "dGVzdA==",
      "vote-first-valid": 0,
      "vote-key-dilution": 0,
      "vote-last-valid": 0,
      "vote-participation-key": "dGVzdA=="
    },
    "last-block-proposal": 0,
    "last-state-proof": 0,
    "last-vote": 0
  }
]

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

Add a participation key to the node

POST

https://algo.nownodes.io/v2/participation

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Body

application/msgpack

The participation key to add to the node

string<binary>

Response

200OK

Participation ID of the submission

400Bad Request

Bad Request

401Unauthorized

Invalid API Token

404Not Found

Participation Key Not Found

500Internal Server Error

Internal Error

503Service Unavailable

Service Temporarily Unavailable

default

Unknown Error

Add a participation key to the node

curl -X POST 'https://algo.nownodes.io/v2/participation' \
  -H 'Content-Type: application/msgpack' \
  -d '"<binary>"'

const response = await fetch('https://algo.nownodes.io/v2/participation', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/msgpack',
  },
  body: JSON.stringify("<binary>"),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v2/participation')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/msgpack'
request.body = '"<binary>"'

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

import requests

payload = "<binary>"

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

const response = await fetch('https://algo.nownodes.io/v2/participation', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/msgpack',
  },
  body: JSON.stringify("<binary>"),
});

const data = await response.json();

const endpoint = "https://algo.nownodes.io/v2/participation";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest("<binary>");
console.log(result);

const response = await fetch('https://algo.nownodes.io/v2/participation', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/msgpack',
  },
  body: JSON.stringify("<binary>"),
});

const data = await response.json();

import requests

payload = "<binary>"

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

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v2/participation')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/msgpack'
request.body = '"<binary>"'

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

Request Body

"<binary>"

{
  "partId": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

Generate and install participation keys to the node.

POST

https://algo.nownodes.io/v2/participation/generate/{address}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

addressstringrequiredpath

An account public key

dilutionintegerquery

Key dilution for two-level participation keys (defaults to sqrt of validity window).

firstintegerrequiredquery

First round for participation key.

lastintegerrequiredquery

Last round for participation key.

Response

200OK

An empty JSON object is returned if the generation process was started. Currently no status is available.

400Bad Request

Bad Request

401Unauthorized

Invalid API Token

500Internal Server Error

Internal Error

503Service Unavailable

Service Temporarily Unavailable

default

Unknown Error

Generate and install participation keys to the node.

curl -X POST 'https://algo.nownodes.io/v2/participation/generate/{address}'

const response = await fetch('https://algo.nownodes.io/v2/participation/generate/{address}', {
  method: 'POST',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v2/participation/generate/{address}')
request = Net::HTTP::Post.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.post('https://algo.nownodes.io/v2/participation/generate/{address}')
data = response.json()

const response = await fetch('https://algo.nownodes.io/v2/participation/generate/{address}', {
  method: 'POST',
});

const data = await response.json();

const endpoint = "https://algo.nownodes.io/v2/participation/generate/{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({});
console.log(result);

const response = await fetch('https://algo.nownodes.io/v2/participation/generate/{address}', {
  method: 'POST',
});

const data = await response.json();

import requests

response = requests.post('https://algo.nownodes.io/v2/participation/generate/{address}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v2/participation/generate/{address}')
request = Net::HTTP::Post.new(uri)

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

"string"

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

Get participation key info given a participation ID

GET

https://algo.nownodes.io/v2/participation/{participation-id}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Given a participation ID, return information about that participation key

Parameters

participation-idstringrequiredpath

Response

200OK

A detailed description of a participation ID

400Bad Request

Bad Request

401Unauthorized

Invalid API Token

404Not Found

Participation Key Not Found

500Internal Server Error

Internal Error

default

Unknown Error

Get participation key info given a participation ID

curl -X GET 'https://algo.nownodes.io/v2/participation/{participation-id}'

const response = await fetch('https://algo.nownodes.io/v2/participation/{participation-id}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v2/participation/{participation-id}')
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://algo.nownodes.io/v2/participation/{participation-id}')
data = response.json()

const response = await fetch('https://algo.nownodes.io/v2/participation/{participation-id}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://algo.nownodes.io/v2/participation/{participation-id}";
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://algo.nownodes.io/v2/participation/{participation-id}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://algo.nownodes.io/v2/participation/{participation-id}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v2/participation/{participation-id}')
request = Net::HTTP::Get.new(uri)

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

{
  "address": "string",
  "effective-first-valid": 0,
  "effective-last-valid": 0,
  "id": "string",
  "key": {
    "selection-participation-key": "dGVzdA==",
    "state-proof-key": "dGVzdA==",
    "vote-first-valid": 0,
    "vote-key-dilution": 0,
    "vote-last-valid": 0,
    "vote-participation-key": "dGVzdA=="
  },
  "last-block-proposal": 0,
  "last-state-proof": 0,
  "last-vote": 0
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

Append state proof keys to a participation key

POST

https://algo.nownodes.io/v2/participation/{participation-id}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Given a participation ID, append state proof keys to a particular set of participation keys

Body

application/msgpack

The state proof keys to add to an existing participation ID

string<binary>

Parameters

participation-idstringrequiredpath

Response

200OK

A detailed description of a participation ID

400Bad Request

Bad Request

401Unauthorized

Invalid API Token

404Not Found

Participation Key Not Found

500Internal Server Error

Internal Error

default

Unknown Error

Append state proof keys to a participation key

curl -X POST 'https://algo.nownodes.io/v2/participation/{participation-id}' \
  -H 'Content-Type: application/msgpack' \
  -d '"<binary>"'

const response = await fetch('https://algo.nownodes.io/v2/participation/{participation-id}', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/msgpack',
  },
  body: JSON.stringify("<binary>"),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v2/participation/{participation-id}')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/msgpack'
request.body = '"<binary>"'

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

import requests

payload = "<binary>"

response = requests.post('https://algo.nownodes.io/v2/participation/{participation-id}', json=payload)
data = response.json()

const response = await fetch('https://algo.nownodes.io/v2/participation/{participation-id}', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/msgpack',
  },
  body: JSON.stringify("<binary>"),
});

const data = await response.json();

const endpoint = "https://algo.nownodes.io/v2/participation/{participation-id}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest("<binary>");
console.log(result);

const response = await fetch('https://algo.nownodes.io/v2/participation/{participation-id}', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/msgpack',
  },
  body: JSON.stringify("<binary>"),
});

const data = await response.json();

import requests

payload = "<binary>"

response = requests.post('https://algo.nownodes.io/v2/participation/{participation-id}', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v2/participation/{participation-id}')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/msgpack'
request.body = '"<binary>"'

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

Request Body

"<binary>"

{
  "address": "string",
  "effective-first-valid": 0,
  "effective-last-valid": 0,
  "id": "string",
  "key": {
    "selection-participation-key": "dGVzdA==",
    "state-proof-key": "dGVzdA==",
    "vote-first-valid": 0,
    "vote-key-dilution": 0,
    "vote-last-valid": 0,
    "vote-participation-key": "dGVzdA=="
  },
  "last-block-proposal": 0,
  "last-state-proof": 0,
  "last-vote": 0
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

Shutdown

POST

https://algo.nownodes.io/v2/shutdown

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Special management endpoint to shutdown the node. Optionally provide a timeout parameter to indicate that the node should begin shutting down after a number of seconds.

Parameters

timeoutinteger0query

Response

200OK

Valid response

POST /v2/shutdown

curl -X POST 'https://algo.nownodes.io/v2/shutdown'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v2/shutdown')
request = Net::HTTP::Post.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.post('https://algo.nownodes.io/v2/shutdown')
data = response.json()

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

const data = await response.json();

const endpoint = "https://algo.nownodes.io/v2/shutdown";
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({});
console.log(result);

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

const data = await response.json();

import requests

response = requests.post('https://algo.nownodes.io/v2/shutdown')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v2/shutdown')
request = Net::HTTP::Post.new(uri)

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

200

{}

Stateproofs

Get a state proof that covers a given round

GET

https://algo.nownodes.io/v2/stateproofs/{round}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Parameters

roundinteger>= 0requiredpath

The round for which a state proof is desired.

Response

200OK

StateProofResponse wraps the StateProof type in a response.

401Unauthorized

Invalid API Token

404Not Found

Could not find a state proof that covers a given round

408Request Timeout

timed out on request

500Internal Server Error

Internal Error

503Service Unavailable

Service Temporarily Unavailable

default

Unknown Error

Get a state proof that covers a given round

curl -X GET 'https://algo.nownodes.io/v2/stateproofs/{round}'

const response = await fetch('https://algo.nownodes.io/v2/stateproofs/{round}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v2/stateproofs/{round}')
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://algo.nownodes.io/v2/stateproofs/{round}')
data = response.json()

const response = await fetch('https://algo.nownodes.io/v2/stateproofs/{round}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://algo.nownodes.io/v2/stateproofs/{round}";
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://algo.nownodes.io/v2/stateproofs/{round}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://algo.nownodes.io/v2/stateproofs/{round}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v2/stateproofs/{round}')
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)

{
  "Message": {
    "BlockHeadersCommitment": "dGVzdA==",
    "FirstAttestedRound": 0,
    "LastAttestedRound": 0,
    "LnProvenWeight": 0,
    "VotersCommitment": "dGVzdA=="
  },
  "StateProof": "dGVzdA=="
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

Status

Gets the current node status.

GET

https://algo.nownodes.io/v2/status

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Response

200OK

Valid response

401Unauthorized

Invalid API Token

500Internal Server Error

Internal Error

default

Unknown Error

Gets the current node status.

curl -X GET 'https://algo.nownodes.io/v2/status'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

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

{
  "catchpoint": "string",
  "catchpoint-acquired-blocks": 0,
  "catchpoint-processed-accounts": 0,
  "catchpoint-processed-kvs": 0,
  "catchpoint-total-accounts": 0,
  "catchpoint-total-blocks": 0,
  "catchpoint-total-kvs": 0,
  "catchpoint-verified-accounts": 0,
  "catchpoint-verified-kvs": 0,
  "catchup-time": 0,
  "last-catchpoint": "string",
  "last-round": 0,
  "last-version": "string",
  "next-version": "string",
  "next-version-round": 0,
  "next-version-supported": true,
  "stopped-at-unsupported-round": true,
  "time-since-last-round": 0,
  "upgrade-delay": 0,
  "upgrade-next-protocol-vote-before": 0,
  "upgrade-no-votes": 0,
  "upgrade-node-vote": true,
  "upgrade-vote-rounds": 0,
  "upgrade-votes": 0,
  "upgrade-votes-required": 0,
  "upgrade-yes-votes": 0
}

{
  "data": {},
  "message": "string"
}

"string"

Gets the node status after waiting for a round after the given round.

GET

https://algo.nownodes.io/v2/status/wait-for-block-after/{round}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Waits for a block to appear after round {round} and returns the node's status at the time. There is a 1 minute timeout, when reached the current status is returned regardless of whether or not it is the round after the given round.

Parameters

roundinteger>= 0requiredpath

The round to wait until returning status

Response

200OK

Valid response

400Bad Request

Bad Request -- number must be non-negative integer

401Unauthorized

Invalid API Token

500Internal Server Error

Internal Error

503Service Unavailable

Service Temporarily Unavailable

default

Unknown Error

Gets the node status after waiting for a round after the given round.

curl -X GET 'https://algo.nownodes.io/v2/status/wait-for-block-after/{round}'

const response = await fetch('https://algo.nownodes.io/v2/status/wait-for-block-after/{round}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v2/status/wait-for-block-after/{round}')
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://algo.nownodes.io/v2/status/wait-for-block-after/{round}')
data = response.json()

const response = await fetch('https://algo.nownodes.io/v2/status/wait-for-block-after/{round}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://algo.nownodes.io/v2/status/wait-for-block-after/{round}";
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://algo.nownodes.io/v2/status/wait-for-block-after/{round}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://algo.nownodes.io/v2/status/wait-for-block-after/{round}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v2/status/wait-for-block-after/{round}')
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)

{
  "catchpoint": "string",
  "catchpoint-acquired-blocks": 0,
  "catchpoint-processed-accounts": 0,
  "catchpoint-processed-kvs": 0,
  "catchpoint-total-accounts": 0,
  "catchpoint-total-blocks": 0,
  "catchpoint-total-kvs": 0,
  "catchpoint-verified-accounts": 0,
  "catchpoint-verified-kvs": 0,
  "catchup-time": 0,
  "last-catchpoint": "string",
  "last-round": 0,
  "last-version": "string",
  "next-version": "string",
  "next-version-round": 0,
  "next-version-supported": true,
  "stopped-at-unsupported-round": true,
  "time-since-last-round": 0,
  "upgrade-delay": 0,
  "upgrade-next-protocol-vote-before": 0,
  "upgrade-no-votes": 0,
  "upgrade-node-vote": true,
  "upgrade-vote-rounds": 0,
  "upgrade-votes": 0,
  "upgrade-votes-required": 0,
  "upgrade-yes-votes": 0
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

Teal

Compile TEAL source code to binary, produce its hash

POST

https://algo.nownodes.io/v2/teal/compile

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Given TEAL source code in plain text, return base64 encoded program bytes and base32 SHA512_256 hash of program bytes (Address style). This endpoint is only enabled when a node's configuration file sets EnableDeveloperAPI to true.

Body

text/plain

TEAL source code to be compiled

string<binary>

Parameters

sourcemapbooleanquery

When set to true, returns the source map of the program as a JSON. Defaults to false.

Response

200OK

Teal compile Result

400Bad Request

Bad Request - Teal Compile Error

401Unauthorized

Invalid API Token

404Not Found

Developer API not enabled

500Internal Server Error

Internal Error

default

Unknown Error

Compile TEAL source code to binary, produce its hash

curl -X POST 'https://algo.nownodes.io/v2/teal/compile' \
  -H 'Content-Type: text/plain' \
  -d '"<binary>"'

const response = await fetch('https://algo.nownodes.io/v2/teal/compile', {
  method: 'POST',
  headers: {
    'Content-Type': 'text/plain',
  },
  body: JSON.stringify("<binary>"),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v2/teal/compile')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'text/plain'
request.body = '"<binary>"'

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

import requests

payload = "<binary>"

response = requests.post('https://algo.nownodes.io/v2/teal/compile', json=payload)
data = response.json()

const response = await fetch('https://algo.nownodes.io/v2/teal/compile', {
  method: 'POST',
  headers: {
    'Content-Type': 'text/plain',
  },
  body: JSON.stringify("<binary>"),
});

const data = await response.json();

const endpoint = "https://algo.nownodes.io/v2/teal/compile";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest("<binary>");
console.log(result);

const response = await fetch('https://algo.nownodes.io/v2/teal/compile', {
  method: 'POST',
  headers: {
    'Content-Type': 'text/plain',
  },
  body: JSON.stringify("<binary>"),
});

const data = await response.json();

import requests

payload = "<binary>"

response = requests.post('https://algo.nownodes.io/v2/teal/compile', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v2/teal/compile')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'text/plain'
request.body = '"<binary>"'

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

Request Body

<binary>

{
  "hash": "string",
  "result": "string",
  "sourcemap": {}
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

Disassemble program bytes into the TEAL source code.

POST

https://algo.nownodes.io/v2/teal/disassemble

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Given the program bytes, return the TEAL source code in plain text. This endpoint is only enabled when a node's configuration file sets EnableDeveloperAPI to true.

Body

application/x-binary

TEAL program binary to be disassembled

string<byte>

Response

200OK

Teal disassembly Result

400Bad Request

Bad Request - Teal Compile Error

401Unauthorized

Invalid API Token

404Not Found

Developer API not enabled

500Internal Server Error

Internal Error

default

Unknown Error

Disassemble program bytes into the TEAL source code.

curl -X POST 'https://algo.nownodes.io/v2/teal/disassemble' \
  -H 'Content-Type: application/x-binary' \
  -d '"dGVzdA=="'

const response = await fetch('https://algo.nownodes.io/v2/teal/disassemble', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/x-binary',
  },
  body: JSON.stringify("dGVzdA=="),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v2/teal/disassemble')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/x-binary'
request.body = '"dGVzdA=="'

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

import requests

payload = "dGVzdA=="

response = requests.post('https://algo.nownodes.io/v2/teal/disassemble', json=payload)
data = response.json()

const response = await fetch('https://algo.nownodes.io/v2/teal/disassemble', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/x-binary',
  },
  body: JSON.stringify("dGVzdA=="),
});

const data = await response.json();

const endpoint = "https://algo.nownodes.io/v2/teal/disassemble";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest("dGVzdA==");
console.log(result);

const response = await fetch('https://algo.nownodes.io/v2/teal/disassemble', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/x-binary',
  },
  body: JSON.stringify("dGVzdA=="),
});

const data = await response.json();

import requests

payload = "dGVzdA=="

response = requests.post('https://algo.nownodes.io/v2/teal/disassemble', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v2/teal/disassemble')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/x-binary'
request.body = '"dGVzdA=="'

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

Request Body

"dGVzdA=="

{
  "result": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

Provide debugging information for a transaction (or group).

POST

https://algo.nownodes.io/v2/teal/dryrun

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Executes TEAL program(s) in context and returns debugging information about the execution. This endpoint is only enabled when a node's configuration file sets EnableDeveloperAPI to true.

Body

application/json

Transaction (or group) and any accompanying state-simulation data.

application/jsonDryrunRequest

Request data type for dryrun endpoint. Given the Transactions and simulated ledger state upload, run TEAL scripts and return debugging information.

accountsArray<Account>required

Show child attributes

addressstringrequired

the account public key

amountintegerrequired

[algo] total number of MicroAlgos in the account

amount-without-pending-rewardsintegerrequired

specifies the amount of MicroAlgos in the account, without the pending rewards.

apps-local-stateArray<ApplicationLocalState>

[appl] applications local data stored in this account.

Note the raw object uses map[int] -> AppLocalState for this type.

Show child attributes

idintegerrequired

The application which this local state is for.

key-valueArray<TealKeyValue>

Represents a key-value store for use in an application.

Show child attributes

keystringrequired

valueTealValuerequired

Represents a TEAL value.

Show child attributes

bytesstringrequired

[tb] bytes value.

typeintegerrequired

[tt] value type. Value 1 refers to bytes, value 2 refers to uint

uintintegerrequired

[ui] uint value.

schemaApplicationStateSchemarequired

Specifies maximums on the number of each type that may be stored.

Show child attributes

num-byte-sliceintegerrequired

[nbs] num of byte slices.

num-uintintegerrequired

[nui] num of uints.

apps-total-extra-pagesinteger

[teap] the sum of all extra application program pages for this account.

apps-total-schemaApplicationStateSchema

Specifies maximums on the number of each type that may be stored.

Show child attributes

num-byte-sliceintegerrequired

[nbs] num of byte slices.

num-uintintegerrequired

[nui] num of uints.

assetsArray<AssetHolding>

[asset] assets held by this account.

Note the raw object uses map[int] -> AssetHolding for this type.

Show child attributes

amountintegerrequired

[a] number of units held.

asset-idintegerrequired

Asset ID of the holding.

is-frozenbooleanrequired

[f] whether or not the holding is frozen.

auth-addrstring

[spend] the address against which signing should be checked. If empty, the address of the current account is used. This field can be updated in any transaction by setting the RekeyTo field.

created-appsArray<Application>

[appp] parameters of applications created by this account including app global data.

Note: the raw account uses map[int] -> AppParams for this type.

Show child attributes

idintegerrequired

[appidx] application index.

paramsApplicationParamsrequired

Stores the global information associated with an application.

Show child attributes

approval-programstring<byte>required

[approv] approval program.

clear-state-programstring<byte>required

[clearp] approval program.

creatorstringrequired

The address that created this application. This is the address where the parameters and global state for this application can be found.

extra-program-pagesinteger

[epp] the amount of extra program pages available to this app.

global-stateArray<TealKeyValue>

Represents a key-value store for use in an application.

Show child attributes

keystringrequired

valueTealValuerequired

Represents a TEAL value.

Show child attributes

bytesstringrequired

[tb] bytes value.

typeintegerrequired

[tt] value type. Value 1 refers to bytes, value 2 refers to uint

uintintegerrequired

[ui] uint value.

global-state-schemaApplicationStateSchema

Specifies maximums on the number of each type that may be stored.

Show child attributes

num-byte-sliceintegerrequired

[nbs] num of byte slices.

num-uintintegerrequired

[nui] num of uints.

local-state-schemaApplicationStateSchema

Specifies maximums on the number of each type that may be stored.

Show child attributes

num-byte-sliceintegerrequired

[nbs] num of byte slices.

num-uintintegerrequired

[nui] num of uints.

created-assetsArray<Asset>

[apar] parameters of assets created by this account.

Note: the raw account uses map[int] -> Asset for this type.

Show child attributes

indexintegerrequired

unique asset identifier

paramsAssetParamsrequired

AssetParams specifies the parameters for an asset.

[apar] when part of an AssetConfig transaction.

Definition: data/transactions/asset.go : AssetParams

Show child attributes

clawbackstring

[c] Address of account used to clawback holdings of this asset. If empty, clawback is not permitted.

creatorstringrequired

The address that created this asset. This is the address where the parameters for this asset can be found, and also the address where unwanted asset units can be sent in the worst case.

decimalsinteger[0, 19]required

[dc] The number of digits to use after the decimal point when displaying this asset. If 0, the asset is not divisible. If 1, the base unit of the asset is in tenths. If 2, the base unit of the asset is in hundredths, and so on. This value must be between 0 and 19 (inclusive).

default-frozenboolean

[df] Whether holdings of this asset are frozen by default.

freezestring

[f] Address of account used to freeze holdings of this asset. If empty, freezing is not permitted.

managerstring

[m] Address of account used to manage the keys of this asset and to destroy it.

metadata-hashstring<byte>

[am] A commitment to some unspecified asset metadata. The format of this metadata is up to the application.

namestring

[an] Name of this asset, as supplied by the creator. Included only when the asset name is composed of printable utf-8 characters.

name-b64string<byte>

Base64 encoded name of this asset, as supplied by the creator.

reservestring

[r] Address of account holding reserve (non-minted) units of this asset.

totalintegerrequired

[t] The total number of units of this asset.

unit-namestring

[un] Name of a unit of this asset, as supplied by the creator. Included only when the name of a unit of this asset is composed of printable utf-8 characters.

unit-name-b64string<byte>

Base64 encoded name of a unit of this asset, as supplied by the creator.

urlstring

[au] URL where more information about the asset can be retrieved. Included only when the URL is composed of printable utf-8 characters.

url-b64string<byte>

Base64 encoded URL where more information about the asset can be retrieved.

min-balanceintegerrequired

MicroAlgo balance required by the account.

The requirement grows based on asset and application usage.

participationAccountParticipation

AccountParticipation describes the parameters used by this account in consensus protocol.

Show child attributes

selection-participation-keystring<byte>required

[sel] Selection public key (if any) currently registered for this round.

state-proof-keystring<byte>

[stprf] Root of the state proof key (if any)

vote-first-validintegerrequired

[voteFst] First round for which this participation is valid.

vote-key-dilutionintegerrequired

[voteKD] Number of subkeys in each batch of participation keys.

vote-last-validintegerrequired

[voteLst] Last round for which this participation is valid.

vote-participation-keystring<byte>required

[vote] root participation public key (if any) currently registered for this round.

pending-rewardsintegerrequired

amount of MicroAlgos of pending rewards in this account.

reward-baseinteger

[ebase] used as part of the rewards computation. Only applicable to accounts which are participating.

rewardsintegerrequired

[ern] total rewards of MicroAlgos the account has received, including pending rewards.

roundintegerrequired

The round for which this information is relevant.

sig-typestringsigmsiglsig

Indicates what type of signature is used by this account, must be one of:

sig
msig
lsig

statusstringrequired

[onl] delegation status of the account's MicroAlgos

Offline - indicates that the associated account is delegated.
Online - indicates that the associated account used as part of the delegation pool.
NotParticipating - indicates that the associated account is neither a delegator nor a delegate.

total-apps-opted-inintegerrequired

The count of all applications that have been opted in, equivalent to the count of application local data (AppLocalState objects) stored in this account.

total-assets-opted-inintegerrequired

The count of all assets that have been opted in, equivalent to the count of AssetHolding objects held by this account.

total-box-bytesinteger

[tbxb] The total number of bytes used by this account's app's box keys and values.

total-boxesinteger

[tbx] The number of existing boxes created by this account's app.

total-created-appsintegerrequired

The count of all apps (AppParams objects) created by this account.

total-created-assetsintegerrequired

The count of all assets (AssetParams objects) created by this account.

appsArray<Application>required

Show child attributes

idintegerrequired

[appidx] application index.

paramsApplicationParamsrequired

Stores the global information associated with an application.

Show child attributes

approval-programstring<byte>required

[approv] approval program.

clear-state-programstring<byte>required

[clearp] approval program.

creatorstringrequired

The address that created this application. This is the address where the parameters and global state for this application can be found.

extra-program-pagesinteger

[epp] the amount of extra program pages available to this app.

global-stateArray<TealKeyValue>

Represents a key-value store for use in an application.

Show child attributes

keystringrequired

valueTealValuerequired

Represents a TEAL value.

Show child attributes

bytesstringrequired

[tb] bytes value.

typeintegerrequired

[tt] value type. Value 1 refers to bytes, value 2 refers to uint

uintintegerrequired

[ui] uint value.

global-state-schemaApplicationStateSchema

Specifies maximums on the number of each type that may be stored.

Show child attributes

num-byte-sliceintegerrequired

[nbs] num of byte slices.

num-uintintegerrequired

[nui] num of uints.

local-state-schemaApplicationStateSchema

Specifies maximums on the number of each type that may be stored.

Show child attributes

num-byte-sliceintegerrequired

[nbs] num of byte slices.

num-uintintegerrequired

[nui] num of uints.

latest-timestampinteger<int64>required

LatestTimestamp is available to some TEAL scripts. Defaults to the latest confirmed timestamp this algod is attached to.

protocol-versionstringrequired

ProtocolVersion specifies a specific version string to operate under, otherwise whatever the current protocol of the network this algod is running in.

roundintegerrequired

Round is available to some TEAL scripts. Defaults to the current round on the network this algod is attached to.

sourcesArray<DryrunSource>required

Show child attributes

app-indexintegerrequired

field-namestringrequired

FieldName is what kind of sources this is. If lsig then it goes into the transactions[this.TxnIndex].LogicSig. If approv or clearp it goes into the Approval Program or Clear State Program of application[this.AppIndex].

sourcestringrequired

txn-indexintegerrequired

txnsArray<string>required

application/msgpackDryrunRequest

Request data type for dryrun endpoint. Given the Transactions and simulated ledger state upload, run TEAL scripts and return debugging information.

accountsArray<Account>required

Show child attributes

addressstringrequired

the account public key

amountintegerrequired

[algo] total number of MicroAlgos in the account

amount-without-pending-rewardsintegerrequired

specifies the amount of MicroAlgos in the account, without the pending rewards.

apps-local-stateArray<ApplicationLocalState>

[appl] applications local data stored in this account.

Note the raw object uses map[int] -> AppLocalState for this type.

Show child attributes

idintegerrequired

The application which this local state is for.

key-valueArray<TealKeyValue>

Represents a key-value store for use in an application.

Show child attributes

keystringrequired

valueTealValuerequired

Represents a TEAL value.

Show child attributes

bytesstringrequired

[tb] bytes value.

typeintegerrequired

[tt] value type. Value 1 refers to bytes, value 2 refers to uint

uintintegerrequired

[ui] uint value.

schemaApplicationStateSchemarequired

Specifies maximums on the number of each type that may be stored.

Show child attributes

num-byte-sliceintegerrequired

[nbs] num of byte slices.

num-uintintegerrequired

[nui] num of uints.

apps-total-extra-pagesinteger

[teap] the sum of all extra application program pages for this account.

apps-total-schemaApplicationStateSchema

Specifies maximums on the number of each type that may be stored.

Show child attributes

num-byte-sliceintegerrequired

[nbs] num of byte slices.

num-uintintegerrequired

[nui] num of uints.

assetsArray<AssetHolding>

[asset] assets held by this account.

Note the raw object uses map[int] -> AssetHolding for this type.

Show child attributes

amountintegerrequired

[a] number of units held.

asset-idintegerrequired

Asset ID of the holding.

is-frozenbooleanrequired

[f] whether or not the holding is frozen.

auth-addrstring

[spend] the address against which signing should be checked. If empty, the address of the current account is used. This field can be updated in any transaction by setting the RekeyTo field.

created-appsArray<Application>

[appp] parameters of applications created by this account including app global data.

Note: the raw account uses map[int] -> AppParams for this type.

Show child attributes

idintegerrequired

[appidx] application index.

paramsApplicationParamsrequired

Stores the global information associated with an application.

Show child attributes

approval-programstring<byte>required

[approv] approval program.

clear-state-programstring<byte>required

[clearp] approval program.

creatorstringrequired

The address that created this application. This is the address where the parameters and global state for this application can be found.

extra-program-pagesinteger

[epp] the amount of extra program pages available to this app.

global-stateArray<TealKeyValue>

Represents a key-value store for use in an application.

Show child attributes

keystringrequired

valueTealValuerequired

Represents a TEAL value.

Show child attributes

bytesstringrequired

[tb] bytes value.

typeintegerrequired

[tt] value type. Value 1 refers to bytes, value 2 refers to uint

uintintegerrequired

[ui] uint value.

global-state-schemaApplicationStateSchema

Specifies maximums on the number of each type that may be stored.

Show child attributes

num-byte-sliceintegerrequired

[nbs] num of byte slices.

num-uintintegerrequired

[nui] num of uints.

local-state-schemaApplicationStateSchema

Specifies maximums on the number of each type that may be stored.

Show child attributes

num-byte-sliceintegerrequired

[nbs] num of byte slices.

num-uintintegerrequired

[nui] num of uints.

created-assetsArray<Asset>

[apar] parameters of assets created by this account.

Note: the raw account uses map[int] -> Asset for this type.

Show child attributes

indexintegerrequired

unique asset identifier

paramsAssetParamsrequired

AssetParams specifies the parameters for an asset.

[apar] when part of an AssetConfig transaction.

Definition: data/transactions/asset.go : AssetParams

Show child attributes

clawbackstring

[c] Address of account used to clawback holdings of this asset. If empty, clawback is not permitted.

creatorstringrequired

The address that created this asset. This is the address where the parameters for this asset can be found, and also the address where unwanted asset units can be sent in the worst case.

decimalsinteger[0, 19]required

default-frozenboolean

[df] Whether holdings of this asset are frozen by default.

freezestring

[f] Address of account used to freeze holdings of this asset. If empty, freezing is not permitted.

managerstring

[m] Address of account used to manage the keys of this asset and to destroy it.

metadata-hashstring<byte>

[am] A commitment to some unspecified asset metadata. The format of this metadata is up to the application.

namestring

[an] Name of this asset, as supplied by the creator. Included only when the asset name is composed of printable utf-8 characters.

name-b64string<byte>

Base64 encoded name of this asset, as supplied by the creator.

reservestring

[r] Address of account holding reserve (non-minted) units of this asset.

totalintegerrequired

[t] The total number of units of this asset.

unit-namestring

[un] Name of a unit of this asset, as supplied by the creator. Included only when the name of a unit of this asset is composed of printable utf-8 characters.

unit-name-b64string<byte>

Base64 encoded name of a unit of this asset, as supplied by the creator.

urlstring

[au] URL where more information about the asset can be retrieved. Included only when the URL is composed of printable utf-8 characters.

url-b64string<byte>

Base64 encoded URL where more information about the asset can be retrieved.

min-balanceintegerrequired

MicroAlgo balance required by the account.

The requirement grows based on asset and application usage.

participationAccountParticipation

AccountParticipation describes the parameters used by this account in consensus protocol.

Show child attributes

selection-participation-keystring<byte>required

[sel] Selection public key (if any) currently registered for this round.

state-proof-keystring<byte>

[stprf] Root of the state proof key (if any)

vote-first-validintegerrequired

[voteFst] First round for which this participation is valid.

vote-key-dilutionintegerrequired

[voteKD] Number of subkeys in each batch of participation keys.

vote-last-validintegerrequired

[voteLst] Last round for which this participation is valid.

vote-participation-keystring<byte>required

[vote] root participation public key (if any) currently registered for this round.

pending-rewardsintegerrequired

amount of MicroAlgos of pending rewards in this account.

reward-baseinteger

[ebase] used as part of the rewards computation. Only applicable to accounts which are participating.

rewardsintegerrequired

[ern] total rewards of MicroAlgos the account has received, including pending rewards.

roundintegerrequired

The round for which this information is relevant.

sig-typestringsigmsiglsig

Indicates what type of signature is used by this account, must be one of:

sig
msig
lsig

statusstringrequired

[onl] delegation status of the account's MicroAlgos

Offline - indicates that the associated account is delegated.
Online - indicates that the associated account used as part of the delegation pool.
NotParticipating - indicates that the associated account is neither a delegator nor a delegate.

total-apps-opted-inintegerrequired

The count of all applications that have been opted in, equivalent to the count of application local data (AppLocalState objects) stored in this account.

total-assets-opted-inintegerrequired

The count of all assets that have been opted in, equivalent to the count of AssetHolding objects held by this account.

total-box-bytesinteger

[tbxb] The total number of bytes used by this account's app's box keys and values.

total-boxesinteger

[tbx] The number of existing boxes created by this account's app.

total-created-appsintegerrequired

The count of all apps (AppParams objects) created by this account.

total-created-assetsintegerrequired

The count of all assets (AssetParams objects) created by this account.

appsArray<Application>required

Show child attributes

idintegerrequired

[appidx] application index.

paramsApplicationParamsrequired

Stores the global information associated with an application.

Show child attributes

approval-programstring<byte>required

[approv] approval program.

clear-state-programstring<byte>required

[clearp] approval program.

creatorstringrequired

The address that created this application. This is the address where the parameters and global state for this application can be found.

extra-program-pagesinteger

[epp] the amount of extra program pages available to this app.

global-stateArray<TealKeyValue>

Represents a key-value store for use in an application.

Show child attributes

keystringrequired

valueTealValuerequired

Represents a TEAL value.

Show child attributes

bytesstringrequired

[tb] bytes value.

typeintegerrequired

[tt] value type. Value 1 refers to bytes, value 2 refers to uint

uintintegerrequired

[ui] uint value.

global-state-schemaApplicationStateSchema

Specifies maximums on the number of each type that may be stored.

Show child attributes

num-byte-sliceintegerrequired

[nbs] num of byte slices.

num-uintintegerrequired

[nui] num of uints.

local-state-schemaApplicationStateSchema

Specifies maximums on the number of each type that may be stored.

Show child attributes

num-byte-sliceintegerrequired

[nbs] num of byte slices.

num-uintintegerrequired

[nui] num of uints.

latest-timestampinteger<int64>required

LatestTimestamp is available to some TEAL scripts. Defaults to the latest confirmed timestamp this algod is attached to.

protocol-versionstringrequired

ProtocolVersion specifies a specific version string to operate under, otherwise whatever the current protocol of the network this algod is running in.

roundintegerrequired

Round is available to some TEAL scripts. Defaults to the current round on the network this algod is attached to.

sourcesArray<DryrunSource>required

Show child attributes

app-indexintegerrequired

field-namestringrequired

sourcestringrequired

txn-indexintegerrequired

txnsArray<string>required

Response

200OK

DryrunResponse contains per-txn debug information from a dryrun.

400Bad Request

Bad Request

401Unauthorized

Invalid API Token

404Not Found

Developer API not enabled

500Internal Server Error

Internal Error

default

Unknown Error

Provide debugging information for a transaction (or group).

curl -X POST 'https://algo.nownodes.io/v2/teal/dryrun' \
  -H 'Content-Type: application/json' \
  -d '{
    "accounts": [
      {
        "address": "string",
        "amount": 0,
        "amount-without-pending-rewards": 0,
        "apps-local-state": [
          {
            "id": 0,
            "key-value": [
              {
                "key": "string",
                "value": {
                  "bytes": "string",
                  "type": 0,
                  "uint": 0
                }
              }
            ],
            "schema": {
              "num-byte-slice": 0,
              "num-uint": 0
            }
          }
        ],
        "apps-total-extra-pages": 0,
        "apps-total-schema": {
          "num-byte-slice": 0,
          "num-uint": 0
        },
        "assets": [
          {
            "amount": 0,
            "asset-id": 0,
            "is-frozen": true
          }
        ],
        "auth-addr": "string",
        "created-apps": [
          {
            "id": 0,
            "params": {
              "approval-program": "dGVzdA==",
              "clear-state-program": "dGVzdA==",
              "creator": "string",
              "extra-program-pages": 0,
              "global-state": [
                {
                  "key": "string",
                  "value": {
                    "bytes": "string",
                    "type": 0,
                    "uint": 0
                  }
                }
              ],
              "global-state-schema": {
                "num-byte-slice": 0,
                "num-uint": 0
              },
              "local-state-schema": {
                "num-byte-slice": 0,
                "num-uint": 0
              }
            }
          }
        ],
        "created-assets": [
          {
            "index": 0,
            "params": {
              "clawback": "string",
              "creator": "string",
              "decimals": 0,
              "default-frozen": true,
              "freeze": "string",
              "manager": "string",
              "metadata-hash": "dGVzdA==",
              "name": "string",
              "name-b64": "dGVzdA==",
              "reserve": "string",
              "total": 0,
              "unit-name": "string",
              "unit-name-b64": "dGVzdA==",
              "url": "string",
              "url-b64": "dGVzdA=="
            }
          }
        ],
        "min-balance": 0,
        "participation": {
          "selection-participation-key": "dGVzdA==",
          "state-proof-key": "dGVzdA==",
          "vote-first-valid": 0,
          "vote-key-dilution": 0,
          "vote-last-valid": 0,
          "vote-participation-key": "dGVzdA=="
        },
        "pending-rewards": 0,
        "reward-base": 0,
        "rewards": 0,
        "round": 0,
        "sig-type": "sig",
        "status": "string",
        "total-apps-opted-in": 0,
        "total-assets-opted-in": 0,
        "total-box-bytes": 0,
        "total-boxes": 0,
        "total-created-apps": 0,
        "total-created-assets": 0
      }
    ],
    "apps": [
      {
        "id": 0,
        "params": {
          "approval-program": "dGVzdA==",
          "clear-state-program": "dGVzdA==",
          "creator": "string",
          "extra-program-pages": 0,
          "global-state": [
            {
              "key": "string",
              "value": {
                "bytes": "string",
                "type": 0,
                "uint": 0
              }
            }
          ],
          "global-state-schema": {
            "num-byte-slice": 0,
            "num-uint": 0
          },
          "local-state-schema": {
            "num-byte-slice": 0,
            "num-uint": 0
          }
        }
      }
    ],
    "latest-timestamp": 0,
    "protocol-version": "string",
    "round": 0,
    "sources": [
      {
        "app-index": 0,
        "field-name": "string",
        "source": "string",
        "txn-index": 0
      }
    ],
    "txns": [
      "string"
    ]
  }'

const response = await fetch('https://algo.nownodes.io/v2/teal/dryrun', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "accounts": [
        {
          "address": "string",
          "amount": 0,
          "amount-without-pending-rewards": 0,
          "apps-local-state": [
            {
              "id": 0,
              "key-value": [
                {
                  "key": "string",
                  "value": {
                    "bytes": "string",
                    "type": 0,
                    "uint": 0
                  }
                }
              ],
              "schema": {
                "num-byte-slice": 0,
                "num-uint": 0
              }
            }
          ],
          "apps-total-extra-pages": 0,
          "apps-total-schema": {
            "num-byte-slice": 0,
            "num-uint": 0
          },
          "assets": [
            {
              "amount": 0,
              "asset-id": 0,
              "is-frozen": true
            }
          ],
          "auth-addr": "string",
          "created-apps": [
            {
              "id": 0,
              "params": {
                "approval-program": "dGVzdA==",
                "clear-state-program": "dGVzdA==",
                "creator": "string",
                "extra-program-pages": 0,
                "global-state": [
                  {
                    "key": "string",
                    "value": {
                      "bytes": "string",
                      "type": 0,
                      "uint": 0
                    }
                  }
                ],
                "global-state-schema": {
                  "num-byte-slice": 0,
                  "num-uint": 0
                },
                "local-state-schema": {
                  "num-byte-slice": 0,
                  "num-uint": 0
                }
              }
            }
          ],
          "created-assets": [
            {
              "index": 0,
              "params": {
                "clawback": "string",
                "creator": "string",
                "decimals": 0,
                "default-frozen": true,
                "freeze": "string",
                "manager": "string",
                "metadata-hash": "dGVzdA==",
                "name": "string",
                "name-b64": "dGVzdA==",
                "reserve": "string",
                "total": 0,
                "unit-name": "string",
                "unit-name-b64": "dGVzdA==",
                "url": "string",
                "url-b64": "dGVzdA=="
              }
            }
          ],
          "min-balance": 0,
          "participation": {
            "selection-participation-key": "dGVzdA==",
            "state-proof-key": "dGVzdA==",
            "vote-first-valid": 0,
            "vote-key-dilution": 0,
            "vote-last-valid": 0,
            "vote-participation-key": "dGVzdA=="
          },
          "pending-rewards": 0,
          "reward-base": 0,
          "rewards": 0,
          "round": 0,
          "sig-type": "sig",
          "status": "string",
          "total-apps-opted-in": 0,
          "total-assets-opted-in": 0,
          "total-box-bytes": 0,
          "total-boxes": 0,
          "total-created-apps": 0,
          "total-created-assets": 0
        }
      ],
      "apps": [
        {
          "id": 0,
          "params": {
            "approval-program": "dGVzdA==",
            "clear-state-program": "dGVzdA==",
            "creator": "string",
            "extra-program-pages": 0,
            "global-state": [
              {
                "key": "string",
                "value": {
                  "bytes": "string",
                  "type": 0,
                  "uint": 0
                }
              }
            ],
            "global-state-schema": {
              "num-byte-slice": 0,
              "num-uint": 0
            },
            "local-state-schema": {
              "num-byte-slice": 0,
              "num-uint": 0
            }
          }
        }
      ],
      "latest-timestamp": 0,
      "protocol-version": "string",
      "round": 0,
      "sources": [
        {
          "app-index": 0,
          "field-name": "string",
          "source": "string",
          "txn-index": 0
        }
      ],
      "txns": [
        "string"
      ]
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v2/teal/dryrun')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "accounts": [
      {
        "address": "string",
        "amount": 0,
        "amount-without-pending-rewards": 0,
        "apps-local-state": [
          {
            "id": 0,
            "key-value": [
              {
                "key": "string",
                "value": {
                  "bytes": "string",
                  "type": 0,
                  "uint": 0
                }
              }
            ],
            "schema": {
              "num-byte-slice": 0,
              "num-uint": 0
            }
          }
        ],
        "apps-total-extra-pages": 0,
        "apps-total-schema": {
          "num-byte-slice": 0,
          "num-uint": 0
        },
        "assets": [
          {
            "amount": 0,
            "asset-id": 0,
            "is-frozen": true
          }
        ],
        "auth-addr": "string",
        "created-apps": [
          {
            "id": 0,
            "params": {
              "approval-program": "dGVzdA==",
              "clear-state-program": "dGVzdA==",
              "creator": "string",
              "extra-program-pages": 0,
              "global-state": [
                {
                  "key": "string",
                  "value": {
                    "bytes": "string",
                    "type": 0,
                    "uint": 0
                  }
                }
              ],
              "global-state-schema": {
                "num-byte-slice": 0,
                "num-uint": 0
              },
              "local-state-schema": {
                "num-byte-slice": 0,
                "num-uint": 0
              }
            }
          }
        ],
        "created-assets": [
          {
            "index": 0,
            "params": {
              "clawback": "string",
              "creator": "string",
              "decimals": 0,
              "default-frozen": true,
              "freeze": "string",
              "manager": "string",
              "metadata-hash": "dGVzdA==",
              "name": "string",
              "name-b64": "dGVzdA==",
              "reserve": "string",
              "total": 0,
              "unit-name": "string",
              "unit-name-b64": "dGVzdA==",
              "url": "string",
              "url-b64": "dGVzdA=="
            }
          }
        ],
        "min-balance": 0,
        "participation": {
          "selection-participation-key": "dGVzdA==",
          "state-proof-key": "dGVzdA==",
          "vote-first-valid": 0,
          "vote-key-dilution": 0,
          "vote-last-valid": 0,
          "vote-participation-key": "dGVzdA=="
        },
        "pending-rewards": 0,
        "reward-base": 0,
        "rewards": 0,
        "round": 0,
        "sig-type": "sig",
        "status": "string",
        "total-apps-opted-in": 0,
        "total-assets-opted-in": 0,
        "total-box-bytes": 0,
        "total-boxes": 0,
        "total-created-apps": 0,
        "total-created-assets": 0
      }
    ],
    "apps": [
      {
        "id": 0,
        "params": {
          "approval-program": "dGVzdA==",
          "clear-state-program": "dGVzdA==",
          "creator": "string",
          "extra-program-pages": 0,
          "global-state": [
            {
              "key": "string",
              "value": {
                "bytes": "string",
                "type": 0,
                "uint": 0
              }
            }
          ],
          "global-state-schema": {
            "num-byte-slice": 0,
            "num-uint": 0
          },
          "local-state-schema": {
            "num-byte-slice": 0,
            "num-uint": 0
          }
        }
      }
    ],
    "latest-timestamp": 0,
    "protocol-version": "string",
    "round": 0,
    "sources": [
      {
        "app-index": 0,
        "field-name": "string",
        "source": "string",
        "txn-index": 0
      }
    ],
    "txns": [
      "string"
    ]
  }'

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

import requests

payload = {
  "accounts": [
    {
      "address": "string",
      "amount": 0,
      "amount-without-pending-rewards": 0,
      "apps-local-state": [
        {
          "id": 0,
          "key-value": [
            {
              "key": "string",
              "value": {
                "bytes": "string",
                "type": 0,
                "uint": 0
              }
            }
          ],
          "schema": {
            "num-byte-slice": 0,
            "num-uint": 0
          }
        }
      ],
      "apps-total-extra-pages": 0,
      "apps-total-schema": {
        "num-byte-slice": 0,
        "num-uint": 0
      },
      "assets": [
        {
          "amount": 0,
          "asset-id": 0,
          "is-frozen": True
        }
      ],
      "auth-addr": "string",
      "created-apps": [
        {
          "id": 0,
          "params": {
            "approval-program": "dGVzdA==",
            "clear-state-program": "dGVzdA==",
            "creator": "string",
            "extra-program-pages": 0,
            "global-state": [
              {
                "key": "string",
                "value": {
                  "bytes": "string",
                  "type": 0,
                  "uint": 0
                }
              }
            ],
            "global-state-schema": {
              "num-byte-slice": 0,
              "num-uint": 0
            },
            "local-state-schema": {
              "num-byte-slice": 0,
              "num-uint": 0
            }
          }
        }
      ],
      "created-assets": [
        {
          "index": 0,
          "params": {
            "clawback": "string",
            "creator": "string",
            "decimals": 0,
            "default-frozen": True,
            "freeze": "string",
            "manager": "string",
            "metadata-hash": "dGVzdA==",
            "name": "string",
            "name-b64": "dGVzdA==",
            "reserve": "string",
            "total": 0,
            "unit-name": "string",
            "unit-name-b64": "dGVzdA==",
            "url": "string",
            "url-b64": "dGVzdA=="
          }
        }
      ],
      "min-balance": 0,
      "participation": {
        "selection-participation-key": "dGVzdA==",
        "state-proof-key": "dGVzdA==",
        "vote-first-valid": 0,
        "vote-key-dilution": 0,
        "vote-last-valid": 0,
        "vote-participation-key": "dGVzdA=="
      },
      "pending-rewards": 0,
      "reward-base": 0,
      "rewards": 0,
      "round": 0,
      "sig-type": "sig",
      "status": "string",
      "total-apps-opted-in": 0,
      "total-assets-opted-in": 0,
      "total-box-bytes": 0,
      "total-boxes": 0,
      "total-created-apps": 0,
      "total-created-assets": 0
    }
  ],
  "apps": [
    {
      "id": 0,
      "params": {
        "approval-program": "dGVzdA==",
        "clear-state-program": "dGVzdA==",
        "creator": "string",
        "extra-program-pages": 0,
        "global-state": [
          {
            "key": "string",
            "value": {
              "bytes": "string",
              "type": 0,
              "uint": 0
            }
          }
        ],
        "global-state-schema": {
          "num-byte-slice": 0,
          "num-uint": 0
        },
        "local-state-schema": {
          "num-byte-slice": 0,
          "num-uint": 0
        }
      }
    }
  ],
  "latest-timestamp": 0,
  "protocol-version": "string",
  "round": 0,
  "sources": [
    {
      "app-index": 0,
      "field-name": "string",
      "source": "string",
      "txn-index": 0
    }
  ],
  "txns": [
    "string"
  ]
}

response = requests.post('https://algo.nownodes.io/v2/teal/dryrun', json=payload)
data = response.json()

const response = await fetch('https://algo.nownodes.io/v2/teal/dryrun', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "accounts": [
        {
          "address": "string",
          "amount": 0,
          "amount-without-pending-rewards": 0,
          "apps-local-state": [
            {
              "id": 0,
              "key-value": [
                {
                  "key": "string",
                  "value": {
                    "bytes": "string",
                    "type": 0,
                    "uint": 0
                  }
                }
              ],
              "schema": {
                "num-byte-slice": 0,
                "num-uint": 0
              }
            }
          ],
          "apps-total-extra-pages": 0,
          "apps-total-schema": {
            "num-byte-slice": 0,
            "num-uint": 0
          },
          "assets": [
            {
              "amount": 0,
              "asset-id": 0,
              "is-frozen": true
            }
          ],
          "auth-addr": "string",
          "created-apps": [
            {
              "id": 0,
              "params": {
                "approval-program": "dGVzdA==",
                "clear-state-program": "dGVzdA==",
                "creator": "string",
                "extra-program-pages": 0,
                "global-state": [
                  {
                    "key": "string",
                    "value": {
                      "bytes": "string",
                      "type": 0,
                      "uint": 0
                    }
                  }
                ],
                "global-state-schema": {
                  "num-byte-slice": 0,
                  "num-uint": 0
                },
                "local-state-schema": {
                  "num-byte-slice": 0,
                  "num-uint": 0
                }
              }
            }
          ],
          "created-assets": [
            {
              "index": 0,
              "params": {
                "clawback": "string",
                "creator": "string",
                "decimals": 0,
                "default-frozen": true,
                "freeze": "string",
                "manager": "string",
                "metadata-hash": "dGVzdA==",
                "name": "string",
                "name-b64": "dGVzdA==",
                "reserve": "string",
                "total": 0,
                "unit-name": "string",
                "unit-name-b64": "dGVzdA==",
                "url": "string",
                "url-b64": "dGVzdA=="
              }
            }
          ],
          "min-balance": 0,
          "participation": {
            "selection-participation-key": "dGVzdA==",
            "state-proof-key": "dGVzdA==",
            "vote-first-valid": 0,
            "vote-key-dilution": 0,
            "vote-last-valid": 0,
            "vote-participation-key": "dGVzdA=="
          },
          "pending-rewards": 0,
          "reward-base": 0,
          "rewards": 0,
          "round": 0,
          "sig-type": "sig",
          "status": "string",
          "total-apps-opted-in": 0,
          "total-assets-opted-in": 0,
          "total-box-bytes": 0,
          "total-boxes": 0,
          "total-created-apps": 0,
          "total-created-assets": 0
        }
      ],
      "apps": [
        {
          "id": 0,
          "params": {
            "approval-program": "dGVzdA==",
            "clear-state-program": "dGVzdA==",
            "creator": "string",
            "extra-program-pages": 0,
            "global-state": [
              {
                "key": "string",
                "value": {
                  "bytes": "string",
                  "type": 0,
                  "uint": 0
                }
              }
            ],
            "global-state-schema": {
              "num-byte-slice": 0,
              "num-uint": 0
            },
            "local-state-schema": {
              "num-byte-slice": 0,
              "num-uint": 0
            }
          }
        }
      ],
      "latest-timestamp": 0,
      "protocol-version": "string",
      "round": 0,
      "sources": [
        {
          "app-index": 0,
          "field-name": "string",
          "source": "string",
          "txn-index": 0
        }
      ],
      "txns": [
        "string"
      ]
    }),
});

const data = await response.json();

const endpoint = "https://algo.nownodes.io/v2/teal/dryrun";
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({
    "accounts": [
      {
        "address": "string",
        "amount": 0,
        "amount-without-pending-rewards": 0,
        "apps-local-state": [
          {
            "id": 0,
            "key-value": [
              {
                "key": "string",
                "value": {
                  "bytes": "string",
                  "type": 0,
                  "uint": 0
                }
              }
            ],
            "schema": {
              "num-byte-slice": 0,
              "num-uint": 0
            }
          }
        ],
        "apps-total-extra-pages": 0,
        "apps-total-schema": {
          "num-byte-slice": 0,
          "num-uint": 0
        },
        "assets": [
          {
            "amount": 0,
            "asset-id": 0,
            "is-frozen": true
          }
        ],
        "auth-addr": "string",
        "created-apps": [
          {
            "id": 0,
            "params": {
              "approval-program": "dGVzdA==",
              "clear-state-program": "dGVzdA==",
              "creator": "string",
              "extra-program-pages": 0,
              "global-state": [
                {
                  "key": "string",
                  "value": {
                    "bytes": "string",
                    "type": 0,
                    "uint": 0
                  }
                }
              ],
              "global-state-schema": {
                "num-byte-slice": 0,
                "num-uint": 0
              },
              "local-state-schema": {
                "num-byte-slice": 0,
                "num-uint": 0
              }
            }
          }
        ],
        "created-assets": [
          {
            "index": 0,
            "params": {
              "clawback": "string",
              "creator": "string",
              "decimals": 0,
              "default-frozen": true,
              "freeze": "string",
              "manager": "string",
              "metadata-hash": "dGVzdA==",
              "name": "string",
              "name-b64": "dGVzdA==",
              "reserve": "string",
              "total": 0,
              "unit-name": "string",
              "unit-name-b64": "dGVzdA==",
              "url": "string",
              "url-b64": "dGVzdA=="
            }
          }
        ],
        "min-balance": 0,
        "participation": {
          "selection-participation-key": "dGVzdA==",
          "state-proof-key": "dGVzdA==",
          "vote-first-valid": 0,
          "vote-key-dilution": 0,
          "vote-last-valid": 0,
          "vote-participation-key": "dGVzdA=="
        },
        "pending-rewards": 0,
        "reward-base": 0,
        "rewards": 0,
        "round": 0,
        "sig-type": "sig",
        "status": "string",
        "total-apps-opted-in": 0,
        "total-assets-opted-in": 0,
        "total-box-bytes": 0,
        "total-boxes": 0,
        "total-created-apps": 0,
        "total-created-assets": 0
      }
    ],
    "apps": [
      {
        "id": 0,
        "params": {
          "approval-program": "dGVzdA==",
          "clear-state-program": "dGVzdA==",
          "creator": "string",
          "extra-program-pages": 0,
          "global-state": [
            {
              "key": "string",
              "value": {
                "bytes": "string",
                "type": 0,
                "uint": 0
              }
            }
          ],
          "global-state-schema": {
            "num-byte-slice": 0,
            "num-uint": 0
          },
          "local-state-schema": {
            "num-byte-slice": 0,
            "num-uint": 0
          }
        }
      }
    ],
    "latest-timestamp": 0,
    "protocol-version": "string",
    "round": 0,
    "sources": [
      {
        "app-index": 0,
        "field-name": "string",
        "source": "string",
        "txn-index": 0
      }
    ],
    "txns": [
      "string"
    ]
  });
console.log(result);

const response = await fetch('https://algo.nownodes.io/v2/teal/dryrun', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "accounts": [
        {
          "address": "string",
          "amount": 0,
          "amount-without-pending-rewards": 0,
          "apps-local-state": [
            {
              "id": 0,
              "key-value": [
                {
                  "key": "string",
                  "value": {
                    "bytes": "string",
                    "type": 0,
                    "uint": 0
                  }
                }
              ],
              "schema": {
                "num-byte-slice": 0,
                "num-uint": 0
              }
            }
          ],
          "apps-total-extra-pages": 0,
          "apps-total-schema": {
            "num-byte-slice": 0,
            "num-uint": 0
          },
          "assets": [
            {
              "amount": 0,
              "asset-id": 0,
              "is-frozen": true
            }
          ],
          "auth-addr": "string",
          "created-apps": [
            {
              "id": 0,
              "params": {
                "approval-program": "dGVzdA==",
                "clear-state-program": "dGVzdA==",
                "creator": "string",
                "extra-program-pages": 0,
                "global-state": [
                  {
                    "key": "string",
                    "value": {
                      "bytes": "string",
                      "type": 0,
                      "uint": 0
                    }
                  }
                ],
                "global-state-schema": {
                  "num-byte-slice": 0,
                  "num-uint": 0
                },
                "local-state-schema": {
                  "num-byte-slice": 0,
                  "num-uint": 0
                }
              }
            }
          ],
          "created-assets": [
            {
              "index": 0,
              "params": {
                "clawback": "string",
                "creator": "string",
                "decimals": 0,
                "default-frozen": true,
                "freeze": "string",
                "manager": "string",
                "metadata-hash": "dGVzdA==",
                "name": "string",
                "name-b64": "dGVzdA==",
                "reserve": "string",
                "total": 0,
                "unit-name": "string",
                "unit-name-b64": "dGVzdA==",
                "url": "string",
                "url-b64": "dGVzdA=="
              }
            }
          ],
          "min-balance": 0,
          "participation": {
            "selection-participation-key": "dGVzdA==",
            "state-proof-key": "dGVzdA==",
            "vote-first-valid": 0,
            "vote-key-dilution": 0,
            "vote-last-valid": 0,
            "vote-participation-key": "dGVzdA=="
          },
          "pending-rewards": 0,
          "reward-base": 0,
          "rewards": 0,
          "round": 0,
          "sig-type": "sig",
          "status": "string",
          "total-apps-opted-in": 0,
          "total-assets-opted-in": 0,
          "total-box-bytes": 0,
          "total-boxes": 0,
          "total-created-apps": 0,
          "total-created-assets": 0
        }
      ],
      "apps": [
        {
          "id": 0,
          "params": {
            "approval-program": "dGVzdA==",
            "clear-state-program": "dGVzdA==",
            "creator": "string",
            "extra-program-pages": 0,
            "global-state": [
              {
                "key": "string",
                "value": {
                  "bytes": "string",
                  "type": 0,
                  "uint": 0
                }
              }
            ],
            "global-state-schema": {
              "num-byte-slice": 0,
              "num-uint": 0
            },
            "local-state-schema": {
              "num-byte-slice": 0,
              "num-uint": 0
            }
          }
        }
      ],
      "latest-timestamp": 0,
      "protocol-version": "string",
      "round": 0,
      "sources": [
        {
          "app-index": 0,
          "field-name": "string",
          "source": "string",
          "txn-index": 0
        }
      ],
      "txns": [
        "string"
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "accounts": [
    {
      "address": "string",
      "amount": 0,
      "amount-without-pending-rewards": 0,
      "apps-local-state": [
        {
          "id": 0,
          "key-value": [
            {
              "key": "string",
              "value": {
                "bytes": "string",
                "type": 0,
                "uint": 0
              }
            }
          ],
          "schema": {
            "num-byte-slice": 0,
            "num-uint": 0
          }
        }
      ],
      "apps-total-extra-pages": 0,
      "apps-total-schema": {
        "num-byte-slice": 0,
        "num-uint": 0
      },
      "assets": [
        {
          "amount": 0,
          "asset-id": 0,
          "is-frozen": True
        }
      ],
      "auth-addr": "string",
      "created-apps": [
        {
          "id": 0,
          "params": {
            "approval-program": "dGVzdA==",
            "clear-state-program": "dGVzdA==",
            "creator": "string",
            "extra-program-pages": 0,
            "global-state": [
              {
                "key": "string",
                "value": {
                  "bytes": "string",
                  "type": 0,
                  "uint": 0
                }
              }
            ],
            "global-state-schema": {
              "num-byte-slice": 0,
              "num-uint": 0
            },
            "local-state-schema": {
              "num-byte-slice": 0,
              "num-uint": 0
            }
          }
        }
      ],
      "created-assets": [
        {
          "index": 0,
          "params": {
            "clawback": "string",
            "creator": "string",
            "decimals": 0,
            "default-frozen": True,
            "freeze": "string",
            "manager": "string",
            "metadata-hash": "dGVzdA==",
            "name": "string",
            "name-b64": "dGVzdA==",
            "reserve": "string",
            "total": 0,
            "unit-name": "string",
            "unit-name-b64": "dGVzdA==",
            "url": "string",
            "url-b64": "dGVzdA=="
          }
        }
      ],
      "min-balance": 0,
      "participation": {
        "selection-participation-key": "dGVzdA==",
        "state-proof-key": "dGVzdA==",
        "vote-first-valid": 0,
        "vote-key-dilution": 0,
        "vote-last-valid": 0,
        "vote-participation-key": "dGVzdA=="
      },
      "pending-rewards": 0,
      "reward-base": 0,
      "rewards": 0,
      "round": 0,
      "sig-type": "sig",
      "status": "string",
      "total-apps-opted-in": 0,
      "total-assets-opted-in": 0,
      "total-box-bytes": 0,
      "total-boxes": 0,
      "total-created-apps": 0,
      "total-created-assets": 0
    }
  ],
  "apps": [
    {
      "id": 0,
      "params": {
        "approval-program": "dGVzdA==",
        "clear-state-program": "dGVzdA==",
        "creator": "string",
        "extra-program-pages": 0,
        "global-state": [
          {
            "key": "string",
            "value": {
              "bytes": "string",
              "type": 0,
              "uint": 0
            }
          }
        ],
        "global-state-schema": {
          "num-byte-slice": 0,
          "num-uint": 0
        },
        "local-state-schema": {
          "num-byte-slice": 0,
          "num-uint": 0
        }
      }
    }
  ],
  "latest-timestamp": 0,
  "protocol-version": "string",
  "round": 0,
  "sources": [
    {
      "app-index": 0,
      "field-name": "string",
      "source": "string",
      "txn-index": 0
    }
  ],
  "txns": [
    "string"
  ]
}

response = requests.post('https://algo.nownodes.io/v2/teal/dryrun', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v2/teal/dryrun')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "accounts": [
      {
        "address": "string",
        "amount": 0,
        "amount-without-pending-rewards": 0,
        "apps-local-state": [
          {
            "id": 0,
            "key-value": [
              {
                "key": "string",
                "value": {
                  "bytes": "string",
                  "type": 0,
                  "uint": 0
                }
              }
            ],
            "schema": {
              "num-byte-slice": 0,
              "num-uint": 0
            }
          }
        ],
        "apps-total-extra-pages": 0,
        "apps-total-schema": {
          "num-byte-slice": 0,
          "num-uint": 0
        },
        "assets": [
          {
            "amount": 0,
            "asset-id": 0,
            "is-frozen": true
          }
        ],
        "auth-addr": "string",
        "created-apps": [
          {
            "id": 0,
            "params": {
              "approval-program": "dGVzdA==",
              "clear-state-program": "dGVzdA==",
              "creator": "string",
              "extra-program-pages": 0,
              "global-state": [
                {
                  "key": "string",
                  "value": {
                    "bytes": "string",
                    "type": 0,
                    "uint": 0
                  }
                }
              ],
              "global-state-schema": {
                "num-byte-slice": 0,
                "num-uint": 0
              },
              "local-state-schema": {
                "num-byte-slice": 0,
                "num-uint": 0
              }
            }
          }
        ],
        "created-assets": [
          {
            "index": 0,
            "params": {
              "clawback": "string",
              "creator": "string",
              "decimals": 0,
              "default-frozen": true,
              "freeze": "string",
              "manager": "string",
              "metadata-hash": "dGVzdA==",
              "name": "string",
              "name-b64": "dGVzdA==",
              "reserve": "string",
              "total": 0,
              "unit-name": "string",
              "unit-name-b64": "dGVzdA==",
              "url": "string",
              "url-b64": "dGVzdA=="
            }
          }
        ],
        "min-balance": 0,
        "participation": {
          "selection-participation-key": "dGVzdA==",
          "state-proof-key": "dGVzdA==",
          "vote-first-valid": 0,
          "vote-key-dilution": 0,
          "vote-last-valid": 0,
          "vote-participation-key": "dGVzdA=="
        },
        "pending-rewards": 0,
        "reward-base": 0,
        "rewards": 0,
        "round": 0,
        "sig-type": "sig",
        "status": "string",
        "total-apps-opted-in": 0,
        "total-assets-opted-in": 0,
        "total-box-bytes": 0,
        "total-boxes": 0,
        "total-created-apps": 0,
        "total-created-assets": 0
      }
    ],
    "apps": [
      {
        "id": 0,
        "params": {
          "approval-program": "dGVzdA==",
          "clear-state-program": "dGVzdA==",
          "creator": "string",
          "extra-program-pages": 0,
          "global-state": [
            {
              "key": "string",
              "value": {
                "bytes": "string",
                "type": 0,
                "uint": 0
              }
            }
          ],
          "global-state-schema": {
            "num-byte-slice": 0,
            "num-uint": 0
          },
          "local-state-schema": {
            "num-byte-slice": 0,
            "num-uint": 0
          }
        }
      }
    ],
    "latest-timestamp": 0,
    "protocol-version": "string",
    "round": 0,
    "sources": [
      {
        "app-index": 0,
        "field-name": "string",
        "source": "string",
        "txn-index": 0
      }
    ],
    "txns": [
      "string"
    ]
  }'

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

Request Body

{
  "accounts": [
    {
      "address": "string",
      "amount": 0,
      "amount-without-pending-rewards": 0,
      "apps-local-state": [
        {
          "id": 0,
          "key-value": [
            {
              "key": "string",
              "value": {
                "bytes": "string",
                "type": 0,
                "uint": 0
              }
            }
          ],
          "schema": {
            "num-byte-slice": 0,
            "num-uint": 0
          }
        }
      ],
      "apps-total-extra-pages": 0,
      "apps-total-schema": {
        "num-byte-slice": 0,
        "num-uint": 0
      },
      "assets": [
        {
          "amount": 0,
          "asset-id": 0,
          "is-frozen": true
        }
      ],
      "auth-addr": "string",
      "created-apps": [
        {
          "id": 0,
          "params": {
            "approval-program": "dGVzdA==",
            "clear-state-program": "dGVzdA==",
            "creator": "string",
            "extra-program-pages": 0,
            "global-state": [
              {
                "key": "string",
                "value": {
                  "bytes": "string",
                  "type": 0,
                  "uint": 0
                }
              }
            ],
            "global-state-schema": {
              "num-byte-slice": 0,
              "num-uint": 0
            },
            "local-state-schema": {
              "num-byte-slice": 0,
              "num-uint": 0
            }
          }
        }
      ],
      "created-assets": [
        {
          "index": 0,
          "params": {
            "clawback": "string",
            "creator": "string",
            "decimals": 0,
            "default-frozen": true,
            "freeze": "string",
            "manager": "string",
            "metadata-hash": "dGVzdA==",
            "name": "string",
            "name-b64": "dGVzdA==",
            "reserve": "string",
            "total": 0,
            "unit-name": "string",
            "unit-name-b64": "dGVzdA==",
            "url": "string",
            "url-b64": "dGVzdA=="
          }
        }
      ],
      "min-balance": 0,
      "participation": {
        "selection-participation-key": "dGVzdA==",
        "state-proof-key": "dGVzdA==",
        "vote-first-valid": 0,
        "vote-key-dilution": 0,
        "vote-last-valid": 0,
        "vote-participation-key": "dGVzdA=="
      },
      "pending-rewards": 0,
      "reward-base": 0,
      "rewards": 0,
      "round": 0,
      "sig-type": "sig",
      "status": "string",
      "total-apps-opted-in": 0,
      "total-assets-opted-in": 0,
      "total-box-bytes": 0,
      "total-boxes": 0,
      "total-created-apps": 0,
      "total-created-assets": 0
    }
  ],
  "apps": [
    {
      "id": 0,
      "params": {
        "approval-program": "dGVzdA==",
        "clear-state-program": "dGVzdA==",
        "creator": "string",
        "extra-program-pages": 0,
        "global-state": [
          {
            "key": "string",
            "value": {
              "bytes": "string",
              "type": 0,
              "uint": 0
            }
          }
        ],
        "global-state-schema": {
          "num-byte-slice": 0,
          "num-uint": 0
        },
        "local-state-schema": {
          "num-byte-slice": 0,
          "num-uint": 0
        }
      }
    }
  ],
  "latest-timestamp": 0,
  "protocol-version": "string",
  "round": 0,
  "sources": [
    {
      "app-index": 0,
      "field-name": "string",
      "source": "string",
      "txn-index": 0
    }
  ],
  "txns": [
    "string"
  ]
}

{
  "accounts": [
    {
      "address": "string",
      "amount": 0,
      "amount-without-pending-rewards": 0,
      "apps-local-state": [
        {
          "id": 0,
          "key-value": [
            {
              "key": "string",
              "value": {
                "bytes": "string",
                "type": 0,
                "uint": 0
              }
            }
          ],
          "schema": {
            "num-byte-slice": 0,
            "num-uint": 0
          }
        }
      ],
      "apps-total-extra-pages": 0,
      "apps-total-schema": {
        "num-byte-slice": 0,
        "num-uint": 0
      },
      "assets": [
        {
          "amount": 0,
          "asset-id": 0,
          "is-frozen": true
        }
      ],
      "auth-addr": "string",
      "created-apps": [
        {
          "id": 0,
          "params": {
            "approval-program": "dGVzdA==",
            "clear-state-program": "dGVzdA==",
            "creator": "string",
            "extra-program-pages": 0,
            "global-state": [
              {
                "key": "string",
                "value": {
                  "bytes": "string",
                  "type": 0,
                  "uint": 0
                }
              }
            ],
            "global-state-schema": {
              "num-byte-slice": 0,
              "num-uint": 0
            },
            "local-state-schema": {
              "num-byte-slice": 0,
              "num-uint": 0
            }
          }
        }
      ],
      "created-assets": [
        {
          "index": 0,
          "params": {
            "clawback": "string",
            "creator": "string",
            "decimals": 0,
            "default-frozen": true,
            "freeze": "string",
            "manager": "string",
            "metadata-hash": "dGVzdA==",
            "name": "string",
            "name-b64": "dGVzdA==",
            "reserve": "string",
            "total": 0,
            "unit-name": "string",
            "unit-name-b64": "dGVzdA==",
            "url": "string",
            "url-b64": "dGVzdA=="
          }
        }
      ],
      "min-balance": 0,
      "participation": {
        "selection-participation-key": "dGVzdA==",
        "state-proof-key": "dGVzdA==",
        "vote-first-valid": 0,
        "vote-key-dilution": 0,
        "vote-last-valid": 0,
        "vote-participation-key": "dGVzdA=="
      },
      "pending-rewards": 0,
      "reward-base": 0,
      "rewards": 0,
      "round": 0,
      "sig-type": "sig",
      "status": "string",
      "total-apps-opted-in": 0,
      "total-assets-opted-in": 0,
      "total-box-bytes": 0,
      "total-boxes": 0,
      "total-created-apps": 0,
      "total-created-assets": 0
    }
  ],
  "apps": [
    {
      "id": 0,
      "params": {
        "approval-program": "dGVzdA==",
        "clear-state-program": "dGVzdA==",
        "creator": "string",
        "extra-program-pages": 0,
        "global-state": [
          {
            "key": "string",
            "value": {
              "bytes": "string",
              "type": 0,
              "uint": 0
            }
          }
        ],
        "global-state-schema": {
          "num-byte-slice": 0,
          "num-uint": 0
        },
        "local-state-schema": {
          "num-byte-slice": 0,
          "num-uint": 0
        }
      }
    }
  ],
  "latest-timestamp": 0,
  "protocol-version": "string",
  "round": 0,
  "sources": [
    {
      "app-index": 0,
      "field-name": "string",
      "source": "string",
      "txn-index": 0
    }
  ],
  "txns": [
    "string"
  ]
}

{
  "error": "string",
  "protocol-version": "string",
  "txns": [
    {
      "app-call-messages": [
        "string"
      ],
      "app-call-trace": [
        {
          "error": "string",
          "line": 0,
          "pc": 0,
          "scratch": [
            {
              "bytes": "string",
              "type": 0,
              "uint": 0
            }
          ],
          "stack": [
            {
              "bytes": "string",
              "type": 0,
              "uint": 0
            }
          ]
        }
      ],
      "budget-added": 0,
      "budget-consumed": 0,
      "disassembly": [
        "string"
      ],
      "global-delta": [
        {
          "key": "string",
          "value": {
            "action": 0,
            "bytes": "string",
            "uint": 0
          }
        }
      ],
      "local-deltas": [
        {
          "address": "string",
          "delta": [
            {
              "key": "string",
              "value": {
                "action": 0,
                "bytes": "string",
                "uint": 0
              }
            }
          ]
        }
      ],
      "logic-sig-disassembly": [
        "string"
      ],
      "logic-sig-messages": [
        "string"
      ],
      "logic-sig-trace": [
        {
          "error": "string",
          "line": 0,
          "pc": 0,
          "scratch": [
            {
              "bytes": "string",
              "type": 0,
              "uint": 0
            }
          ],
          "stack": [
            {
              "bytes": "string",
              "type": 0,
              "uint": 0
            }
          ]
        }
      ],
      "logs": [
        "dGVzdA=="
      ]
    }
  ]
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

Transactions

Broadcasts a raw transaction or transaction group to the network.

POST

https://algo.nownodes.io/v2/transactions

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Body

application/x-binary

The byte encoded signed transaction to broadcast to network

string<binary>

Response

200OK

Transaction ID of the submission.

400Bad Request

Bad Request - Malformed Algorand transaction

401Unauthorized

Invalid API Token

500Internal Server Error

Internal Error

503Service Unavailable

Service Temporarily Unavailable

default

Unknown Error

Broadcasts a raw transaction or transaction group to the network.

curl -X POST 'https://algo.nownodes.io/v2/transactions' \
  -H 'Content-Type: application/x-binary' \
  -d '"<binary>"'

const response = await fetch('https://algo.nownodes.io/v2/transactions', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/x-binary',
  },
  body: JSON.stringify("<binary>"),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v2/transactions')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/x-binary'
request.body = '"<binary>"'

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

import requests

payload = "<binary>"

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

const response = await fetch('https://algo.nownodes.io/v2/transactions', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/x-binary',
  },
  body: JSON.stringify("<binary>"),
});

const data = await response.json();

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

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

  return response.json();
}

const result = await nownodesRequest("<binary>");
console.log(result);

const response = await fetch('https://algo.nownodes.io/v2/transactions', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/x-binary',
  },
  body: JSON.stringify("<binary>"),
});

const data = await response.json();

import requests

payload = "<binary>"

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

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v2/transactions')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/x-binary'
request.body = '"<binary>"'

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

Request Body

"<binary>"

{
  "txId": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

Fast track for broadcasting a raw transaction or transaction group to the network through the tx handler without performing most of the checks and reporting detailed errors. Should be only used for development and performance testing.

POST

https://algo.nownodes.io/v2/transactions/async

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Body

application/x-binary

The byte encoded signed transaction to broadcast to network

string<binary>

Response

200OK

Valid response

400Bad Request

Bad Request - Malformed Algorand transaction

401Unauthorized

Invalid API Token

500Internal Server Error

Internal Error

503Service Unavailable

Service Temporarily Unavailable

default

Unknown Error

Fast track for broadcasting a raw transaction or transaction group to the network through the tx handler without performing most of the checks and reporting detailed errors. Should be only used for development and performance testing.

curl -X POST 'https://algo.nownodes.io/v2/transactions/async' \
  -H 'Content-Type: application/x-binary' \
  -d '"<binary>"'

const response = await fetch('https://algo.nownodes.io/v2/transactions/async', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/x-binary',
  },
  body: JSON.stringify("<binary>"),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v2/transactions/async')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/x-binary'
request.body = '"<binary>"'

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

import requests

payload = "<binary>"

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

const response = await fetch('https://algo.nownodes.io/v2/transactions/async', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/x-binary',
  },
  body: JSON.stringify("<binary>"),
});

const data = await response.json();

const endpoint = "https://algo.nownodes.io/v2/transactions/async";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

const result = await nownodesRequest("<binary>");
console.log(result);

const response = await fetch('https://algo.nownodes.io/v2/transactions/async', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/x-binary',
  },
  body: JSON.stringify("<binary>"),
});

const data = await response.json();

import requests

payload = "<binary>"

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

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v2/transactions/async')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/x-binary'
request.body = '"<binary>"'

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

Request Body

"<binary>"

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

Get parameters for constructing a new transaction

GET

https://algo.nownodes.io/v2/transactions/params

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Response

200OK

TransactionParams contains the parameters that help a client construct a new transaction.

401Unauthorized

Invalid API Token

500Internal Server Error

Internal Error

503Service Unavailable

Service Temporarily Unavailable

default

Unknown Error

Get parameters for constructing a new transaction

curl -X GET 'https://algo.nownodes.io/v2/transactions/params'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://algo.nownodes.io/v2/transactions/params')
data = response.json()

require 'net/http'
require 'json'

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

{
  "consensus-version": "string",
  "fee": 0,
  "genesis-hash": "dGVzdA==",
  "genesis-id": "string",
  "last-round": 0,
  "min-fee": 0
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

Get a list of unconfirmed transactions currently in the transaction pool.

GET

https://algo.nownodes.io/v2/transactions/pending

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Get the list of pending transactions, sorted by priority, in decreasing order, truncated at the end at MAX. If MAX = 0, returns all pending transactions.

Parameters

maxintegerquery

Truncated number of transactions to display. If max=0, returns all pending txns.

formatstringjsonmsgpackquery

Configures whether the response object is JSON or MessagePack encoded. If not provided, defaults to JSON.

Response

200OK

401Unauthorized

Invalid API Token

500Internal Server Error

Internal Error

503Service Unavailable

Service Temporarily Unavailable

default

Unknown Error

Get a list of unconfirmed transactions currently in the transaction pool.

curl -X GET 'https://algo.nownodes.io/v2/transactions/pending'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://algo.nownodes.io/v2/transactions/pending')
data = response.json()

require 'net/http'
require 'json'

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

{
  "top-transactions": [
    {}
  ],
  "total-transactions": 0
}

{
  "top-transactions": [
    {}
  ],
  "total-transactions": 0
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

Get a specific pending transaction.

GET

https://algo.nownodes.io/v2/transactions/pending/{txid}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Given a transaction ID of a recently submitted transaction, it returns information about it. There are several cases when this might succeed:

transaction committed (committed round > 0)
transaction still in the pool (committed round = 0, pool error = "")
transaction removed from pool due to error (committed round = 0, pool error != "") Or the transaction may have happened sufficiently long ago that the node no longer remembers it, and this will return an error.

Parameters

txidstringrequiredpath

A transaction ID

formatstringjsonmsgpackquery

Configures whether the response object is JSON or MessagePack encoded. If not provided, defaults to JSON.

Response

200OK

Given a transaction ID of a recently submitted transaction, it returns information about it. There are several cases when this might succeed:

transaction committed (committed round > 0)
transaction still in the pool (committed round = 0, pool error = "")
transaction removed from pool due to error (committed round = 0, pool error != "")

Or the transaction may have happened sufficiently long ago that the node no longer remembers it, and this will return an error.

400Bad Request

Bad Request

401Unauthorized

Invalid API Token

404Not Found

Transaction Not Found

default

Unknown Error

Get a specific pending transaction.

curl -X GET 'https://algo.nownodes.io/v2/transactions/pending/{txid}'

const response = await fetch('https://algo.nownodes.io/v2/transactions/pending/{txid}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v2/transactions/pending/{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://algo.nownodes.io/v2/transactions/pending/{txid}')
data = response.json()

const response = await fetch('https://algo.nownodes.io/v2/transactions/pending/{txid}', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://algo.nownodes.io/v2/transactions/pending/{txid}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v2/transactions/pending/{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)

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

Simulates a raw transaction or transaction group as it would be evaluated on the network. The simulation will use blockchain state from the latest committed round.

POST

https://algo.nownodes.io/v2/transactions/simulate

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Body

application/json

The transactions to simulate, along with any other inputs.

application/jsonSimulateRequest

Request type for simulation endpoint.

allow-empty-signaturesboolean

Allows transactions without signatures to be simulated as if they had correct signatures.

allow-more-loggingboolean

Lifts limits on log opcode usage during simulation.

allow-unnamed-resourcesboolean

Allows access to unnamed resources during simulation.

exec-trace-configSimulateTraceConfig

An object that configures simulation execution trace.

Show child attributes

enableboolean

A boolean option for opting in execution trace features simulation endpoint.

scratch-changeboolean

A boolean option enabling returning scratch slot changes together with execution trace during simulation.

stack-changeboolean

A boolean option enabling returning stack changes together with execution trace during simulation.

state-changeboolean

A boolean option enabling returning application state changes (global, local, and box changes) with the execution trace during simulation.

extra-opcode-budgetinteger

Applies extra opcode budget during simulation for each transaction group.

roundinteger

If provided, specifies the round preceding the simulation. State changes through this round will be used to run this simulation. Usually only the 4 most recent rounds will be available (controlled by the node config value MaxAcctLookback). If not specified, defaults to the latest available round.

txn-groupsArray<SimulateRequestTransactionGroup>required

The transaction groups to simulate.

Show child attributes

txnsArray<string>required

An atomic transaction group.

application/msgpackSimulateRequest

Request type for simulation endpoint.

allow-empty-signaturesboolean

Allows transactions without signatures to be simulated as if they had correct signatures.

allow-more-loggingboolean

Lifts limits on log opcode usage during simulation.

allow-unnamed-resourcesboolean

Allows access to unnamed resources during simulation.

exec-trace-configSimulateTraceConfig

An object that configures simulation execution trace.

Show child attributes

enableboolean

A boolean option for opting in execution trace features simulation endpoint.

scratch-changeboolean

A boolean option enabling returning scratch slot changes together with execution trace during simulation.

stack-changeboolean

A boolean option enabling returning stack changes together with execution trace during simulation.

state-changeboolean

A boolean option enabling returning application state changes (global, local, and box changes) with the execution trace during simulation.

extra-opcode-budgetinteger

Applies extra opcode budget during simulation for each transaction group.

roundinteger

txn-groupsArray<SimulateRequestTransactionGroup>required

The transaction groups to simulate.

Show child attributes

txnsArray<string>required

An atomic transaction group.

Parameters

formatstringjsonmsgpackquery

Configures whether the response object is JSON or MessagePack encoded. If not provided, defaults to JSON.

Response

200OK

Result of a transaction group simulation.

400Bad Request

Bad Request

401Unauthorized

Invalid API Token

500Internal Server Error

Internal Error

503Service Unavailable

Service Temporarily Unavailable

default

Unknown Error

Simulates a raw transaction or transaction group as it would be evaluated on the network. The simulation will use blockchain state from the latest committed round.

curl -X POST 'https://algo.nownodes.io/v2/transactions/simulate' \
  -H 'Content-Type: application/json' \
  -d '{
    "allow-empty-signatures": true,
    "allow-more-logging": true,
    "allow-unnamed-resources": true,
    "exec-trace-config": {
      "enable": true,
      "scratch-change": true,
      "stack-change": true,
      "state-change": true
    },
    "extra-opcode-budget": 0,
    "round": 0,
    "txn-groups": [
      {
        "txns": [
          "string"
        ]
      }
    ]
  }'

const response = await fetch('https://algo.nownodes.io/v2/transactions/simulate', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "allow-empty-signatures": true,
      "allow-more-logging": true,
      "allow-unnamed-resources": true,
      "exec-trace-config": {
        "enable": true,
        "scratch-change": true,
        "stack-change": true,
        "state-change": true
      },
      "extra-opcode-budget": 0,
      "round": 0,
      "txn-groups": [
        {
          "txns": [
            "string"
          ]
        }
      ]
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v2/transactions/simulate')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "allow-empty-signatures": true,
    "allow-more-logging": true,
    "allow-unnamed-resources": true,
    "exec-trace-config": {
      "enable": true,
      "scratch-change": true,
      "stack-change": true,
      "state-change": true
    },
    "extra-opcode-budget": 0,
    "round": 0,
    "txn-groups": [
      {
        "txns": [
          "string"
        ]
      }
    ]
  }'

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

import requests

payload = {
  "allow-empty-signatures": True,
  "allow-more-logging": True,
  "allow-unnamed-resources": True,
  "exec-trace-config": {
    "enable": True,
    "scratch-change": True,
    "stack-change": True,
    "state-change": True
  },
  "extra-opcode-budget": 0,
  "round": 0,
  "txn-groups": [
    {
      "txns": [
        "string"
      ]
    }
  ]
}

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

const response = await fetch('https://algo.nownodes.io/v2/transactions/simulate', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "allow-empty-signatures": true,
      "allow-more-logging": true,
      "allow-unnamed-resources": true,
      "exec-trace-config": {
        "enable": true,
        "scratch-change": true,
        "stack-change": true,
        "state-change": true
      },
      "extra-opcode-budget": 0,
      "round": 0,
      "txn-groups": [
        {
          "txns": [
            "string"
          ]
        }
      ]
    }),
});

const data = await response.json();

const endpoint = "https://algo.nownodes.io/v2/transactions/simulate";
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({
    "allow-empty-signatures": true,
    "allow-more-logging": true,
    "allow-unnamed-resources": true,
    "exec-trace-config": {
      "enable": true,
      "scratch-change": true,
      "stack-change": true,
      "state-change": true
    },
    "extra-opcode-budget": 0,
    "round": 0,
    "txn-groups": [
      {
        "txns": [
          "string"
        ]
      }
    ]
  });
console.log(result);

const response = await fetch('https://algo.nownodes.io/v2/transactions/simulate', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "allow-empty-signatures": true,
      "allow-more-logging": true,
      "allow-unnamed-resources": true,
      "exec-trace-config": {
        "enable": true,
        "scratch-change": true,
        "stack-change": true,
        "state-change": true
      },
      "extra-opcode-budget": 0,
      "round": 0,
      "txn-groups": [
        {
          "txns": [
            "string"
          ]
        }
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "allow-empty-signatures": True,
  "allow-more-logging": True,
  "allow-unnamed-resources": True,
  "exec-trace-config": {
    "enable": True,
    "scratch-change": True,
    "stack-change": True,
    "state-change": True
  },
  "extra-opcode-budget": 0,
  "round": 0,
  "txn-groups": [
    {
      "txns": [
        "string"
      ]
    }
  ]
}

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

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v2/transactions/simulate')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "allow-empty-signatures": true,
    "allow-more-logging": true,
    "allow-unnamed-resources": true,
    "exec-trace-config": {
      "enable": true,
      "scratch-change": true,
      "stack-change": true,
      "state-change": true
    },
    "extra-opcode-budget": 0,
    "round": 0,
    "txn-groups": [
      {
        "txns": [
          "string"
        ]
      }
    ]
  }'

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

Request Body

{
  "allow-empty-signatures": true,
  "allow-more-logging": true,
  "allow-unnamed-resources": true,
  "exec-trace-config": {
    "enable": true,
    "scratch-change": true,
    "stack-change": true,
    "state-change": true
  },
  "extra-opcode-budget": 0,
  "round": 0,
  "txn-groups": [
    {
      "txns": [
        "string"
      ]
    }
  ]
}

{
  "allow-empty-signatures": true,
  "allow-more-logging": true,
  "allow-unnamed-resources": true,
  "exec-trace-config": {
    "enable": true,
    "scratch-change": true,
    "stack-change": true,
    "state-change": true
  },
  "extra-opcode-budget": 0,
  "round": 0,
  "txn-groups": [
    {
      "txns": [
        "string"
      ]
    }
  ]
}

{
  "eval-overrides": {
    "allow-empty-signatures": true,
    "allow-unnamed-resources": true,
    "extra-opcode-budget": 0,
    "max-log-calls": 0,
    "max-log-size": 0
  },
  "exec-trace-config": {
    "enable": true,
    "scratch-change": true,
    "stack-change": true,
    "state-change": true
  },
  "initial-states": {
    "app-initial-states": [
      {
        "app-boxes": {
          "account": "string",
          "kvs": [
            {
              "key": "dGVzdA==",
              "value": {
                "bytes": "dGVzdA==",
                "type": 0,
                "uint": 0
              }
            }
          ]
        },
        "app-globals": {
          "account": "string",
          "kvs": [
            {
              "key": "dGVzdA==",
              "value": {
                "bytes": "dGVzdA==",
                "type": 0,
                "uint": 0
              }
            }
          ]
        },
        "app-locals": [
          {
            "account": "string",
            "kvs": [
              {
                "key": "dGVzdA==",
                "value": {
                  "bytes": "dGVzdA==",
                  "type": 0,
                  "uint": 0
                }
              }
            ]
          }
        ],
        "id": 0
      }
    ]
  },
  "last-round": 0,
  "txn-groups": [],
  "version": 0
}

{
  "eval-overrides": {
    "allow-empty-signatures": true,
    "allow-unnamed-resources": true,
    "extra-opcode-budget": 0,
    "max-log-calls": 0,
    "max-log-size": 0
  },
  "exec-trace-config": {
    "enable": true,
    "scratch-change": true,
    "stack-change": true,
    "state-change": true
  },
  "initial-states": {
    "app-initial-states": [
      {
        "app-boxes": {
          "account": "string",
          "kvs": [
            {
              "key": "dGVzdA==",
              "value": {
                "bytes": "dGVzdA==",
                "type": 0,
                "uint": 0
              }
            }
          ]
        },
        "app-globals": {
          "account": "string",
          "kvs": [
            {
              "key": "dGVzdA==",
              "value": {
                "bytes": "dGVzdA==",
                "type": 0,
                "uint": 0
              }
            }
          ]
        },
        "app-locals": [
          {
            "account": "string",
            "kvs": [
              {
                "key": "dGVzdA==",
                "value": {
                  "bytes": "dGVzdA==",
                  "type": 0,
                  "uint": 0
                }
              }
            ]
          }
        ],
        "id": 0
      }
    ]
  },
  "last-round": 0,
  "txn-groups": [],
  "version": 0
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

{
  "data": {},
  "message": "string"
}

Versions

GET

https://algo.nownodes.io/versions

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Retrieves the supported API versions, binary build versions, and genesis information.

Response

200OK

VersionsResponse is the response to 'GET /versions'

GET /versions

curl -X GET 'https://algo.nownodes.io/versions'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://algo.nownodes.io/versions')
data = response.json()

require 'net/http'
require 'json'

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

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

200

{
  "build": {
    "branch": "string",
    "build_number": 0,
    "channel": "string",
    "commit_hash": "string",
    "major": 0,
    "minor": 0
  },
  "genesis_hash_b64": "dGVzdA==",
  "genesis_id": "string",
  "versions": [
    "string"
  ]
}

Documentation

How to migrate to NOWNodes

Authentication

API Reference

Genesis

Authorizations

Response

Health

Authorizations

Response

Metrics

Authorizations

Response

Ready

Authorizations

Response

Swagger

Authorizations

Response

Accounts

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Applications

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Assets

Authorizations

Parameters

Response

Blocks

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Deltas

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Devmode

Authorizations

Response

Authorizations

Parameters