for KMD HTTP API

v0.0.1

Contact: [email protected]

Base URL

https://algo.nownodes.io

API for KMD (Key Management Daemon)

Authentication

api-keyAuthapiKey

API Key: api-key in header

API Reference

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"

Key

Generate a key

POST

https://algo.nownodes.io/v1/key

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Generates the next key in the deterministic key sequence (as determined by the master derivation key) and adds it to the wallet, returning the public key.

Body

application/json

APIV1POSTKeyRequest is the request for POST /v1/key

display_mnemonicboolean

wallet_handle_tokenstring

Response

200OK

Response to POST /v1/key

Generate a key

curl -X POST 'https://algo.nownodes.io/v1/key' \
  -H 'Content-Type: application/json' \
  -d '{
    "display_mnemonic": true,
    "wallet_handle_token": "string"
  }'

const response = await fetch('https://algo.nownodes.io/v1/key', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "display_mnemonic": true,
      "wallet_handle_token": "string"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v1/key')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "display_mnemonic": true,
    "wallet_handle_token": "string"
  }'

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

import requests

payload = {
  "display_mnemonic": True,
  "wallet_handle_token": "string"
}

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

const response = await fetch('https://algo.nownodes.io/v1/key', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "display_mnemonic": true,
      "wallet_handle_token": "string"
    }),
});

const data = await response.json();

const endpoint = "https://algo.nownodes.io/v1/key";
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({
    "display_mnemonic": true,
    "wallet_handle_token": "string"
  });
console.log(result);

const response = await fetch('https://algo.nownodes.io/v1/key', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "display_mnemonic": true,
      "wallet_handle_token": "string"
    }),
});

const data = await response.json();

import requests

payload = {
  "display_mnemonic": True,
  "wallet_handle_token": "string"
}

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

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v1/key')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "display_mnemonic": true,
    "wallet_handle_token": "string"
  }'

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

Request Body

{
  "display_mnemonic": true,
  "wallet_handle_token": "string"
}

200

{
  "address": "string",
  "error": true,
  "message": "string"
}

Export a key

POST

https://algo.nownodes.io/v1/key/export

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Export the secret key associated with the passed public key.

Body

application/json

APIV1POSTKeyExportRequest is the request for POST /v1/key/export

addressstring

wallet_handle_tokenstring

wallet_passwordstring

Response

200OK

Response to POST /v1/key/export

Export a key

curl -X POST 'https://algo.nownodes.io/v1/key/export' \
  -H 'Content-Type: application/json' \
  -d '{
    "address": "string",
    "wallet_handle_token": "string",
    "wallet_password": "string"
  }'

const response = await fetch('https://algo.nownodes.io/v1/key/export', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "address": "string",
      "wallet_handle_token": "string",
      "wallet_password": "string"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v1/key/export')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "address": "string",
    "wallet_handle_token": "string",
    "wallet_password": "string"
  }'

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

import requests

payload = {
  "address": "string",
  "wallet_handle_token": "string",
  "wallet_password": "string"
}

response = requests.post('https://algo.nownodes.io/v1/key/export', json=payload)
data = response.json()

const response = await fetch('https://algo.nownodes.io/v1/key/export', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "address": "string",
      "wallet_handle_token": "string",
      "wallet_password": "string"
    }),
});

const data = await response.json();

const endpoint = "https://algo.nownodes.io/v1/key/export";
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({
    "address": "string",
    "wallet_handle_token": "string",
    "wallet_password": "string"
  });
console.log(result);

const response = await fetch('https://algo.nownodes.io/v1/key/export', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "address": "string",
      "wallet_handle_token": "string",
      "wallet_password": "string"
    }),
});

const data = await response.json();

import requests

payload = {
  "address": "string",
  "wallet_handle_token": "string",
  "wallet_password": "string"
}

response = requests.post('https://algo.nownodes.io/v1/key/export', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v1/key/export')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "address": "string",
    "wallet_handle_token": "string",
    "wallet_password": "string"
  }'

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

Request Body

{
  "address": "string",
  "wallet_handle_token": "string",
  "wallet_password": "string"
}

200

{
  "error": true,
  "message": "string",
  "private_key": [
    0
  ]
}

Import a key

POST

https://algo.nownodes.io/v1/key/import

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Import an externally generated key into the wallet. Note that if you wish to back up the imported key, you must do so by backing up the entire wallet database, because imported keys were not derived from the wallet's master derivation key.

Body

application/json

APIV1POSTKeyImportRequest is the request for POST /v1/key/import

private_keyArray<integer>

wallet_handle_tokenstring

Response

200OK

Response to POST /v1/key/import

Import a key

curl -X POST 'https://algo.nownodes.io/v1/key/import' \
  -H 'Content-Type: application/json' \
  -d '{
    "private_key": [
      0
    ],
    "wallet_handle_token": "string"
  }'

const response = await fetch('https://algo.nownodes.io/v1/key/import', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "private_key": [
        0
      ],
      "wallet_handle_token": "string"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v1/key/import')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "private_key": [
      0
    ],
    "wallet_handle_token": "string"
  }'

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

import requests

payload = {
  "private_key": [
    0
  ],
  "wallet_handle_token": "string"
}

response = requests.post('https://algo.nownodes.io/v1/key/import', json=payload)
data = response.json()

const response = await fetch('https://algo.nownodes.io/v1/key/import', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "private_key": [
        0
      ],
      "wallet_handle_token": "string"
    }),
});

const data = await response.json();

const endpoint = "https://algo.nownodes.io/v1/key/import";
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({
    "private_key": [
      0
    ],
    "wallet_handle_token": "string"
  });
console.log(result);

const response = await fetch('https://algo.nownodes.io/v1/key/import', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "private_key": [
        0
      ],
      "wallet_handle_token": "string"
    }),
});

const data = await response.json();

import requests

payload = {
  "private_key": [
    0
  ],
  "wallet_handle_token": "string"
}

response = requests.post('https://algo.nownodes.io/v1/key/import', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v1/key/import')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "private_key": [
      0
    ],
    "wallet_handle_token": "string"
  }'

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

Request Body

{
  "private_key": [
    0
  ],
  "wallet_handle_token": "string"
}

200

{
  "address": "string",
  "error": true,
  "message": "string"
}

List keys in wallet

POST

https://algo.nownodes.io/v1/key/list

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Lists all of the public keys in this wallet. All of them have a stored private key.

Body

application/json

APIV1POSTKeyListRequest is the request for POST /v1/key/list

wallet_handle_tokenstring

Response

200OK

Response to POST /v1/key/list

List keys in wallet

curl -X POST 'https://algo.nownodes.io/v1/key/list' \
  -H 'Content-Type: application/json' \
  -d '{
    "wallet_handle_token": "string"
  }'

const response = await fetch('https://algo.nownodes.io/v1/key/list', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "wallet_handle_token": "string"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v1/key/list')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "wallet_handle_token": "string"
  }'

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

import requests

payload = {
  "wallet_handle_token": "string"
}

response = requests.post('https://algo.nownodes.io/v1/key/list', json=payload)
data = response.json()

const response = await fetch('https://algo.nownodes.io/v1/key/list', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "wallet_handle_token": "string"
    }),
});

const data = await response.json();

const endpoint = "https://algo.nownodes.io/v1/key/list";
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({
    "wallet_handle_token": "string"
  });
console.log(result);

const response = await fetch('https://algo.nownodes.io/v1/key/list', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "wallet_handle_token": "string"
    }),
});

const data = await response.json();

import requests

payload = {
  "wallet_handle_token": "string"
}

response = requests.post('https://algo.nownodes.io/v1/key/list', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v1/key/list')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "wallet_handle_token": "string"
  }'

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

Request Body

{
  "wallet_handle_token": "string"
}

200

{
  "addresses": [
    "string"
  ],
  "error": true,
  "message": "string"
}

Master-key

Export the master derivation key from a wallet

POST

https://algo.nownodes.io/v1/master-key/export

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Export the master derivation key from the wallet. This key is a master "backup" key for the underlying wallet. With it, you can regenerate all of the wallets that have been generated with this wallet's POST /v1/key endpoint. This key will not allow you to recover keys imported from other wallets, however.

Body

application/json

APIV1POSTMasterKeyExportRequest is the request for POST /v1/master-key/export

wallet_handle_tokenstring

wallet_passwordstring

Response

200OK

Response to POST /v1/master-key/export

Export the master derivation key from a wallet

curl -X POST 'https://algo.nownodes.io/v1/master-key/export' \
  -H 'Content-Type: application/json' \
  -d '{
    "wallet_handle_token": "string",
    "wallet_password": "string"
  }'

const response = await fetch('https://algo.nownodes.io/v1/master-key/export', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "wallet_handle_token": "string",
      "wallet_password": "string"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v1/master-key/export')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "wallet_handle_token": "string",
    "wallet_password": "string"
  }'

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

import requests

payload = {
  "wallet_handle_token": "string",
  "wallet_password": "string"
}

response = requests.post('https://algo.nownodes.io/v1/master-key/export', json=payload)
data = response.json()

const response = await fetch('https://algo.nownodes.io/v1/master-key/export', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "wallet_handle_token": "string",
      "wallet_password": "string"
    }),
});

const data = await response.json();

const endpoint = "https://algo.nownodes.io/v1/master-key/export";
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({
    "wallet_handle_token": "string",
    "wallet_password": "string"
  });
console.log(result);

const response = await fetch('https://algo.nownodes.io/v1/master-key/export', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "wallet_handle_token": "string",
      "wallet_password": "string"
    }),
});

const data = await response.json();

import requests

payload = {
  "wallet_handle_token": "string",
  "wallet_password": "string"
}

response = requests.post('https://algo.nownodes.io/v1/master-key/export', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v1/master-key/export')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "wallet_handle_token": "string",
    "wallet_password": "string"
  }'

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

Request Body

{
  "wallet_handle_token": "string",
  "wallet_password": "string"
}

200

{
  "error": true,
  "master_derivation_key": [
    0
  ],
  "message": "string"
}

Multisig

Export multisig address metadata

POST

https://algo.nownodes.io/v1/multisig/export

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Given a multisig address whose preimage this wallet stores, returns the information used to generate the address, including public keys, threshold, and multisig version.

Body

application/json

APIV1POSTMultisigExportRequest is the request for POST /v1/multisig/export

addressstring

wallet_handle_tokenstring

Response

200OK

Response to POST /v1/multisig/export

Export multisig address metadata

curl -X POST 'https://algo.nownodes.io/v1/multisig/export' \
  -H 'Content-Type: application/json' \
  -d '{
    "address": "string",
    "wallet_handle_token": "string"
  }'

const response = await fetch('https://algo.nownodes.io/v1/multisig/export', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "address": "string",
      "wallet_handle_token": "string"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v1/multisig/export')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "address": "string",
    "wallet_handle_token": "string"
  }'

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

import requests

payload = {
  "address": "string",
  "wallet_handle_token": "string"
}

response = requests.post('https://algo.nownodes.io/v1/multisig/export', json=payload)
data = response.json()

const response = await fetch('https://algo.nownodes.io/v1/multisig/export', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "address": "string",
      "wallet_handle_token": "string"
    }),
});

const data = await response.json();

const endpoint = "https://algo.nownodes.io/v1/multisig/export";
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({
    "address": "string",
    "wallet_handle_token": "string"
  });
console.log(result);

const response = await fetch('https://algo.nownodes.io/v1/multisig/export', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "address": "string",
      "wallet_handle_token": "string"
    }),
});

const data = await response.json();

import requests

payload = {
  "address": "string",
  "wallet_handle_token": "string"
}

response = requests.post('https://algo.nownodes.io/v1/multisig/export', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v1/multisig/export')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "address": "string",
    "wallet_handle_token": "string"
  }'

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

Request Body

{
  "address": "string",
  "wallet_handle_token": "string"
}

200

{
  "error": true,
  "message": "string",
  "multisig_version": 0,
  "pks": [
    [
      0
    ]
  ],
  "threshold": 0
}

Import a multisig account

POST

https://algo.nownodes.io/v1/multisig/import

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Generates a multisig account from the passed public keys array and multisig metadata, and stores all of this in the wallet.

Body

application/json

APIV1POSTMultisigImportRequest is the request for POST /v1/multisig/import

multisig_versioninteger<uint8>

pksArray<PublicKey>

thresholdinteger<uint8>

wallet_handle_tokenstring

Response

200OK

Response to POST /v1/multisig/import

Import a multisig account

curl -X POST 'https://algo.nownodes.io/v1/multisig/import' \
  -H 'Content-Type: application/json' \
  -d '{
    "multisig_version": 0,
    "pks": [
      [
        0
      ]
    ],
    "threshold": 0,
    "wallet_handle_token": "string"
  }'

const response = await fetch('https://algo.nownodes.io/v1/multisig/import', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "multisig_version": 0,
      "pks": [
        [
          0
        ]
      ],
      "threshold": 0,
      "wallet_handle_token": "string"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v1/multisig/import')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "multisig_version": 0,
    "pks": [
      [
        0
      ]
    ],
    "threshold": 0,
    "wallet_handle_token": "string"
  }'

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

import requests

payload = {
  "multisig_version": 0,
  "pks": [
    [
      0
    ]
  ],
  "threshold": 0,
  "wallet_handle_token": "string"
}

response = requests.post('https://algo.nownodes.io/v1/multisig/import', json=payload)
data = response.json()

const response = await fetch('https://algo.nownodes.io/v1/multisig/import', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "multisig_version": 0,
      "pks": [
        [
          0
        ]
      ],
      "threshold": 0,
      "wallet_handle_token": "string"
    }),
});

const data = await response.json();

const endpoint = "https://algo.nownodes.io/v1/multisig/import";
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({
    "multisig_version": 0,
    "pks": [
      [
        0
      ]
    ],
    "threshold": 0,
    "wallet_handle_token": "string"
  });
console.log(result);

const response = await fetch('https://algo.nownodes.io/v1/multisig/import', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "multisig_version": 0,
      "pks": [
        [
          0
        ]
      ],
      "threshold": 0,
      "wallet_handle_token": "string"
    }),
});

const data = await response.json();

import requests

payload = {
  "multisig_version": 0,
  "pks": [
    [
      0
    ]
  ],
  "threshold": 0,
  "wallet_handle_token": "string"
}

response = requests.post('https://algo.nownodes.io/v1/multisig/import', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v1/multisig/import')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "multisig_version": 0,
    "pks": [
      [
        0
      ]
    ],
    "threshold": 0,
    "wallet_handle_token": "string"
  }'

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

Request Body

{
  "multisig_version": 0,
  "pks": [
    [
      0
    ]
  ],
  "threshold": 0,
  "wallet_handle_token": "string"
}

200

{
  "address": "string",
  "error": true,
  "message": "string"
}

List multisig accounts

POST

https://algo.nownodes.io/v1/multisig/list

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Lists all of the multisig accounts whose preimages this wallet stores

Body

application/json

APIV1POSTMultisigListRequest is the request for POST /v1/multisig/list

wallet_handle_tokenstring

Response

200OK

Response to POST /v1/multisig/list

List multisig accounts

curl -X POST 'https://algo.nownodes.io/v1/multisig/list' \
  -H 'Content-Type: application/json' \
  -d '{
    "wallet_handle_token": "string"
  }'

const response = await fetch('https://algo.nownodes.io/v1/multisig/list', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "wallet_handle_token": "string"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v1/multisig/list')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "wallet_handle_token": "string"
  }'

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

import requests

payload = {
  "wallet_handle_token": "string"
}

response = requests.post('https://algo.nownodes.io/v1/multisig/list', json=payload)
data = response.json()

const response = await fetch('https://algo.nownodes.io/v1/multisig/list', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "wallet_handle_token": "string"
    }),
});

const data = await response.json();

const endpoint = "https://algo.nownodes.io/v1/multisig/list";
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({
    "wallet_handle_token": "string"
  });
console.log(result);

const response = await fetch('https://algo.nownodes.io/v1/multisig/list', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "wallet_handle_token": "string"
    }),
});

const data = await response.json();

import requests

payload = {
  "wallet_handle_token": "string"
}

response = requests.post('https://algo.nownodes.io/v1/multisig/list', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v1/multisig/list')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "wallet_handle_token": "string"
  }'

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

Request Body

{
  "wallet_handle_token": "string"
}

200

{
  "addresses": [
    "string"
  ],
  "error": true,
  "message": "string"
}

Sign a multisig transaction

POST

https://algo.nownodes.io/v1/multisig/sign

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Start a multisig signature, or add a signature to a partially completed multisig signature object.

Body

application/json

APIV1POSTMultisigTransactionSignRequest is the request for POST /v1/multisig/sign

partial_multisigMultisigSig

MultisigSig is the structure that holds multiple Subsigs

Show child attributes

SubsigsArray<MultisigSubsig>

Show child attributes

KeyArray<integer>

SigArray<integer>

Thresholdinteger<uint8>

Versioninteger<uint8>

public_keyArray<integer>

signerArray<integer>

transactionstring<byte>

wallet_handle_tokenstring

wallet_passwordstring

Response

200OK

Response to POST /v1/multisig/sign

Sign a multisig transaction

curl -X POST 'https://algo.nownodes.io/v1/multisig/sign' \
  -H 'Content-Type: application/json' \
  -d '{
    "partial_multisig": {
      "Subsigs": [
        {
          "Key": [
            0
          ],
          "Sig": [
            0
          ]
        }
      ],
      "Threshold": 0,
      "Version": 0
    },
    "public_key": [
      0
    ],
    "signer": [
      0
    ],
    "transaction": "dGVzdA==",
    "wallet_handle_token": "string",
    "wallet_password": "string"
  }'

const response = await fetch('https://algo.nownodes.io/v1/multisig/sign', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "partial_multisig": {
        "Subsigs": [
          {
            "Key": [
              0
            ],
            "Sig": [
              0
            ]
          }
        ],
        "Threshold": 0,
        "Version": 0
      },
      "public_key": [
        0
      ],
      "signer": [
        0
      ],
      "transaction": "dGVzdA==",
      "wallet_handle_token": "string",
      "wallet_password": "string"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v1/multisig/sign')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "partial_multisig": {
      "Subsigs": [
        {
          "Key": [
            0
          ],
          "Sig": [
            0
          ]
        }
      ],
      "Threshold": 0,
      "Version": 0
    },
    "public_key": [
      0
    ],
    "signer": [
      0
    ],
    "transaction": "dGVzdA==",
    "wallet_handle_token": "string",
    "wallet_password": "string"
  }'

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

import requests

payload = {
  "partial_multisig": {
    "Subsigs": [
      {
        "Key": [
          0
        ],
        "Sig": [
          0
        ]
      }
    ],
    "Threshold": 0,
    "Version": 0
  },
  "public_key": [
    0
  ],
  "signer": [
    0
  ],
  "transaction": "dGVzdA==",
  "wallet_handle_token": "string",
  "wallet_password": "string"
}

response = requests.post('https://algo.nownodes.io/v1/multisig/sign', json=payload)
data = response.json()

const response = await fetch('https://algo.nownodes.io/v1/multisig/sign', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "partial_multisig": {
        "Subsigs": [
          {
            "Key": [
              0
            ],
            "Sig": [
              0
            ]
          }
        ],
        "Threshold": 0,
        "Version": 0
      },
      "public_key": [
        0
      ],
      "signer": [
        0
      ],
      "transaction": "dGVzdA==",
      "wallet_handle_token": "string",
      "wallet_password": "string"
    }),
});

const data = await response.json();

const endpoint = "https://algo.nownodes.io/v1/multisig/sign";
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({
    "partial_multisig": {
      "Subsigs": [
        {
          "Key": [
            0
          ],
          "Sig": [
            0
          ]
        }
      ],
      "Threshold": 0,
      "Version": 0
    },
    "public_key": [
      0
    ],
    "signer": [
      0
    ],
    "transaction": "dGVzdA==",
    "wallet_handle_token": "string",
    "wallet_password": "string"
  });
console.log(result);

const response = await fetch('https://algo.nownodes.io/v1/multisig/sign', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "partial_multisig": {
        "Subsigs": [
          {
            "Key": [
              0
            ],
            "Sig": [
              0
            ]
          }
        ],
        "Threshold": 0,
        "Version": 0
      },
      "public_key": [
        0
      ],
      "signer": [
        0
      ],
      "transaction": "dGVzdA==",
      "wallet_handle_token": "string",
      "wallet_password": "string"
    }),
});

const data = await response.json();

import requests

payload = {
  "partial_multisig": {
    "Subsigs": [
      {
        "Key": [
          0
        ],
        "Sig": [
          0
        ]
      }
    ],
    "Threshold": 0,
    "Version": 0
  },
  "public_key": [
    0
  ],
  "signer": [
    0
  ],
  "transaction": "dGVzdA==",
  "wallet_handle_token": "string",
  "wallet_password": "string"
}

response = requests.post('https://algo.nownodes.io/v1/multisig/sign', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v1/multisig/sign')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "partial_multisig": {
      "Subsigs": [
        {
          "Key": [
            0
          ],
          "Sig": [
            0
          ]
        }
      ],
      "Threshold": 0,
      "Version": 0
    },
    "public_key": [
      0
    ],
    "signer": [
      0
    ],
    "transaction": "dGVzdA==",
    "wallet_handle_token": "string",
    "wallet_password": "string"
  }'

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

Request Body

{
  "partial_multisig": {
    "Subsigs": [
      {
        "Key": [
          0
        ],
        "Sig": [
          0
        ]
      }
    ],
    "Threshold": 0,
    "Version": 0
  },
  "public_key": [
    0
  ],
  "signer": [
    0
  ],
  "transaction": "dGVzdA==",
  "wallet_handle_token": "string",
  "wallet_password": "string"
}

200

{
  "error": true,
  "message": "string",
  "multisig": "dGVzdA=="
}

Sign a program for a multisig account

POST

https://algo.nownodes.io/v1/multisig/signprogram

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Start a multisig signature, or add a signature to a partially completed multisig signature object.

Body

application/json

APIV1POSTMultisigProgramSignRequest is the request for POST /v1/multisig/signprogram

addressstring

datastring<byte>

partial_multisigMultisigSig

MultisigSig is the structure that holds multiple Subsigs

Show child attributes

SubsigsArray<MultisigSubsig>

Show child attributes

KeyArray<integer>

SigArray<integer>

Thresholdinteger<uint8>

Versioninteger<uint8>

public_keyArray<integer>

wallet_handle_tokenstring

wallet_passwordstring

Response

200OK

Response to POST /v1/multisig/signdata

Sign a program for a multisig account

curl -X POST 'https://algo.nownodes.io/v1/multisig/signprogram' \
  -H 'Content-Type: application/json' \
  -d '{
    "address": "string",
    "data": "dGVzdA==",
    "partial_multisig": {
      "Subsigs": [
        {
          "Key": [
            0
          ],
          "Sig": [
            0
          ]
        }
      ],
      "Threshold": 0,
      "Version": 0
    },
    "public_key": [
      0
    ],
    "wallet_handle_token": "string",
    "wallet_password": "string"
  }'

const response = await fetch('https://algo.nownodes.io/v1/multisig/signprogram', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "address": "string",
      "data": "dGVzdA==",
      "partial_multisig": {
        "Subsigs": [
          {
            "Key": [
              0
            ],
            "Sig": [
              0
            ]
          }
        ],
        "Threshold": 0,
        "Version": 0
      },
      "public_key": [
        0
      ],
      "wallet_handle_token": "string",
      "wallet_password": "string"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v1/multisig/signprogram')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "address": "string",
    "data": "dGVzdA==",
    "partial_multisig": {
      "Subsigs": [
        {
          "Key": [
            0
          ],
          "Sig": [
            0
          ]
        }
      ],
      "Threshold": 0,
      "Version": 0
    },
    "public_key": [
      0
    ],
    "wallet_handle_token": "string",
    "wallet_password": "string"
  }'

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

import requests

payload = {
  "address": "string",
  "data": "dGVzdA==",
  "partial_multisig": {
    "Subsigs": [
      {
        "Key": [
          0
        ],
        "Sig": [
          0
        ]
      }
    ],
    "Threshold": 0,
    "Version": 0
  },
  "public_key": [
    0
  ],
  "wallet_handle_token": "string",
  "wallet_password": "string"
}

response = requests.post('https://algo.nownodes.io/v1/multisig/signprogram', json=payload)
data = response.json()

const response = await fetch('https://algo.nownodes.io/v1/multisig/signprogram', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "address": "string",
      "data": "dGVzdA==",
      "partial_multisig": {
        "Subsigs": [
          {
            "Key": [
              0
            ],
            "Sig": [
              0
            ]
          }
        ],
        "Threshold": 0,
        "Version": 0
      },
      "public_key": [
        0
      ],
      "wallet_handle_token": "string",
      "wallet_password": "string"
    }),
});

const data = await response.json();

const endpoint = "https://algo.nownodes.io/v1/multisig/signprogram";
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({
    "address": "string",
    "data": "dGVzdA==",
    "partial_multisig": {
      "Subsigs": [
        {
          "Key": [
            0
          ],
          "Sig": [
            0
          ]
        }
      ],
      "Threshold": 0,
      "Version": 0
    },
    "public_key": [
      0
    ],
    "wallet_handle_token": "string",
    "wallet_password": "string"
  });
console.log(result);

const response = await fetch('https://algo.nownodes.io/v1/multisig/signprogram', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "address": "string",
      "data": "dGVzdA==",
      "partial_multisig": {
        "Subsigs": [
          {
            "Key": [
              0
            ],
            "Sig": [
              0
            ]
          }
        ],
        "Threshold": 0,
        "Version": 0
      },
      "public_key": [
        0
      ],
      "wallet_handle_token": "string",
      "wallet_password": "string"
    }),
});

const data = await response.json();

import requests

payload = {
  "address": "string",
  "data": "dGVzdA==",
  "partial_multisig": {
    "Subsigs": [
      {
        "Key": [
          0
        ],
        "Sig": [
          0
        ]
      }
    ],
    "Threshold": 0,
    "Version": 0
  },
  "public_key": [
    0
  ],
  "wallet_handle_token": "string",
  "wallet_password": "string"
}

response = requests.post('https://algo.nownodes.io/v1/multisig/signprogram', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v1/multisig/signprogram')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "address": "string",
    "data": "dGVzdA==",
    "partial_multisig": {
      "Subsigs": [
        {
          "Key": [
            0
          ],
          "Sig": [
            0
          ]
        }
      ],
      "Threshold": 0,
      "Version": 0
    },
    "public_key": [
      0
    ],
    "wallet_handle_token": "string",
    "wallet_password": "string"
  }'

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

Request Body

{
  "address": "string",
  "data": "dGVzdA==",
  "partial_multisig": {
    "Subsigs": [
      {
        "Key": [
          0
        ],
        "Sig": [
          0
        ]
      }
    ],
    "Threshold": 0,
    "Version": 0
  },
  "public_key": [
    0
  ],
  "wallet_handle_token": "string",
  "wallet_password": "string"
}

200

{
  "error": true,
  "message": "string",
  "multisig": "dGVzdA=="
}

Program

Sign program

POST

https://algo.nownodes.io/v1/program/sign

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Signs the passed program with a key from the wallet, determined by the account named in the request.

Body

application/json

APIV1POSTProgramSignRequest is the request for POST /v1/program/sign

addressstring

datastring<byte>

wallet_handle_tokenstring

wallet_passwordstring

Response

200OK

Response to POST /v1/data/sign

Sign program

curl -X POST 'https://algo.nownodes.io/v1/program/sign' \
  -H 'Content-Type: application/json' \
  -d '{
    "address": "string",
    "data": "dGVzdA==",
    "wallet_handle_token": "string",
    "wallet_password": "string"
  }'

const response = await fetch('https://algo.nownodes.io/v1/program/sign', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "address": "string",
      "data": "dGVzdA==",
      "wallet_handle_token": "string",
      "wallet_password": "string"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v1/program/sign')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "address": "string",
    "data": "dGVzdA==",
    "wallet_handle_token": "string",
    "wallet_password": "string"
  }'

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

import requests

payload = {
  "address": "string",
  "data": "dGVzdA==",
  "wallet_handle_token": "string",
  "wallet_password": "string"
}

response = requests.post('https://algo.nownodes.io/v1/program/sign', json=payload)
data = response.json()

const response = await fetch('https://algo.nownodes.io/v1/program/sign', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "address": "string",
      "data": "dGVzdA==",
      "wallet_handle_token": "string",
      "wallet_password": "string"
    }),
});

const data = await response.json();

const endpoint = "https://algo.nownodes.io/v1/program/sign";
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({
    "address": "string",
    "data": "dGVzdA==",
    "wallet_handle_token": "string",
    "wallet_password": "string"
  });
console.log(result);

const response = await fetch('https://algo.nownodes.io/v1/program/sign', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "address": "string",
      "data": "dGVzdA==",
      "wallet_handle_token": "string",
      "wallet_password": "string"
    }),
});

const data = await response.json();

import requests

payload = {
  "address": "string",
  "data": "dGVzdA==",
  "wallet_handle_token": "string",
  "wallet_password": "string"
}

response = requests.post('https://algo.nownodes.io/v1/program/sign', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v1/program/sign')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "address": "string",
    "data": "dGVzdA==",
    "wallet_handle_token": "string",
    "wallet_password": "string"
  }'

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

Request Body

{
  "address": "string",
  "data": "dGVzdA==",
  "wallet_handle_token": "string",
  "wallet_password": "string"
}

200

{
  "error": true,
  "message": "string",
  "sig": "dGVzdA=="
}

Transaction

Sign a transaction

POST

https://algo.nownodes.io/v1/transaction/sign

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Signs the passed transaction with a key from the wallet, determined by the sender encoded in the transaction.

Body

application/json

APIV1POSTTransactionSignRequest is the request for POST /v1/transaction/sign

public_keyArray<integer>

transactionstring<byte>

Base64 encoding of msgpack encoding of a Transaction object Note: SDK and goal usually generate SignedTxn objects in that case, the field txn / Transaction of the generated SignedTxn object needs to be used

wallet_handle_tokenstring

wallet_passwordstring

Response

200OK

Response to POST /v1/transaction/sign

Sign a transaction

curl -X POST 'https://algo.nownodes.io/v1/transaction/sign' \
  -H 'Content-Type: application/json' \
  -d '{
    "public_key": [
      0
    ],
    "transaction": "dGVzdA==",
    "wallet_handle_token": "string",
    "wallet_password": "string"
  }'

const response = await fetch('https://algo.nownodes.io/v1/transaction/sign', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "public_key": [
        0
      ],
      "transaction": "dGVzdA==",
      "wallet_handle_token": "string",
      "wallet_password": "string"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v1/transaction/sign')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "public_key": [
      0
    ],
    "transaction": "dGVzdA==",
    "wallet_handle_token": "string",
    "wallet_password": "string"
  }'

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

import requests

payload = {
  "public_key": [
    0
  ],
  "transaction": "dGVzdA==",
  "wallet_handle_token": "string",
  "wallet_password": "string"
}

response = requests.post('https://algo.nownodes.io/v1/transaction/sign', json=payload)
data = response.json()

const response = await fetch('https://algo.nownodes.io/v1/transaction/sign', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "public_key": [
        0
      ],
      "transaction": "dGVzdA==",
      "wallet_handle_token": "string",
      "wallet_password": "string"
    }),
});

const data = await response.json();

const endpoint = "https://algo.nownodes.io/v1/transaction/sign";
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({
    "public_key": [
      0
    ],
    "transaction": "dGVzdA==",
    "wallet_handle_token": "string",
    "wallet_password": "string"
  });
console.log(result);

const response = await fetch('https://algo.nownodes.io/v1/transaction/sign', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "public_key": [
        0
      ],
      "transaction": "dGVzdA==",
      "wallet_handle_token": "string",
      "wallet_password": "string"
    }),
});

const data = await response.json();

import requests

payload = {
  "public_key": [
    0
  ],
  "transaction": "dGVzdA==",
  "wallet_handle_token": "string",
  "wallet_password": "string"
}

response = requests.post('https://algo.nownodes.io/v1/transaction/sign', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v1/transaction/sign')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "public_key": [
      0
    ],
    "transaction": "dGVzdA==",
    "wallet_handle_token": "string",
    "wallet_password": "string"
  }'

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

Request Body

{
  "public_key": [
    0
  ],
  "transaction": "dGVzdA==",
  "wallet_handle_token": "string",
  "wallet_password": "string"
}

200

{
  "error": true,
  "message": "string",
  "signed_transaction": "dGVzdA=="
}

Wallet

Create a wallet

POST

https://algo.nownodes.io/v1/wallet

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Create a new wallet (collection of keys) with the given parameters.

Body

application/json

APIV1POSTWalletRequest is the request for POST /v1/wallet

master_derivation_keyArray<integer>

MasterDerivationKey is used to derive ed25519 keys for use in wallets

wallet_driver_namestring

wallet_namestring

wallet_passwordstring

Response

200OK

Response to POST /v1/wallet

Create a wallet

curl -X POST 'https://algo.nownodes.io/v1/wallet' \
  -H 'Content-Type: application/json' \
  -d '{
    "master_derivation_key": [
      0
    ],
    "wallet_driver_name": "string",
    "wallet_name": "string",
    "wallet_password": "string"
  }'

const response = await fetch('https://algo.nownodes.io/v1/wallet', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "master_derivation_key": [
        0
      ],
      "wallet_driver_name": "string",
      "wallet_name": "string",
      "wallet_password": "string"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v1/wallet')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "master_derivation_key": [
      0
    ],
    "wallet_driver_name": "string",
    "wallet_name": "string",
    "wallet_password": "string"
  }'

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

import requests

payload = {
  "master_derivation_key": [
    0
  ],
  "wallet_driver_name": "string",
  "wallet_name": "string",
  "wallet_password": "string"
}

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

const response = await fetch('https://algo.nownodes.io/v1/wallet', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "master_derivation_key": [
        0
      ],
      "wallet_driver_name": "string",
      "wallet_name": "string",
      "wallet_password": "string"
    }),
});

const data = await response.json();

const endpoint = "https://algo.nownodes.io/v1/wallet";
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({
    "master_derivation_key": [
      0
    ],
    "wallet_driver_name": "string",
    "wallet_name": "string",
    "wallet_password": "string"
  });
console.log(result);

const response = await fetch('https://algo.nownodes.io/v1/wallet', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "master_derivation_key": [
        0
      ],
      "wallet_driver_name": "string",
      "wallet_name": "string",
      "wallet_password": "string"
    }),
});

const data = await response.json();

import requests

payload = {
  "master_derivation_key": [
    0
  ],
  "wallet_driver_name": "string",
  "wallet_name": "string",
  "wallet_password": "string"
}

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

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v1/wallet')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "master_derivation_key": [
      0
    ],
    "wallet_driver_name": "string",
    "wallet_name": "string",
    "wallet_password": "string"
  }'

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

Request Body

{
  "master_derivation_key": [
    0
  ],
  "wallet_driver_name": "string",
  "wallet_name": "string",
  "wallet_password": "string"
}

200

{
  "error": true,
  "message": "string",
  "wallet": {
    "driver_name": "string",
    "driver_version": 0,
    "id": "string",
    "mnemonic_ux": true,
    "name": "string",
    "supported_txs": [
      "string"
    ]
  }
}

Get wallet info

POST

https://algo.nownodes.io/v1/wallet/info

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns information about the wallet associated with the passed wallet handle token. Additionally returns expiration information about the token itself.

Body

application/json

APIV1POSTWalletInfoRequest is the request for POST /v1/wallet/info

wallet_handle_tokenstring

Response

200OK

Response to POST /v1/wallet/info

Get wallet info

curl -X POST 'https://algo.nownodes.io/v1/wallet/info' \
  -H 'Content-Type: application/json' \
  -d '{
    "wallet_handle_token": "string"
  }'

const response = await fetch('https://algo.nownodes.io/v1/wallet/info', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "wallet_handle_token": "string"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v1/wallet/info')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "wallet_handle_token": "string"
  }'

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

import requests

payload = {
  "wallet_handle_token": "string"
}

response = requests.post('https://algo.nownodes.io/v1/wallet/info', json=payload)
data = response.json()

const response = await fetch('https://algo.nownodes.io/v1/wallet/info', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "wallet_handle_token": "string"
    }),
});

const data = await response.json();

const endpoint = "https://algo.nownodes.io/v1/wallet/info";
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({
    "wallet_handle_token": "string"
  });
console.log(result);

const response = await fetch('https://algo.nownodes.io/v1/wallet/info', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "wallet_handle_token": "string"
    }),
});

const data = await response.json();

import requests

payload = {
  "wallet_handle_token": "string"
}

response = requests.post('https://algo.nownodes.io/v1/wallet/info', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v1/wallet/info')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "wallet_handle_token": "string"
  }'

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

Request Body

{
  "wallet_handle_token": "string"
}

200

{
  "error": true,
  "message": "string",
  "wallet_handle": {
    "expires_seconds": 0,
    "wallet": {
      "driver_name": "string",
      "driver_version": 0,
      "id": "string",
      "mnemonic_ux": true,
      "name": "string",
      "supported_txs": [
        "string"
      ]
    }
  }
}

Initialize a wallet handle token

POST

https://algo.nownodes.io/v1/wallet/init

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Unlock the wallet and return a wallet handle token that can be used for subsequent operations. These tokens expire periodically and must be renewed. You can POST the token to /v1/wallet/info to see how much time remains until expiration, and renew it with /v1/wallet/renew. When you're done, you can invalidate the token with /v1/wallet/release.

Body

application/json

APIV1POSTWalletInitRequest is the request for POST /v1/wallet/init

wallet_idstring

wallet_passwordstring

Response

200OK

Response to POST /v1/wallet/init

Initialize a wallet handle token

curl -X POST 'https://algo.nownodes.io/v1/wallet/init' \
  -H 'Content-Type: application/json' \
  -d '{
    "wallet_id": "string",
    "wallet_password": "string"
  }'

const response = await fetch('https://algo.nownodes.io/v1/wallet/init', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "wallet_id": "string",
      "wallet_password": "string"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v1/wallet/init')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "wallet_id": "string",
    "wallet_password": "string"
  }'

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

import requests

payload = {
  "wallet_id": "string",
  "wallet_password": "string"
}

response = requests.post('https://algo.nownodes.io/v1/wallet/init', json=payload)
data = response.json()

const response = await fetch('https://algo.nownodes.io/v1/wallet/init', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "wallet_id": "string",
      "wallet_password": "string"
    }),
});

const data = await response.json();

const endpoint = "https://algo.nownodes.io/v1/wallet/init";
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({
    "wallet_id": "string",
    "wallet_password": "string"
  });
console.log(result);

const response = await fetch('https://algo.nownodes.io/v1/wallet/init', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "wallet_id": "string",
      "wallet_password": "string"
    }),
});

const data = await response.json();

import requests

payload = {
  "wallet_id": "string",
  "wallet_password": "string"
}

response = requests.post('https://algo.nownodes.io/v1/wallet/init', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v1/wallet/init')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "wallet_id": "string",
    "wallet_password": "string"
  }'

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

Request Body

{
  "wallet_id": "string",
  "wallet_password": "string"
}

200

{
  "error": true,
  "message": "string",
  "wallet_handle_token": "string"
}

Release a wallet handle token

POST

https://algo.nownodes.io/v1/wallet/release

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Invalidate the passed wallet handle token, making it invalid for use in subsequent requests.

Body

application/json

APIV1POSTWalletReleaseRequest is the request for POST /v1/wallet/release

wallet_handle_tokenstring

Response

200OK

Response to POST /v1/wallet/release

Release a wallet handle token

curl -X POST 'https://algo.nownodes.io/v1/wallet/release' \
  -H 'Content-Type: application/json' \
  -d '{
    "wallet_handle_token": "string"
  }'

const response = await fetch('https://algo.nownodes.io/v1/wallet/release', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "wallet_handle_token": "string"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v1/wallet/release')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "wallet_handle_token": "string"
  }'

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

import requests

payload = {
  "wallet_handle_token": "string"
}

response = requests.post('https://algo.nownodes.io/v1/wallet/release', json=payload)
data = response.json()

const response = await fetch('https://algo.nownodes.io/v1/wallet/release', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "wallet_handle_token": "string"
    }),
});

const data = await response.json();

const endpoint = "https://algo.nownodes.io/v1/wallet/release";
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({
    "wallet_handle_token": "string"
  });
console.log(result);

const response = await fetch('https://algo.nownodes.io/v1/wallet/release', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "wallet_handle_token": "string"
    }),
});

const data = await response.json();

import requests

payload = {
  "wallet_handle_token": "string"
}

response = requests.post('https://algo.nownodes.io/v1/wallet/release', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v1/wallet/release')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "wallet_handle_token": "string"
  }'

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

Request Body

{
  "wallet_handle_token": "string"
}

200

{
  "error": true,
  "message": "string"
}

Rename a wallet

POST

https://algo.nownodes.io/v1/wallet/rename

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Rename the underlying wallet to something else

Body

application/json

APIV1POSTWalletRenameRequest is the request for POST /v1/wallet/rename

wallet_idstring

wallet_namestring

wallet_passwordstring

Response

200OK

Response to POST /v1/wallet/rename

Rename a wallet

curl -X POST 'https://algo.nownodes.io/v1/wallet/rename' \
  -H 'Content-Type: application/json' \
  -d '{
    "wallet_id": "string",
    "wallet_name": "string",
    "wallet_password": "string"
  }'

const response = await fetch('https://algo.nownodes.io/v1/wallet/rename', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "wallet_id": "string",
      "wallet_name": "string",
      "wallet_password": "string"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v1/wallet/rename')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "wallet_id": "string",
    "wallet_name": "string",
    "wallet_password": "string"
  }'

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

import requests

payload = {
  "wallet_id": "string",
  "wallet_name": "string",
  "wallet_password": "string"
}

response = requests.post('https://algo.nownodes.io/v1/wallet/rename', json=payload)
data = response.json()

const response = await fetch('https://algo.nownodes.io/v1/wallet/rename', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "wallet_id": "string",
      "wallet_name": "string",
      "wallet_password": "string"
    }),
});

const data = await response.json();

const endpoint = "https://algo.nownodes.io/v1/wallet/rename";
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({
    "wallet_id": "string",
    "wallet_name": "string",
    "wallet_password": "string"
  });
console.log(result);

const response = await fetch('https://algo.nownodes.io/v1/wallet/rename', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "wallet_id": "string",
      "wallet_name": "string",
      "wallet_password": "string"
    }),
});

const data = await response.json();

import requests

payload = {
  "wallet_id": "string",
  "wallet_name": "string",
  "wallet_password": "string"
}

response = requests.post('https://algo.nownodes.io/v1/wallet/rename', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v1/wallet/rename')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "wallet_id": "string",
    "wallet_name": "string",
    "wallet_password": "string"
  }'

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

Request Body

{
  "wallet_id": "string",
  "wallet_name": "string",
  "wallet_password": "string"
}

200

{
  "error": true,
  "message": "string",
  "wallet": {
    "driver_name": "string",
    "driver_version": 0,
    "id": "string",
    "mnemonic_ux": true,
    "name": "string",
    "supported_txs": [
      "string"
    ]
  }
}

Renew a wallet handle token

POST

https://algo.nownodes.io/v1/wallet/renew

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Renew a wallet handle token, increasing its expiration duration to its initial value

Body

application/json

APIV1POSTWalletRenewRequest is the request for POST /v1/wallet/renew

wallet_handle_tokenstring

Response

200OK

Response POST /v1/wallet/renew

Renew a wallet handle token

curl -X POST 'https://algo.nownodes.io/v1/wallet/renew' \
  -H 'Content-Type: application/json' \
  -d '{
    "wallet_handle_token": "string"
  }'

const response = await fetch('https://algo.nownodes.io/v1/wallet/renew', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "wallet_handle_token": "string"
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v1/wallet/renew')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "wallet_handle_token": "string"
  }'

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

import requests

payload = {
  "wallet_handle_token": "string"
}

response = requests.post('https://algo.nownodes.io/v1/wallet/renew', json=payload)
data = response.json()

const response = await fetch('https://algo.nownodes.io/v1/wallet/renew', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "wallet_handle_token": "string"
    }),
});

const data = await response.json();

const endpoint = "https://algo.nownodes.io/v1/wallet/renew";
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({
    "wallet_handle_token": "string"
  });
console.log(result);

const response = await fetch('https://algo.nownodes.io/v1/wallet/renew', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "wallet_handle_token": "string"
    }),
});

const data = await response.json();

import requests

payload = {
  "wallet_handle_token": "string"
}

response = requests.post('https://algo.nownodes.io/v1/wallet/renew', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v1/wallet/renew')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "wallet_handle_token": "string"
  }'

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

Request Body

{
  "wallet_handle_token": "string"
}

200

{
  "error": true,
  "message": "string",
  "wallet_handle": {
    "expires_seconds": 0,
    "wallet": {
      "driver_name": "string",
      "driver_version": 0,
      "id": "string",
      "mnemonic_ux": true,
      "name": "string",
      "supported_txs": [
        "string"
      ]
    }
  }
}

Wallets

List wallets

GET

https://algo.nownodes.io/v1/wallets

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Lists all of the wallets that kmd is aware of.

Body

application/json

APIV1GETWalletsRequest is the request for GET /v1/wallets

ListWalletsRequest

Response

200OK

Response to GET /v1/wallets

List wallets

curl -X GET 'https://algo.nownodes.io/v1/wallets' \
  -H 'Content-Type: application/json' \
  -d '{}'

const response = await fetch('https://algo.nownodes.io/v1/wallets', {
  method: 'GET',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({}),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v1/wallets')
request = Net::HTTP::Get.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{}'

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

import requests

payload = {}

response = requests.get('https://algo.nownodes.io/v1/wallets', json=payload)
data = response.json()

const response = await fetch('https://algo.nownodes.io/v1/wallets', {
  method: 'GET',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({}),
});

const data = await response.json();

const endpoint = "https://algo.nownodes.io/v1/wallets";
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/v1/wallets', {
  method: 'GET',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({}),
});

const data = await response.json();

import requests

payload = {}

response = requests.get('https://algo.nownodes.io/v1/wallets', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/v1/wallets')
request = Net::HTTP::Get.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{}'

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

Request Body

{}

200

{
  "error": true,
  "message": "string",
  "wallets": [
    {
      "driver_name": "string",
      "driver_version": 0,
      "id": "string",
      "mnemonic_ux": true,
      "name": "string",
      "supported_txs": [
        "string"
      ]
    }
  ]
}

Versions

Retrieves the current version

GET

https://algo.nownodes.io/versions

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Body

application/json

VersionsRequest is the request for GET /versions

VersionsRequest

Response

200OK

Response to GET /versions

Retrieves the current version

curl -X GET 'https://algo.nownodes.io/versions' \
  -H 'Content-Type: application/json' \
  -d '{}'

const response = await fetch('https://algo.nownodes.io/versions', {
  method: 'GET',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({}),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/versions')
request = Net::HTTP::Get.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{}'

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

import requests

payload = {}

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

const response = await fetch('https://algo.nownodes.io/versions', {
  method: 'GET',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({}),
});

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',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({}),
});

const data = await response.json();

import requests

payload = {}

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

require 'net/http'
require 'json'

uri = URI('https://algo.nownodes.io/versions')
request = Net::HTTP::Get.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{}'

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

Request Body

{}

200

{
  "versions": [
    "string"
  ]
}

Documentation

How to migrate to NOWNodes

Authentication

API Reference

Swagger

Authorizations

Response

Key

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Master-key

Authorizations

Body

Response

Multisig

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Program

Authorizations

Body

Response

Transaction

Authorizations

Body

Response

Wallet

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Authorizations

Body

Response

Wallets

Authorizations

Body

Response

Versions

Authorizations

Body

Response