Neblio REST API Suite

POST Broadcasts a signed raw transaction to the network (not NTP1 specific)

{{baseUrl}}/ins/tx/send

BODY json

{
  "rawtx": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/ins/tx/send");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"rawtx\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/ins/tx/send" {:content-type :json
                                                        :form-params {:rawtx ""}})

require "http/client"

url = "{{baseUrl}}/ins/tx/send"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"rawtx\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/ins/tx/send"),
    Content = new StringContent("{\n  \"rawtx\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/ins/tx/send");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"rawtx\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/ins/tx/send"

	payload := strings.NewReader("{\n  \"rawtx\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ins/tx/send HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 17

{
  "rawtx": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/ins/tx/send")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"rawtx\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/ins/tx/send"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"rawtx\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"rawtx\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/ins/tx/send")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/ins/tx/send")
  .header("content-type", "application/json")
  .body("{\n  \"rawtx\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  rawtx: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/ins/tx/send');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/ins/tx/send',
  headers: {'content-type': 'application/json'},
  data: {rawtx: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/ins/tx/send';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"rawtx":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/ins/tx/send',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "rawtx": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"rawtx\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/ins/tx/send")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/ins/tx/send',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({rawtx: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/ins/tx/send',
  headers: {'content-type': 'application/json'},
  body: {rawtx: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/ins/tx/send');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  rawtx: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/ins/tx/send',
  headers: {'content-type': 'application/json'},
  data: {rawtx: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/ins/tx/send';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"rawtx":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"rawtx": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/ins/tx/send"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/ins/tx/send" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"rawtx\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/ins/tx/send",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'rawtx' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/ins/tx/send', [
  'body' => '{
  "rawtx": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/ins/tx/send');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'rawtx' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'rawtx' => ''
]));
$request->setRequestUrl('{{baseUrl}}/ins/tx/send');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/ins/tx/send' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "rawtx": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/ins/tx/send' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "rawtx": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"rawtx\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/ins/tx/send", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/ins/tx/send"

payload = { "rawtx": "" }
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/ins/tx/send"

payload <- "{\n  \"rawtx\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/ins/tx/send")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"rawtx\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/ins/tx/send') do |req|
  req.body = "{\n  \"rawtx\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/ins/tx/send";

    let payload = json!({"rawtx": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/ins/tx/send \
  --header 'content-type: application/json' \
  --data '{
  "rawtx": ""
}'

echo '{
  "rawtx": ""
}' |  \
  http POST {{baseUrl}}/ins/tx/send \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "rawtx": ""\n}' \
  --output-document \
  - {{baseUrl}}/ins/tx/send

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["rawtx": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/ins/tx/send")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Get node sync status

{{baseUrl}}/ins/sync

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/ins/sync");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/ins/sync")

require "http/client"

url = "{{baseUrl}}/ins/sync"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/ins/sync"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/ins/sync");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/ins/sync"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/ins/sync HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/ins/sync")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/ins/sync"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/ins/sync")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/ins/sync")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/ins/sync');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/ins/sync'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/ins/sync';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/ins/sync',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/ins/sync")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/ins/sync',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/ins/sync'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/ins/sync');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/ins/sync'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/ins/sync';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/ins/sync"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/ins/sync" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/ins/sync",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/ins/sync');

echo $response->getBody();

setUrl('{{baseUrl}}/ins/sync');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/ins/sync');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/ins/sync' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/ins/sync' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/ins/sync")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/ins/sync"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/ins/sync"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/ins/sync")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/ins/sync') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/ins/sync";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/ins/sync

http GET {{baseUrl}}/ins/sync

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/ins/sync

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/ins/sync")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Get transactions by block or address

{{baseUrl}}/ins/txs

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/ins/txs");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/ins/txs")

require "http/client"

url = "{{baseUrl}}/ins/txs"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/ins/txs"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/ins/txs");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/ins/txs"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/ins/txs HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/ins/txs")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/ins/txs"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/ins/txs")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/ins/txs")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/ins/txs');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/ins/txs'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/ins/txs';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/ins/txs',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/ins/txs")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/ins/txs',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/ins/txs'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/ins/txs');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/ins/txs'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/ins/txs';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/ins/txs"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/ins/txs" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/ins/txs",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/ins/txs');

echo $response->getBody();

setUrl('{{baseUrl}}/ins/txs');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/ins/txs');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/ins/txs' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/ins/txs' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/ins/txs")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/ins/txs"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/ins/txs"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/ins/txs")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/ins/txs') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/ins/txs";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/ins/txs

http GET {{baseUrl}}/ins/txs

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/ins/txs

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/ins/txs")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Returns address balance in sats

{{baseUrl}}/ins/addr/:address/balance

QUERY PARAMS

address

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/ins/addr/:address/balance");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/ins/addr/:address/balance")

require "http/client"

url = "{{baseUrl}}/ins/addr/:address/balance"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/ins/addr/:address/balance"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/ins/addr/:address/balance");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/ins/addr/:address/balance"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/ins/addr/:address/balance HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/ins/addr/:address/balance")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/ins/addr/:address/balance"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/ins/addr/:address/balance")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/ins/addr/:address/balance")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/ins/addr/:address/balance');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/ins/addr/:address/balance'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/ins/addr/:address/balance';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/ins/addr/:address/balance',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/ins/addr/:address/balance")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/ins/addr/:address/balance',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/ins/addr/:address/balance'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/ins/addr/:address/balance');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/ins/addr/:address/balance'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/ins/addr/:address/balance';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/ins/addr/:address/balance"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/ins/addr/:address/balance" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/ins/addr/:address/balance",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/ins/addr/:address/balance');

echo $response->getBody();

setUrl('{{baseUrl}}/ins/addr/:address/balance');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/ins/addr/:address/balance');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/ins/addr/:address/balance' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/ins/addr/:address/balance' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/ins/addr/:address/balance")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/ins/addr/:address/balance"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/ins/addr/:address/balance"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/ins/addr/:address/balance")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/ins/addr/:address/balance') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/ins/addr/:address/balance";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/ins/addr/:address/balance

http GET {{baseUrl}}/ins/addr/:address/balance

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/ins/addr/:address/balance

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/ins/addr/:address/balance")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Returns address object

{{baseUrl}}/ins/addr/:address

QUERY PARAMS

address

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/ins/addr/:address");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/ins/addr/:address")

require "http/client"

url = "{{baseUrl}}/ins/addr/:address"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/ins/addr/:address"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/ins/addr/:address");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/ins/addr/:address"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/ins/addr/:address HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/ins/addr/:address")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/ins/addr/:address"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/ins/addr/:address")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/ins/addr/:address")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/ins/addr/:address');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/ins/addr/:address'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/ins/addr/:address';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/ins/addr/:address',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/ins/addr/:address")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/ins/addr/:address',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/ins/addr/:address'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/ins/addr/:address');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/ins/addr/:address'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/ins/addr/:address';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/ins/addr/:address"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/ins/addr/:address" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/ins/addr/:address",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/ins/addr/:address');

echo $response->getBody();

setUrl('{{baseUrl}}/ins/addr/:address');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/ins/addr/:address');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/ins/addr/:address' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/ins/addr/:address' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/ins/addr/:address")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/ins/addr/:address"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/ins/addr/:address"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/ins/addr/:address")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/ins/addr/:address') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/ins/addr/:address";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/ins/addr/:address

http GET {{baseUrl}}/ins/addr/:address

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/ins/addr/:address

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/ins/addr/:address")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Returns address unconfirmed balance in sats

{{baseUrl}}/ins/addr/:address/unconfirmedBalance

QUERY PARAMS

address

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/ins/addr/:address/unconfirmedBalance");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/ins/addr/:address/unconfirmedBalance")

require "http/client"

url = "{{baseUrl}}/ins/addr/:address/unconfirmedBalance"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/ins/addr/:address/unconfirmedBalance"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/ins/addr/:address/unconfirmedBalance");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/ins/addr/:address/unconfirmedBalance"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/ins/addr/:address/unconfirmedBalance HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/ins/addr/:address/unconfirmedBalance")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/ins/addr/:address/unconfirmedBalance"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/ins/addr/:address/unconfirmedBalance")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/ins/addr/:address/unconfirmedBalance")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/ins/addr/:address/unconfirmedBalance');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/ins/addr/:address/unconfirmedBalance'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/ins/addr/:address/unconfirmedBalance';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/ins/addr/:address/unconfirmedBalance',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/ins/addr/:address/unconfirmedBalance")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/ins/addr/:address/unconfirmedBalance',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/ins/addr/:address/unconfirmedBalance'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/ins/addr/:address/unconfirmedBalance');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/ins/addr/:address/unconfirmedBalance'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/ins/addr/:address/unconfirmedBalance';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/ins/addr/:address/unconfirmedBalance"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/ins/addr/:address/unconfirmedBalance" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/ins/addr/:address/unconfirmedBalance",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/ins/addr/:address/unconfirmedBalance');

echo $response->getBody();

setUrl('{{baseUrl}}/ins/addr/:address/unconfirmedBalance');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/ins/addr/:address/unconfirmedBalance');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/ins/addr/:address/unconfirmedBalance' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/ins/addr/:address/unconfirmedBalance' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/ins/addr/:address/unconfirmedBalance")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/ins/addr/:address/unconfirmedBalance"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/ins/addr/:address/unconfirmedBalance"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/ins/addr/:address/unconfirmedBalance")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/ins/addr/:address/unconfirmedBalance') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/ins/addr/:address/unconfirmedBalance";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/ins/addr/:address/unconfirmedBalance

http GET {{baseUrl}}/ins/addr/:address/unconfirmedBalance

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/ins/addr/:address/unconfirmedBalance

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/ins/addr/:address/unconfirmedBalance")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Returns all UTXOs at a given address

{{baseUrl}}/ins/addr/:address/utxo

QUERY PARAMS

address

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/ins/addr/:address/utxo");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/ins/addr/:address/utxo")

require "http/client"

url = "{{baseUrl}}/ins/addr/:address/utxo"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/ins/addr/:address/utxo"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/ins/addr/:address/utxo");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/ins/addr/:address/utxo"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/ins/addr/:address/utxo HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/ins/addr/:address/utxo")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/ins/addr/:address/utxo"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/ins/addr/:address/utxo")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/ins/addr/:address/utxo")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/ins/addr/:address/utxo');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/ins/addr/:address/utxo'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/ins/addr/:address/utxo';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/ins/addr/:address/utxo',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/ins/addr/:address/utxo")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/ins/addr/:address/utxo',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/ins/addr/:address/utxo'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/ins/addr/:address/utxo');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/ins/addr/:address/utxo'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/ins/addr/:address/utxo';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/ins/addr/:address/utxo"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/ins/addr/:address/utxo" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/ins/addr/:address/utxo",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/ins/addr/:address/utxo');

echo $response->getBody();

setUrl('{{baseUrl}}/ins/addr/:address/utxo');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/ins/addr/:address/utxo');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/ins/addr/:address/utxo' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/ins/addr/:address/utxo' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/ins/addr/:address/utxo")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/ins/addr/:address/utxo"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/ins/addr/:address/utxo"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/ins/addr/:address/utxo")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/ins/addr/:address/utxo') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/ins/addr/:address/utxo";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/ins/addr/:address/utxo

http GET {{baseUrl}}/ins/addr/:address/utxo

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/ins/addr/:address/utxo

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/ins/addr/:address/utxo")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Returns block hash of block

{{baseUrl}}/ins/block-index/:blockindex

QUERY PARAMS

blockindex

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/ins/block-index/:blockindex");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/ins/block-index/:blockindex")

require "http/client"

url = "{{baseUrl}}/ins/block-index/:blockindex"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/ins/block-index/:blockindex"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/ins/block-index/:blockindex");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/ins/block-index/:blockindex"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/ins/block-index/:blockindex HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/ins/block-index/:blockindex")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/ins/block-index/:blockindex"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/ins/block-index/:blockindex")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/ins/block-index/:blockindex")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/ins/block-index/:blockindex');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/ins/block-index/:blockindex'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/ins/block-index/:blockindex';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/ins/block-index/:blockindex',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/ins/block-index/:blockindex")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/ins/block-index/:blockindex',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/ins/block-index/:blockindex'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/ins/block-index/:blockindex');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/ins/block-index/:blockindex'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/ins/block-index/:blockindex';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/ins/block-index/:blockindex"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/ins/block-index/:blockindex" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/ins/block-index/:blockindex",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/ins/block-index/:blockindex');

echo $response->getBody();

setUrl('{{baseUrl}}/ins/block-index/:blockindex');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/ins/block-index/:blockindex');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/ins/block-index/:blockindex' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/ins/block-index/:blockindex' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/ins/block-index/:blockindex")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/ins/block-index/:blockindex"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/ins/block-index/:blockindex"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/ins/block-index/:blockindex")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/ins/block-index/:blockindex') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/ins/block-index/:blockindex";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/ins/block-index/:blockindex

http GET {{baseUrl}}/ins/block-index/:blockindex

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/ins/block-index/:blockindex

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/ins/block-index/:blockindex")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Returns information regarding a Neblio block

{{baseUrl}}/ins/block/:blockhash

QUERY PARAMS

blockhash

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/ins/block/:blockhash");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/ins/block/:blockhash")

require "http/client"

url = "{{baseUrl}}/ins/block/:blockhash"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/ins/block/:blockhash"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/ins/block/:blockhash");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/ins/block/:blockhash"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/ins/block/:blockhash HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/ins/block/:blockhash")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/ins/block/:blockhash"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/ins/block/:blockhash")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/ins/block/:blockhash")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/ins/block/:blockhash');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/ins/block/:blockhash'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/ins/block/:blockhash';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/ins/block/:blockhash',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/ins/block/:blockhash")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/ins/block/:blockhash',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/ins/block/:blockhash'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/ins/block/:blockhash');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/ins/block/:blockhash'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/ins/block/:blockhash';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/ins/block/:blockhash"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/ins/block/:blockhash" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/ins/block/:blockhash",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/ins/block/:blockhash');

echo $response->getBody();

setUrl('{{baseUrl}}/ins/block/:blockhash');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/ins/block/:blockhash');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/ins/block/:blockhash' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/ins/block/:blockhash' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/ins/block/:blockhash")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/ins/block/:blockhash"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/ins/block/:blockhash"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/ins/block/:blockhash")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/ins/block/:blockhash') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/ins/block/:blockhash";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/ins/block/:blockhash

http GET {{baseUrl}}/ins/block/:blockhash

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/ins/block/:blockhash

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/ins/block/:blockhash")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Returns raw transaction hex

{{baseUrl}}/ins/rawtx/:txid

QUERY PARAMS

txid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/ins/rawtx/:txid");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/ins/rawtx/:txid")

require "http/client"

url = "{{baseUrl}}/ins/rawtx/:txid"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/ins/rawtx/:txid"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/ins/rawtx/:txid");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/ins/rawtx/:txid"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/ins/rawtx/:txid HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/ins/rawtx/:txid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/ins/rawtx/:txid"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/ins/rawtx/:txid")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/ins/rawtx/:txid")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/ins/rawtx/:txid');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/ins/rawtx/:txid'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/ins/rawtx/:txid';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/ins/rawtx/:txid',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/ins/rawtx/:txid")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/ins/rawtx/:txid',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/ins/rawtx/:txid'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/ins/rawtx/:txid');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/ins/rawtx/:txid'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/ins/rawtx/:txid';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/ins/rawtx/:txid"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/ins/rawtx/:txid" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/ins/rawtx/:txid",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/ins/rawtx/:txid');

echo $response->getBody();

setUrl('{{baseUrl}}/ins/rawtx/:txid');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/ins/rawtx/:txid');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/ins/rawtx/:txid' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/ins/rawtx/:txid' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/ins/rawtx/:txid")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/ins/rawtx/:txid"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/ins/rawtx/:txid"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/ins/rawtx/:txid")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/ins/rawtx/:txid') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/ins/rawtx/:txid";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/ins/rawtx/:txid

http GET {{baseUrl}}/ins/rawtx/:txid

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/ins/rawtx/:txid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/ins/rawtx/:txid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Returns total received by address in sats

{{baseUrl}}/ins/addr/:address/totalReceived

QUERY PARAMS

address

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/ins/addr/:address/totalReceived");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/ins/addr/:address/totalReceived")

require "http/client"

url = "{{baseUrl}}/ins/addr/:address/totalReceived"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/ins/addr/:address/totalReceived"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/ins/addr/:address/totalReceived");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/ins/addr/:address/totalReceived"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/ins/addr/:address/totalReceived HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/ins/addr/:address/totalReceived")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/ins/addr/:address/totalReceived"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/ins/addr/:address/totalReceived")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/ins/addr/:address/totalReceived")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/ins/addr/:address/totalReceived');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/ins/addr/:address/totalReceived'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/ins/addr/:address/totalReceived';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/ins/addr/:address/totalReceived',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/ins/addr/:address/totalReceived")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/ins/addr/:address/totalReceived',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/ins/addr/:address/totalReceived'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/ins/addr/:address/totalReceived');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/ins/addr/:address/totalReceived'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/ins/addr/:address/totalReceived';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/ins/addr/:address/totalReceived"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/ins/addr/:address/totalReceived" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/ins/addr/:address/totalReceived",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/ins/addr/:address/totalReceived');

echo $response->getBody();

setUrl('{{baseUrl}}/ins/addr/:address/totalReceived');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/ins/addr/:address/totalReceived');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/ins/addr/:address/totalReceived' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/ins/addr/:address/totalReceived' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/ins/addr/:address/totalReceived")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/ins/addr/:address/totalReceived"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/ins/addr/:address/totalReceived"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/ins/addr/:address/totalReceived")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/ins/addr/:address/totalReceived') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/ins/addr/:address/totalReceived";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/ins/addr/:address/totalReceived

http GET {{baseUrl}}/ins/addr/:address/totalReceived

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/ins/addr/:address/totalReceived

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/ins/addr/:address/totalReceived")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Returns total sent by address in sats

{{baseUrl}}/ins/addr/:address/totalSent

QUERY PARAMS

address

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/ins/addr/:address/totalSent");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/ins/addr/:address/totalSent")

require "http/client"

url = "{{baseUrl}}/ins/addr/:address/totalSent"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/ins/addr/:address/totalSent"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/ins/addr/:address/totalSent");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/ins/addr/:address/totalSent"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/ins/addr/:address/totalSent HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/ins/addr/:address/totalSent")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/ins/addr/:address/totalSent"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/ins/addr/:address/totalSent")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/ins/addr/:address/totalSent")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/ins/addr/:address/totalSent');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/ins/addr/:address/totalSent'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/ins/addr/:address/totalSent';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/ins/addr/:address/totalSent',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/ins/addr/:address/totalSent")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/ins/addr/:address/totalSent',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/ins/addr/:address/totalSent'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/ins/addr/:address/totalSent');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/ins/addr/:address/totalSent'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/ins/addr/:address/totalSent';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/ins/addr/:address/totalSent"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/ins/addr/:address/totalSent" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/ins/addr/:address/totalSent",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/ins/addr/:address/totalSent');

echo $response->getBody();

setUrl('{{baseUrl}}/ins/addr/:address/totalSent');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/ins/addr/:address/totalSent');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/ins/addr/:address/totalSent' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/ins/addr/:address/totalSent' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/ins/addr/:address/totalSent")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/ins/addr/:address/totalSent"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/ins/addr/:address/totalSent"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/ins/addr/:address/totalSent")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/ins/addr/:address/totalSent') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/ins/addr/:address/totalSent";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/ins/addr/:address/totalSent

http GET {{baseUrl}}/ins/addr/:address/totalSent

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/ins/addr/:address/totalSent

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/ins/addr/:address/totalSent")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Returns transaction object

{{baseUrl}}/ins/tx/:txid

QUERY PARAMS

txid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/ins/tx/:txid");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/ins/tx/:txid")

require "http/client"

url = "{{baseUrl}}/ins/tx/:txid"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/ins/tx/:txid"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/ins/tx/:txid");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/ins/tx/:txid"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/ins/tx/:txid HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/ins/tx/:txid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/ins/tx/:txid"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/ins/tx/:txid")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/ins/tx/:txid")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/ins/tx/:txid');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/ins/tx/:txid'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/ins/tx/:txid';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/ins/tx/:txid',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/ins/tx/:txid")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/ins/tx/:txid',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/ins/tx/:txid'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/ins/tx/:txid');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/ins/tx/:txid'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/ins/tx/:txid';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/ins/tx/:txid"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/ins/tx/:txid" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/ins/tx/:txid",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/ins/tx/:txid');

echo $response->getBody();

setUrl('{{baseUrl}}/ins/tx/:txid');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/ins/tx/:txid');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/ins/tx/:txid' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/ins/tx/:txid' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/ins/tx/:txid")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/ins/tx/:txid"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/ins/tx/:txid"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/ins/tx/:txid")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/ins/tx/:txid') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/ins/tx/:txid";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/ins/tx/:txid

http GET {{baseUrl}}/ins/tx/:txid

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/ins/tx/:txid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/ins/tx/:txid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Utility API for calling several blockchain node functions

{{baseUrl}}/ins/status

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/ins/status");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/ins/status")

require "http/client"

url = "{{baseUrl}}/ins/status"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/ins/status"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/ins/status");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/ins/status"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/ins/status HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/ins/status")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/ins/status"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/ins/status")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/ins/status")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/ins/status');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/ins/status'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/ins/status';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/ins/status',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/ins/status")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/ins/status',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/ins/status'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/ins/status');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/ins/status'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/ins/status';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/ins/status"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/ins/status" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/ins/status",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/ins/status');

echo $response->getBody();

setUrl('{{baseUrl}}/ins/status');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/ins/status');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/ins/status' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/ins/status' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/ins/status")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/ins/status"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/ins/status"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/ins/status")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/ins/status') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/ins/status";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/ins/status

http GET {{baseUrl}}/ins/status

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/ins/status

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/ins/status")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Send a JSON-RPC call to a localhost neblio-Qt or nebliod node

{{baseUrl}}/

BODY json

{
  "id": "",
  "jsonrpc": "",
  "method": "",
  "params": []
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"id\": \"neblio-apis\",\n  \"jsonrpc\": \"1.0\",\n  \"method\": \"getstakinginfo\",\n  \"params\": []\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/" {:content-type :json
                                             :form-params {:id "neblio-apis"
                                                           :jsonrpc "1.0"
                                                           :method "getstakinginfo"
                                                           :params []}})

require "http/client"

url = "{{baseUrl}}/"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"id\": \"neblio-apis\",\n  \"jsonrpc\": \"1.0\",\n  \"method\": \"getstakinginfo\",\n  \"params\": []\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/"),
    Content = new StringContent("{\n  \"id\": \"neblio-apis\",\n  \"jsonrpc\": \"1.0\",\n  \"method\": \"getstakinginfo\",\n  \"params\": []\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"id\": \"neblio-apis\",\n  \"jsonrpc\": \"1.0\",\n  \"method\": \"getstakinginfo\",\n  \"params\": []\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/"

	payload := strings.NewReader("{\n  \"id\": \"neblio-apis\",\n  \"jsonrpc\": \"1.0\",\n  \"method\": \"getstakinginfo\",\n  \"params\": []\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 91

{
  "id": "neblio-apis",
  "jsonrpc": "1.0",
  "method": "getstakinginfo",
  "params": []
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"id\": \"neblio-apis\",\n  \"jsonrpc\": \"1.0\",\n  \"method\": \"getstakinginfo\",\n  \"params\": []\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"id\": \"neblio-apis\",\n  \"jsonrpc\": \"1.0\",\n  \"method\": \"getstakinginfo\",\n  \"params\": []\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"id\": \"neblio-apis\",\n  \"jsonrpc\": \"1.0\",\n  \"method\": \"getstakinginfo\",\n  \"params\": []\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/")
  .header("content-type", "application/json")
  .body("{\n  \"id\": \"neblio-apis\",\n  \"jsonrpc\": \"1.0\",\n  \"method\": \"getstakinginfo\",\n  \"params\": []\n}")
  .asString();

const data = JSON.stringify({
  id: 'neblio-apis',
  jsonrpc: '1.0',
  method: 'getstakinginfo',
  params: []
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/',
  headers: {'content-type': 'application/json'},
  data: {id: 'neblio-apis', jsonrpc: '1.0', method: 'getstakinginfo', params: []}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"id":"neblio-apis","jsonrpc":"1.0","method":"getstakinginfo","params":[]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "id": "neblio-apis",\n  "jsonrpc": "1.0",\n  "method": "getstakinginfo",\n  "params": []\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"id\": \"neblio-apis\",\n  \"jsonrpc\": \"1.0\",\n  \"method\": \"getstakinginfo\",\n  \"params\": []\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({id: 'neblio-apis', jsonrpc: '1.0', method: 'getstakinginfo', params: []}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/',
  headers: {'content-type': 'application/json'},
  body: {id: 'neblio-apis', jsonrpc: '1.0', method: 'getstakinginfo', params: []},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  id: 'neblio-apis',
  jsonrpc: '1.0',
  method: 'getstakinginfo',
  params: []
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/',
  headers: {'content-type': 'application/json'},
  data: {id: 'neblio-apis', jsonrpc: '1.0', method: 'getstakinginfo', params: []}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"id":"neblio-apis","jsonrpc":"1.0","method":"getstakinginfo","params":[]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"id": @"neblio-apis",
                              @"jsonrpc": @"1.0",
                              @"method": @"getstakinginfo",
                              @"params": @[  ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"id\": \"neblio-apis\",\n  \"jsonrpc\": \"1.0\",\n  \"method\": \"getstakinginfo\",\n  \"params\": []\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'id' => 'neblio-apis',
    'jsonrpc' => '1.0',
    'method' => 'getstakinginfo',
    'params' => [
        
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/', [
  'body' => '{
  "id": "neblio-apis",
  "jsonrpc": "1.0",
  "method": "getstakinginfo",
  "params": []
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'id' => 'neblio-apis',
  'jsonrpc' => '1.0',
  'method' => 'getstakinginfo',
  'params' => [
    
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'id' => 'neblio-apis',
  'jsonrpc' => '1.0',
  'method' => 'getstakinginfo',
  'params' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "id": "neblio-apis",
  "jsonrpc": "1.0",
  "method": "getstakinginfo",
  "params": []
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "id": "neblio-apis",
  "jsonrpc": "1.0",
  "method": "getstakinginfo",
  "params": []
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"id\": \"neblio-apis\",\n  \"jsonrpc\": \"1.0\",\n  \"method\": \"getstakinginfo\",\n  \"params\": []\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/"

payload = {
    "id": "neblio-apis",
    "jsonrpc": "1.0",
    "method": "getstakinginfo",
    "params": []
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/"

payload <- "{\n  \"id\": \"neblio-apis\",\n  \"jsonrpc\": \"1.0\",\n  \"method\": \"getstakinginfo\",\n  \"params\": []\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"id\": \"neblio-apis\",\n  \"jsonrpc\": \"1.0\",\n  \"method\": \"getstakinginfo\",\n  \"params\": []\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.body = "{\n  \"id\": \"neblio-apis\",\n  \"jsonrpc\": \"1.0\",\n  \"method\": \"getstakinginfo\",\n  \"params\": []\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/";

    let payload = json!({
        "id": "neblio-apis",
        "jsonrpc": "1.0",
        "method": "getstakinginfo",
        "params": ()
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/ \
  --header 'content-type: application/json' \
  --data '{
  "id": "neblio-apis",
  "jsonrpc": "1.0",
  "method": "getstakinginfo",
  "params": []
}'

echo '{
  "id": "neblio-apis",
  "jsonrpc": "1.0",
  "method": "getstakinginfo",
  "params": []
}' |  \
  http POST {{baseUrl}}/ \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "id": "neblio-apis",\n  "jsonrpc": "1.0",\n  "method": "getstakinginfo",\n  "params": []\n}' \
  --output-document \
  - {{baseUrl}}/

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "id": "neblio-apis",
  "jsonrpc": "1.0",
  "method": "getstakinginfo",
  "params": []
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Broadcasts a signed raw transaction to the network

{{baseUrl}}/ntp1/broadcast

BODY json

{
  "txHex": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/ntp1/broadcast");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"txHex\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/ntp1/broadcast" {:content-type :json
                                                           :form-params {:txHex ""}})

require "http/client"

url = "{{baseUrl}}/ntp1/broadcast"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"txHex\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/ntp1/broadcast"),
    Content = new StringContent("{\n  \"txHex\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/ntp1/broadcast");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"txHex\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/ntp1/broadcast"

	payload := strings.NewReader("{\n  \"txHex\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ntp1/broadcast HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 17

{
  "txHex": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/ntp1/broadcast")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"txHex\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/ntp1/broadcast"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"txHex\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"txHex\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/ntp1/broadcast")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/ntp1/broadcast")
  .header("content-type", "application/json")
  .body("{\n  \"txHex\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  txHex: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/ntp1/broadcast');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/ntp1/broadcast',
  headers: {'content-type': 'application/json'},
  data: {txHex: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/ntp1/broadcast';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"txHex":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/ntp1/broadcast',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "txHex": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"txHex\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/ntp1/broadcast")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/ntp1/broadcast',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({txHex: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/ntp1/broadcast',
  headers: {'content-type': 'application/json'},
  body: {txHex: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/ntp1/broadcast');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  txHex: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/ntp1/broadcast',
  headers: {'content-type': 'application/json'},
  data: {txHex: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/ntp1/broadcast';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"txHex":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"txHex": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/ntp1/broadcast"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/ntp1/broadcast" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"txHex\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/ntp1/broadcast",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'txHex' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/ntp1/broadcast', [
  'body' => '{
  "txHex": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/ntp1/broadcast');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'txHex' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'txHex' => ''
]));
$request->setRequestUrl('{{baseUrl}}/ntp1/broadcast');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/ntp1/broadcast' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "txHex": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/ntp1/broadcast' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "txHex": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"txHex\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/ntp1/broadcast", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/ntp1/broadcast"

payload = { "txHex": "" }
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/ntp1/broadcast"

payload <- "{\n  \"txHex\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/ntp1/broadcast")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"txHex\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/ntp1/broadcast') do |req|
  req.body = "{\n  \"txHex\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/ntp1/broadcast";

    let payload = json!({"txHex": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/ntp1/broadcast \
  --header 'content-type: application/json' \
  --data '{
  "txHex": ""
}'

echo '{
  "txHex": ""
}' |  \
  http POST {{baseUrl}}/ntp1/broadcast \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "txHex": ""\n}' \
  --output-document \
  - {{baseUrl}}/ntp1/broadcast

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["txHex": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/ntp1/broadcast")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Builds a transaction that burns an NTP1 Token

{{baseUrl}}/ntp1/burntoken

BODY json

{
  "burn": [
    {
      "amount": "",
      "tokenId": ""
    }
  ],
  "fee": "",
  "from": [],
  "transfer": [
    {
      "address": "",
      "amount": "",
      "tokenId": ""
    }
  ]
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/ntp1/burntoken");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"burn\": [\n    {\n      \"amount\": \"\",\n      \"tokenId\": \"\"\n    }\n  ],\n  \"fee\": \"\",\n  \"from\": [],\n  \"transfer\": [\n    {\n      \"address\": \"\",\n      \"amount\": \"\",\n      \"tokenId\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/ntp1/burntoken" {:content-type :json
                                                           :form-params {:burn [{:amount ""
                                                                                 :tokenId ""}]
                                                                         :fee ""
                                                                         :from []
                                                                         :transfer [{:address ""
                                                                                     :amount ""
                                                                                     :tokenId ""}]}})

require "http/client"

url = "{{baseUrl}}/ntp1/burntoken"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"burn\": [\n    {\n      \"amount\": \"\",\n      \"tokenId\": \"\"\n    }\n  ],\n  \"fee\": \"\",\n  \"from\": [],\n  \"transfer\": [\n    {\n      \"address\": \"\",\n      \"amount\": \"\",\n      \"tokenId\": \"\"\n    }\n  ]\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/ntp1/burntoken"),
    Content = new StringContent("{\n  \"burn\": [\n    {\n      \"amount\": \"\",\n      \"tokenId\": \"\"\n    }\n  ],\n  \"fee\": \"\",\n  \"from\": [],\n  \"transfer\": [\n    {\n      \"address\": \"\",\n      \"amount\": \"\",\n      \"tokenId\": \"\"\n    }\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/ntp1/burntoken");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"burn\": [\n    {\n      \"amount\": \"\",\n      \"tokenId\": \"\"\n    }\n  ],\n  \"fee\": \"\",\n  \"from\": [],\n  \"transfer\": [\n    {\n      \"address\": \"\",\n      \"amount\": \"\",\n      \"tokenId\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/ntp1/burntoken"

	payload := strings.NewReader("{\n  \"burn\": [\n    {\n      \"amount\": \"\",\n      \"tokenId\": \"\"\n    }\n  ],\n  \"fee\": \"\",\n  \"from\": [],\n  \"transfer\": [\n    {\n      \"address\": \"\",\n      \"amount\": \"\",\n      \"tokenId\": \"\"\n    }\n  ]\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ntp1/burntoken HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 192

{
  "burn": [
    {
      "amount": "",
      "tokenId": ""
    }
  ],
  "fee": "",
  "from": [],
  "transfer": [
    {
      "address": "",
      "amount": "",
      "tokenId": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/ntp1/burntoken")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"burn\": [\n    {\n      \"amount\": \"\",\n      \"tokenId\": \"\"\n    }\n  ],\n  \"fee\": \"\",\n  \"from\": [],\n  \"transfer\": [\n    {\n      \"address\": \"\",\n      \"amount\": \"\",\n      \"tokenId\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/ntp1/burntoken"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"burn\": [\n    {\n      \"amount\": \"\",\n      \"tokenId\": \"\"\n    }\n  ],\n  \"fee\": \"\",\n  \"from\": [],\n  \"transfer\": [\n    {\n      \"address\": \"\",\n      \"amount\": \"\",\n      \"tokenId\": \"\"\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"burn\": [\n    {\n      \"amount\": \"\",\n      \"tokenId\": \"\"\n    }\n  ],\n  \"fee\": \"\",\n  \"from\": [],\n  \"transfer\": [\n    {\n      \"address\": \"\",\n      \"amount\": \"\",\n      \"tokenId\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/ntp1/burntoken")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/ntp1/burntoken")
  .header("content-type", "application/json")
  .body("{\n  \"burn\": [\n    {\n      \"amount\": \"\",\n      \"tokenId\": \"\"\n    }\n  ],\n  \"fee\": \"\",\n  \"from\": [],\n  \"transfer\": [\n    {\n      \"address\": \"\",\n      \"amount\": \"\",\n      \"tokenId\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  burn: [
    {
      amount: '',
      tokenId: ''
    }
  ],
  fee: '',
  from: [],
  transfer: [
    {
      address: '',
      amount: '',
      tokenId: ''
    }
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/ntp1/burntoken');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/ntp1/burntoken',
  headers: {'content-type': 'application/json'},
  data: {
    burn: [{amount: '', tokenId: ''}],
    fee: '',
    from: [],
    transfer: [{address: '', amount: '', tokenId: ''}]
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/ntp1/burntoken';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"burn":[{"amount":"","tokenId":""}],"fee":"","from":[],"transfer":[{"address":"","amount":"","tokenId":""}]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/ntp1/burntoken',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "burn": [\n    {\n      "amount": "",\n      "tokenId": ""\n    }\n  ],\n  "fee": "",\n  "from": [],\n  "transfer": [\n    {\n      "address": "",\n      "amount": "",\n      "tokenId": ""\n    }\n  ]\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"burn\": [\n    {\n      \"amount\": \"\",\n      \"tokenId\": \"\"\n    }\n  ],\n  \"fee\": \"\",\n  \"from\": [],\n  \"transfer\": [\n    {\n      \"address\": \"\",\n      \"amount\": \"\",\n      \"tokenId\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/ntp1/burntoken")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/ntp1/burntoken',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  burn: [{amount: '', tokenId: ''}],
  fee: '',
  from: [],
  transfer: [{address: '', amount: '', tokenId: ''}]
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/ntp1/burntoken',
  headers: {'content-type': 'application/json'},
  body: {
    burn: [{amount: '', tokenId: ''}],
    fee: '',
    from: [],
    transfer: [{address: '', amount: '', tokenId: ''}]
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/ntp1/burntoken');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  burn: [
    {
      amount: '',
      tokenId: ''
    }
  ],
  fee: '',
  from: [],
  transfer: [
    {
      address: '',
      amount: '',
      tokenId: ''
    }
  ]
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/ntp1/burntoken',
  headers: {'content-type': 'application/json'},
  data: {
    burn: [{amount: '', tokenId: ''}],
    fee: '',
    from: [],
    transfer: [{address: '', amount: '', tokenId: ''}]
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/ntp1/burntoken';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"burn":[{"amount":"","tokenId":""}],"fee":"","from":[],"transfer":[{"address":"","amount":"","tokenId":""}]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"burn": @[ @{ @"amount": @"", @"tokenId": @"" } ],
                              @"fee": @"",
                              @"from": @[  ],
                              @"transfer": @[ @{ @"address": @"", @"amount": @"", @"tokenId": @"" } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/ntp1/burntoken"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/ntp1/burntoken" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"burn\": [\n    {\n      \"amount\": \"\",\n      \"tokenId\": \"\"\n    }\n  ],\n  \"fee\": \"\",\n  \"from\": [],\n  \"transfer\": [\n    {\n      \"address\": \"\",\n      \"amount\": \"\",\n      \"tokenId\": \"\"\n    }\n  ]\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/ntp1/burntoken",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'burn' => [
        [
                'amount' => '',
                'tokenId' => ''
        ]
    ],
    'fee' => '',
    'from' => [
        
    ],
    'transfer' => [
        [
                'address' => '',
                'amount' => '',
                'tokenId' => ''
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/ntp1/burntoken', [
  'body' => '{
  "burn": [
    {
      "amount": "",
      "tokenId": ""
    }
  ],
  "fee": "",
  "from": [],
  "transfer": [
    {
      "address": "",
      "amount": "",
      "tokenId": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/ntp1/burntoken');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'burn' => [
    [
        'amount' => '',
        'tokenId' => ''
    ]
  ],
  'fee' => '',
  'from' => [
    
  ],
  'transfer' => [
    [
        'address' => '',
        'amount' => '',
        'tokenId' => ''
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'burn' => [
    [
        'amount' => '',
        'tokenId' => ''
    ]
  ],
  'fee' => '',
  'from' => [
    
  ],
  'transfer' => [
    [
        'address' => '',
        'amount' => '',
        'tokenId' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/ntp1/burntoken');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/ntp1/burntoken' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "burn": [
    {
      "amount": "",
      "tokenId": ""
    }
  ],
  "fee": "",
  "from": [],
  "transfer": [
    {
      "address": "",
      "amount": "",
      "tokenId": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/ntp1/burntoken' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "burn": [
    {
      "amount": "",
      "tokenId": ""
    }
  ],
  "fee": "",
  "from": [],
  "transfer": [
    {
      "address": "",
      "amount": "",
      "tokenId": ""
    }
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"burn\": [\n    {\n      \"amount\": \"\",\n      \"tokenId\": \"\"\n    }\n  ],\n  \"fee\": \"\",\n  \"from\": [],\n  \"transfer\": [\n    {\n      \"address\": \"\",\n      \"amount\": \"\",\n      \"tokenId\": \"\"\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/ntp1/burntoken", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/ntp1/burntoken"

payload = {
    "burn": [
        {
            "amount": "",
            "tokenId": ""
        }
    ],
    "fee": "",
    "from": [],
    "transfer": [
        {
            "address": "",
            "amount": "",
            "tokenId": ""
        }
    ]
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/ntp1/burntoken"

payload <- "{\n  \"burn\": [\n    {\n      \"amount\": \"\",\n      \"tokenId\": \"\"\n    }\n  ],\n  \"fee\": \"\",\n  \"from\": [],\n  \"transfer\": [\n    {\n      \"address\": \"\",\n      \"amount\": \"\",\n      \"tokenId\": \"\"\n    }\n  ]\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/ntp1/burntoken")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"burn\": [\n    {\n      \"amount\": \"\",\n      \"tokenId\": \"\"\n    }\n  ],\n  \"fee\": \"\",\n  \"from\": [],\n  \"transfer\": [\n    {\n      \"address\": \"\",\n      \"amount\": \"\",\n      \"tokenId\": \"\"\n    }\n  ]\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/ntp1/burntoken') do |req|
  req.body = "{\n  \"burn\": [\n    {\n      \"amount\": \"\",\n      \"tokenId\": \"\"\n    }\n  ],\n  \"fee\": \"\",\n  \"from\": [],\n  \"transfer\": [\n    {\n      \"address\": \"\",\n      \"amount\": \"\",\n      \"tokenId\": \"\"\n    }\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/ntp1/burntoken";

    let payload = json!({
        "burn": (
            json!({
                "amount": "",
                "tokenId": ""
            })
        ),
        "fee": "",
        "from": (),
        "transfer": (
            json!({
                "address": "",
                "amount": "",
                "tokenId": ""
            })
        )
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/ntp1/burntoken \
  --header 'content-type: application/json' \
  --data '{
  "burn": [
    {
      "amount": "",
      "tokenId": ""
    }
  ],
  "fee": "",
  "from": [],
  "transfer": [
    {
      "address": "",
      "amount": "",
      "tokenId": ""
    }
  ]
}'

echo '{
  "burn": [
    {
      "amount": "",
      "tokenId": ""
    }
  ],
  "fee": "",
  "from": [],
  "transfer": [
    {
      "address": "",
      "amount": "",
      "tokenId": ""
    }
  ]
}' |  \
  http POST {{baseUrl}}/ntp1/burntoken \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "burn": [\n    {\n      "amount": "",\n      "tokenId": ""\n    }\n  ],\n  "fee": "",\n  "from": [],\n  "transfer": [\n    {\n      "address": "",\n      "amount": "",\n      "tokenId": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/ntp1/burntoken

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "burn": [
    [
      "amount": "",
      "tokenId": ""
    ]
  ],
  "fee": "",
  "from": [],
  "transfer": [
    [
      "address": "",
      "amount": "",
      "tokenId": ""
    ]
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/ntp1/burntoken")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Builds a transaction that issues a new NTP1 Token

{{baseUrl}}/ntp1/issue

BODY json

{
  "amount": "",
  "divisibility": "",
  "fee": "",
  "flags": {
    "splitChange": false
  },
  "issueAddress": "",
  "metadata": {
    "description": "",
    "encryptions": [
      {
        "format": "",
        "key": "",
        "pubkey": "",
        "type": ""
      }
    ],
    "issuer": "",
    "rules": {
      "expiration": {
        "locked": false,
        "validUntil": ""
      },
      "fees": {
        "items": [
          {
            "address": "",
            "tokenId": "",
            "value": ""
          }
        ],
        "locked": false
      },
      "holders": [
        {
          "address": "",
          "locked": false
        }
      ]
    },
    "tokenName": "",
    "urls": [
      {
        "dataHash": "",
        "mimeType": "",
        "name": "",
        "url": ""
      }
    ],
    "userData": {
      "meta": [
        {
          "key": "",
          "value": ""
        }
      ]
    }
  },
  "reissuable": false,
  "transfer": [
    {
      "address": "",
      "amount": ""
    }
  ]
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/ntp1/issue");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"amount\": \"\",\n  \"divisibility\": \"\",\n  \"fee\": \"\",\n  \"flags\": {\n    \"splitChange\": false\n  },\n  \"issueAddress\": \"\",\n  \"metadata\": {\n    \"description\": \"\",\n    \"encryptions\": [\n      {\n        \"format\": \"\",\n        \"key\": \"\",\n        \"pubkey\": \"\",\n        \"type\": \"\"\n      }\n    ],\n    \"issuer\": \"\",\n    \"rules\": {\n      \"expiration\": {\n        \"locked\": false,\n        \"validUntil\": \"\"\n      },\n      \"fees\": {\n        \"items\": [\n          {\n            \"address\": \"\",\n            \"tokenId\": \"\",\n            \"value\": \"\"\n          }\n        ],\n        \"locked\": false\n      },\n      \"holders\": [\n        {\n          \"address\": \"\",\n          \"locked\": false\n        }\n      ]\n    },\n    \"tokenName\": \"\",\n    \"urls\": [\n      {\n        \"dataHash\": \"\",\n        \"mimeType\": \"\",\n        \"name\": \"\",\n        \"url\": \"\"\n      }\n    ],\n    \"userData\": {\n      \"meta\": [\n        {\n          \"key\": \"\",\n          \"value\": \"\"\n        }\n      ]\n    }\n  },\n  \"reissuable\": false,\n  \"transfer\": [\n    {\n      \"address\": \"\",\n      \"amount\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/ntp1/issue" {:content-type :json
                                                       :form-params {:amount ""
                                                                     :divisibility ""
                                                                     :fee ""
                                                                     :flags {:splitChange false}
                                                                     :issueAddress ""
                                                                     :metadata {:description ""
                                                                                :encryptions [{:format ""
                                                                                               :key ""
                                                                                               :pubkey ""
                                                                                               :type ""}]
                                                                                :issuer ""
                                                                                :rules {:expiration {:locked false
                                                                                                     :validUntil ""}
                                                                                        :fees {:items [{:address ""
                                                                                                        :tokenId ""
                                                                                                        :value ""}]
                                                                                               :locked false}
                                                                                        :holders [{:address ""
                                                                                                   :locked false}]}
                                                                                :tokenName ""
                                                                                :urls [{:dataHash ""
                                                                                        :mimeType ""
                                                                                        :name ""
                                                                                        :url ""}]
                                                                                :userData {:meta [{:key ""
                                                                                                   :value ""}]}}
                                                                     :reissuable false
                                                                     :transfer [{:address ""
                                                                                 :amount ""}]}})

require "http/client"

url = "{{baseUrl}}/ntp1/issue"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"amount\": \"\",\n  \"divisibility\": \"\",\n  \"fee\": \"\",\n  \"flags\": {\n    \"splitChange\": false\n  },\n  \"issueAddress\": \"\",\n  \"metadata\": {\n    \"description\": \"\",\n    \"encryptions\": [\n      {\n        \"format\": \"\",\n        \"key\": \"\",\n        \"pubkey\": \"\",\n        \"type\": \"\"\n      }\n    ],\n    \"issuer\": \"\",\n    \"rules\": {\n      \"expiration\": {\n        \"locked\": false,\n        \"validUntil\": \"\"\n      },\n      \"fees\": {\n        \"items\": [\n          {\n            \"address\": \"\",\n            \"tokenId\": \"\",\n            \"value\": \"\"\n          }\n        ],\n        \"locked\": false\n      },\n      \"holders\": [\n        {\n          \"address\": \"\",\n          \"locked\": false\n        }\n      ]\n    },\n    \"tokenName\": \"\",\n    \"urls\": [\n      {\n        \"dataHash\": \"\",\n        \"mimeType\": \"\",\n        \"name\": \"\",\n        \"url\": \"\"\n      }\n    ],\n    \"userData\": {\n      \"meta\": [\n        {\n          \"key\": \"\",\n          \"value\": \"\"\n        }\n      ]\n    }\n  },\n  \"reissuable\": false,\n  \"transfer\": [\n    {\n      \"address\": \"\",\n      \"amount\": \"\"\n    }\n  ]\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/ntp1/issue"),
    Content = new StringContent("{\n  \"amount\": \"\",\n  \"divisibility\": \"\",\n  \"fee\": \"\",\n  \"flags\": {\n    \"splitChange\": false\n  },\n  \"issueAddress\": \"\",\n  \"metadata\": {\n    \"description\": \"\",\n    \"encryptions\": [\n      {\n        \"format\": \"\",\n        \"key\": \"\",\n        \"pubkey\": \"\",\n        \"type\": \"\"\n      }\n    ],\n    \"issuer\": \"\",\n    \"rules\": {\n      \"expiration\": {\n        \"locked\": false,\n        \"validUntil\": \"\"\n      },\n      \"fees\": {\n        \"items\": [\n          {\n            \"address\": \"\",\n            \"tokenId\": \"\",\n            \"value\": \"\"\n          }\n        ],\n        \"locked\": false\n      },\n      \"holders\": [\n        {\n          \"address\": \"\",\n          \"locked\": false\n        }\n      ]\n    },\n    \"tokenName\": \"\",\n    \"urls\": [\n      {\n        \"dataHash\": \"\",\n        \"mimeType\": \"\",\n        \"name\": \"\",\n        \"url\": \"\"\n      }\n    ],\n    \"userData\": {\n      \"meta\": [\n        {\n          \"key\": \"\",\n          \"value\": \"\"\n        }\n      ]\n    }\n  },\n  \"reissuable\": false,\n  \"transfer\": [\n    {\n      \"address\": \"\",\n      \"amount\": \"\"\n    }\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/ntp1/issue");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"amount\": \"\",\n  \"divisibility\": \"\",\n  \"fee\": \"\",\n  \"flags\": {\n    \"splitChange\": false\n  },\n  \"issueAddress\": \"\",\n  \"metadata\": {\n    \"description\": \"\",\n    \"encryptions\": [\n      {\n        \"format\": \"\",\n        \"key\": \"\",\n        \"pubkey\": \"\",\n        \"type\": \"\"\n      }\n    ],\n    \"issuer\": \"\",\n    \"rules\": {\n      \"expiration\": {\n        \"locked\": false,\n        \"validUntil\": \"\"\n      },\n      \"fees\": {\n        \"items\": [\n          {\n            \"address\": \"\",\n            \"tokenId\": \"\",\n            \"value\": \"\"\n          }\n        ],\n        \"locked\": false\n      },\n      \"holders\": [\n        {\n          \"address\": \"\",\n          \"locked\": false\n        }\n      ]\n    },\n    \"tokenName\": \"\",\n    \"urls\": [\n      {\n        \"dataHash\": \"\",\n        \"mimeType\": \"\",\n        \"name\": \"\",\n        \"url\": \"\"\n      }\n    ],\n    \"userData\": {\n      \"meta\": [\n        {\n          \"key\": \"\",\n          \"value\": \"\"\n        }\n      ]\n    }\n  },\n  \"reissuable\": false,\n  \"transfer\": [\n    {\n      \"address\": \"\",\n      \"amount\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/ntp1/issue"

	payload := strings.NewReader("{\n  \"amount\": \"\",\n  \"divisibility\": \"\",\n  \"fee\": \"\",\n  \"flags\": {\n    \"splitChange\": false\n  },\n  \"issueAddress\": \"\",\n  \"metadata\": {\n    \"description\": \"\",\n    \"encryptions\": [\n      {\n        \"format\": \"\",\n        \"key\": \"\",\n        \"pubkey\": \"\",\n        \"type\": \"\"\n      }\n    ],\n    \"issuer\": \"\",\n    \"rules\": {\n      \"expiration\": {\n        \"locked\": false,\n        \"validUntil\": \"\"\n      },\n      \"fees\": {\n        \"items\": [\n          {\n            \"address\": \"\",\n            \"tokenId\": \"\",\n            \"value\": \"\"\n          }\n        ],\n        \"locked\": false\n      },\n      \"holders\": [\n        {\n          \"address\": \"\",\n          \"locked\": false\n        }\n      ]\n    },\n    \"tokenName\": \"\",\n    \"urls\": [\n      {\n        \"dataHash\": \"\",\n        \"mimeType\": \"\",\n        \"name\": \"\",\n        \"url\": \"\"\n      }\n    ],\n    \"userData\": {\n      \"meta\": [\n        {\n          \"key\": \"\",\n          \"value\": \"\"\n        }\n      ]\n    }\n  },\n  \"reissuable\": false,\n  \"transfer\": [\n    {\n      \"address\": \"\",\n      \"amount\": \"\"\n    }\n  ]\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ntp1/issue HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 1039

{
  "amount": "",
  "divisibility": "",
  "fee": "",
  "flags": {
    "splitChange": false
  },
  "issueAddress": "",
  "metadata": {
    "description": "",
    "encryptions": [
      {
        "format": "",
        "key": "",
        "pubkey": "",
        "type": ""
      }
    ],
    "issuer": "",
    "rules": {
      "expiration": {
        "locked": false,
        "validUntil": ""
      },
      "fees": {
        "items": [
          {
            "address": "",
            "tokenId": "",
            "value": ""
          }
        ],
        "locked": false
      },
      "holders": [
        {
          "address": "",
          "locked": false
        }
      ]
    },
    "tokenName": "",
    "urls": [
      {
        "dataHash": "",
        "mimeType": "",
        "name": "",
        "url": ""
      }
    ],
    "userData": {
      "meta": [
        {
          "key": "",
          "value": ""
        }
      ]
    }
  },
  "reissuable": false,
  "transfer": [
    {
      "address": "",
      "amount": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/ntp1/issue")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"amount\": \"\",\n  \"divisibility\": \"\",\n  \"fee\": \"\",\n  \"flags\": {\n    \"splitChange\": false\n  },\n  \"issueAddress\": \"\",\n  \"metadata\": {\n    \"description\": \"\",\n    \"encryptions\": [\n      {\n        \"format\": \"\",\n        \"key\": \"\",\n        \"pubkey\": \"\",\n        \"type\": \"\"\n      }\n    ],\n    \"issuer\": \"\",\n    \"rules\": {\n      \"expiration\": {\n        \"locked\": false,\n        \"validUntil\": \"\"\n      },\n      \"fees\": {\n        \"items\": [\n          {\n            \"address\": \"\",\n            \"tokenId\": \"\",\n            \"value\": \"\"\n          }\n        ],\n        \"locked\": false\n      },\n      \"holders\": [\n        {\n          \"address\": \"\",\n          \"locked\": false\n        }\n      ]\n    },\n    \"tokenName\": \"\",\n    \"urls\": [\n      {\n        \"dataHash\": \"\",\n        \"mimeType\": \"\",\n        \"name\": \"\",\n        \"url\": \"\"\n      }\n    ],\n    \"userData\": {\n      \"meta\": [\n        {\n          \"key\": \"\",\n          \"value\": \"\"\n        }\n      ]\n    }\n  },\n  \"reissuable\": false,\n  \"transfer\": [\n    {\n      \"address\": \"\",\n      \"amount\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/ntp1/issue"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"amount\": \"\",\n  \"divisibility\": \"\",\n  \"fee\": \"\",\n  \"flags\": {\n    \"splitChange\": false\n  },\n  \"issueAddress\": \"\",\n  \"metadata\": {\n    \"description\": \"\",\n    \"encryptions\": [\n      {\n        \"format\": \"\",\n        \"key\": \"\",\n        \"pubkey\": \"\",\n        \"type\": \"\"\n      }\n    ],\n    \"issuer\": \"\",\n    \"rules\": {\n      \"expiration\": {\n        \"locked\": false,\n        \"validUntil\": \"\"\n      },\n      \"fees\": {\n        \"items\": [\n          {\n            \"address\": \"\",\n            \"tokenId\": \"\",\n            \"value\": \"\"\n          }\n        ],\n        \"locked\": false\n      },\n      \"holders\": [\n        {\n          \"address\": \"\",\n          \"locked\": false\n        }\n      ]\n    },\n    \"tokenName\": \"\",\n    \"urls\": [\n      {\n        \"dataHash\": \"\",\n        \"mimeType\": \"\",\n        \"name\": \"\",\n        \"url\": \"\"\n      }\n    ],\n    \"userData\": {\n      \"meta\": [\n        {\n          \"key\": \"\",\n          \"value\": \"\"\n        }\n      ]\n    }\n  },\n  \"reissuable\": false,\n  \"transfer\": [\n    {\n      \"address\": \"\",\n      \"amount\": \"\"\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"amount\": \"\",\n  \"divisibility\": \"\",\n  \"fee\": \"\",\n  \"flags\": {\n    \"splitChange\": false\n  },\n  \"issueAddress\": \"\",\n  \"metadata\": {\n    \"description\": \"\",\n    \"encryptions\": [\n      {\n        \"format\": \"\",\n        \"key\": \"\",\n        \"pubkey\": \"\",\n        \"type\": \"\"\n      }\n    ],\n    \"issuer\": \"\",\n    \"rules\": {\n      \"expiration\": {\n        \"locked\": false,\n        \"validUntil\": \"\"\n      },\n      \"fees\": {\n        \"items\": [\n          {\n            \"address\": \"\",\n            \"tokenId\": \"\",\n            \"value\": \"\"\n          }\n        ],\n        \"locked\": false\n      },\n      \"holders\": [\n        {\n          \"address\": \"\",\n          \"locked\": false\n        }\n      ]\n    },\n    \"tokenName\": \"\",\n    \"urls\": [\n      {\n        \"dataHash\": \"\",\n        \"mimeType\": \"\",\n        \"name\": \"\",\n        \"url\": \"\"\n      }\n    ],\n    \"userData\": {\n      \"meta\": [\n        {\n          \"key\": \"\",\n          \"value\": \"\"\n        }\n      ]\n    }\n  },\n  \"reissuable\": false,\n  \"transfer\": [\n    {\n      \"address\": \"\",\n      \"amount\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/ntp1/issue")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/ntp1/issue")
  .header("content-type", "application/json")
  .body("{\n  \"amount\": \"\",\n  \"divisibility\": \"\",\n  \"fee\": \"\",\n  \"flags\": {\n    \"splitChange\": false\n  },\n  \"issueAddress\": \"\",\n  \"metadata\": {\n    \"description\": \"\",\n    \"encryptions\": [\n      {\n        \"format\": \"\",\n        \"key\": \"\",\n        \"pubkey\": \"\",\n        \"type\": \"\"\n      }\n    ],\n    \"issuer\": \"\",\n    \"rules\": {\n      \"expiration\": {\n        \"locked\": false,\n        \"validUntil\": \"\"\n      },\n      \"fees\": {\n        \"items\": [\n          {\n            \"address\": \"\",\n            \"tokenId\": \"\",\n            \"value\": \"\"\n          }\n        ],\n        \"locked\": false\n      },\n      \"holders\": [\n        {\n          \"address\": \"\",\n          \"locked\": false\n        }\n      ]\n    },\n    \"tokenName\": \"\",\n    \"urls\": [\n      {\n        \"dataHash\": \"\",\n        \"mimeType\": \"\",\n        \"name\": \"\",\n        \"url\": \"\"\n      }\n    ],\n    \"userData\": {\n      \"meta\": [\n        {\n          \"key\": \"\",\n          \"value\": \"\"\n        }\n      ]\n    }\n  },\n  \"reissuable\": false,\n  \"transfer\": [\n    {\n      \"address\": \"\",\n      \"amount\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  amount: '',
  divisibility: '',
  fee: '',
  flags: {
    splitChange: false
  },
  issueAddress: '',
  metadata: {
    description: '',
    encryptions: [
      {
        format: '',
        key: '',
        pubkey: '',
        type: ''
      }
    ],
    issuer: '',
    rules: {
      expiration: {
        locked: false,
        validUntil: ''
      },
      fees: {
        items: [
          {
            address: '',
            tokenId: '',
            value: ''
          }
        ],
        locked: false
      },
      holders: [
        {
          address: '',
          locked: false
        }
      ]
    },
    tokenName: '',
    urls: [
      {
        dataHash: '',
        mimeType: '',
        name: '',
        url: ''
      }
    ],
    userData: {
      meta: [
        {
          key: '',
          value: ''
        }
      ]
    }
  },
  reissuable: false,
  transfer: [
    {
      address: '',
      amount: ''
    }
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/ntp1/issue');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/ntp1/issue',
  headers: {'content-type': 'application/json'},
  data: {
    amount: '',
    divisibility: '',
    fee: '',
    flags: {splitChange: false},
    issueAddress: '',
    metadata: {
      description: '',
      encryptions: [{format: '', key: '', pubkey: '', type: ''}],
      issuer: '',
      rules: {
        expiration: {locked: false, validUntil: ''},
        fees: {items: [{address: '', tokenId: '', value: ''}], locked: false},
        holders: [{address: '', locked: false}]
      },
      tokenName: '',
      urls: [{dataHash: '', mimeType: '', name: '', url: ''}],
      userData: {meta: [{key: '', value: ''}]}
    },
    reissuable: false,
    transfer: [{address: '', amount: ''}]
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/ntp1/issue';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"amount":"","divisibility":"","fee":"","flags":{"splitChange":false},"issueAddress":"","metadata":{"description":"","encryptions":[{"format":"","key":"","pubkey":"","type":""}],"issuer":"","rules":{"expiration":{"locked":false,"validUntil":""},"fees":{"items":[{"address":"","tokenId":"","value":""}],"locked":false},"holders":[{"address":"","locked":false}]},"tokenName":"","urls":[{"dataHash":"","mimeType":"","name":"","url":""}],"userData":{"meta":[{"key":"","value":""}]}},"reissuable":false,"transfer":[{"address":"","amount":""}]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/ntp1/issue',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "amount": "",\n  "divisibility": "",\n  "fee": "",\n  "flags": {\n    "splitChange": false\n  },\n  "issueAddress": "",\n  "metadata": {\n    "description": "",\n    "encryptions": [\n      {\n        "format": "",\n        "key": "",\n        "pubkey": "",\n        "type": ""\n      }\n    ],\n    "issuer": "",\n    "rules": {\n      "expiration": {\n        "locked": false,\n        "validUntil": ""\n      },\n      "fees": {\n        "items": [\n          {\n            "address": "",\n            "tokenId": "",\n            "value": ""\n          }\n        ],\n        "locked": false\n      },\n      "holders": [\n        {\n          "address": "",\n          "locked": false\n        }\n      ]\n    },\n    "tokenName": "",\n    "urls": [\n      {\n        "dataHash": "",\n        "mimeType": "",\n        "name": "",\n        "url": ""\n      }\n    ],\n    "userData": {\n      "meta": [\n        {\n          "key": "",\n          "value": ""\n        }\n      ]\n    }\n  },\n  "reissuable": false,\n  "transfer": [\n    {\n      "address": "",\n      "amount": ""\n    }\n  ]\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"amount\": \"\",\n  \"divisibility\": \"\",\n  \"fee\": \"\",\n  \"flags\": {\n    \"splitChange\": false\n  },\n  \"issueAddress\": \"\",\n  \"metadata\": {\n    \"description\": \"\",\n    \"encryptions\": [\n      {\n        \"format\": \"\",\n        \"key\": \"\",\n        \"pubkey\": \"\",\n        \"type\": \"\"\n      }\n    ],\n    \"issuer\": \"\",\n    \"rules\": {\n      \"expiration\": {\n        \"locked\": false,\n        \"validUntil\": \"\"\n      },\n      \"fees\": {\n        \"items\": [\n          {\n            \"address\": \"\",\n            \"tokenId\": \"\",\n            \"value\": \"\"\n          }\n        ],\n        \"locked\": false\n      },\n      \"holders\": [\n        {\n          \"address\": \"\",\n          \"locked\": false\n        }\n      ]\n    },\n    \"tokenName\": \"\",\n    \"urls\": [\n      {\n        \"dataHash\": \"\",\n        \"mimeType\": \"\",\n        \"name\": \"\",\n        \"url\": \"\"\n      }\n    ],\n    \"userData\": {\n      \"meta\": [\n        {\n          \"key\": \"\",\n          \"value\": \"\"\n        }\n      ]\n    }\n  },\n  \"reissuable\": false,\n  \"transfer\": [\n    {\n      \"address\": \"\",\n      \"amount\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/ntp1/issue")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/ntp1/issue',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  amount: '',
  divisibility: '',
  fee: '',
  flags: {splitChange: false},
  issueAddress: '',
  metadata: {
    description: '',
    encryptions: [{format: '', key: '', pubkey: '', type: ''}],
    issuer: '',
    rules: {
      expiration: {locked: false, validUntil: ''},
      fees: {items: [{address: '', tokenId: '', value: ''}], locked: false},
      holders: [{address: '', locked: false}]
    },
    tokenName: '',
    urls: [{dataHash: '', mimeType: '', name: '', url: ''}],
    userData: {meta: [{key: '', value: ''}]}
  },
  reissuable: false,
  transfer: [{address: '', amount: ''}]
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/ntp1/issue',
  headers: {'content-type': 'application/json'},
  body: {
    amount: '',
    divisibility: '',
    fee: '',
    flags: {splitChange: false},
    issueAddress: '',
    metadata: {
      description: '',
      encryptions: [{format: '', key: '', pubkey: '', type: ''}],
      issuer: '',
      rules: {
        expiration: {locked: false, validUntil: ''},
        fees: {items: [{address: '', tokenId: '', value: ''}], locked: false},
        holders: [{address: '', locked: false}]
      },
      tokenName: '',
      urls: [{dataHash: '', mimeType: '', name: '', url: ''}],
      userData: {meta: [{key: '', value: ''}]}
    },
    reissuable: false,
    transfer: [{address: '', amount: ''}]
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/ntp1/issue');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  amount: '',
  divisibility: '',
  fee: '',
  flags: {
    splitChange: false
  },
  issueAddress: '',
  metadata: {
    description: '',
    encryptions: [
      {
        format: '',
        key: '',
        pubkey: '',
        type: ''
      }
    ],
    issuer: '',
    rules: {
      expiration: {
        locked: false,
        validUntil: ''
      },
      fees: {
        items: [
          {
            address: '',
            tokenId: '',
            value: ''
          }
        ],
        locked: false
      },
      holders: [
        {
          address: '',
          locked: false
        }
      ]
    },
    tokenName: '',
    urls: [
      {
        dataHash: '',
        mimeType: '',
        name: '',
        url: ''
      }
    ],
    userData: {
      meta: [
        {
          key: '',
          value: ''
        }
      ]
    }
  },
  reissuable: false,
  transfer: [
    {
      address: '',
      amount: ''
    }
  ]
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/ntp1/issue',
  headers: {'content-type': 'application/json'},
  data: {
    amount: '',
    divisibility: '',
    fee: '',
    flags: {splitChange: false},
    issueAddress: '',
    metadata: {
      description: '',
      encryptions: [{format: '', key: '', pubkey: '', type: ''}],
      issuer: '',
      rules: {
        expiration: {locked: false, validUntil: ''},
        fees: {items: [{address: '', tokenId: '', value: ''}], locked: false},
        holders: [{address: '', locked: false}]
      },
      tokenName: '',
      urls: [{dataHash: '', mimeType: '', name: '', url: ''}],
      userData: {meta: [{key: '', value: ''}]}
    },
    reissuable: false,
    transfer: [{address: '', amount: ''}]
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/ntp1/issue';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"amount":"","divisibility":"","fee":"","flags":{"splitChange":false},"issueAddress":"","metadata":{"description":"","encryptions":[{"format":"","key":"","pubkey":"","type":""}],"issuer":"","rules":{"expiration":{"locked":false,"validUntil":""},"fees":{"items":[{"address":"","tokenId":"","value":""}],"locked":false},"holders":[{"address":"","locked":false}]},"tokenName":"","urls":[{"dataHash":"","mimeType":"","name":"","url":""}],"userData":{"meta":[{"key":"","value":""}]}},"reissuable":false,"transfer":[{"address":"","amount":""}]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"amount": @"",
                              @"divisibility": @"",
                              @"fee": @"",
                              @"flags": @{ @"splitChange": @NO },
                              @"issueAddress": @"",
                              @"metadata": @{ @"description": @"", @"encryptions": @[ @{ @"format": @"", @"key": @"", @"pubkey": @"", @"type": @"" } ], @"issuer": @"", @"rules": @{ @"expiration": @{ @"locked": @NO, @"validUntil": @"" }, @"fees": @{ @"items": @[ @{ @"address": @"", @"tokenId": @"", @"value": @"" } ], @"locked": @NO }, @"holders": @[ @{ @"address": @"", @"locked": @NO } ] }, @"tokenName": @"", @"urls": @[ @{ @"dataHash": @"", @"mimeType": @"", @"name": @"", @"url": @"" } ], @"userData": @{ @"meta": @[ @{ @"key": @"", @"value": @"" } ] } },
                              @"reissuable": @NO,
                              @"transfer": @[ @{ @"address": @"", @"amount": @"" } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/ntp1/issue"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/ntp1/issue" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"amount\": \"\",\n  \"divisibility\": \"\",\n  \"fee\": \"\",\n  \"flags\": {\n    \"splitChange\": false\n  },\n  \"issueAddress\": \"\",\n  \"metadata\": {\n    \"description\": \"\",\n    \"encryptions\": [\n      {\n        \"format\": \"\",\n        \"key\": \"\",\n        \"pubkey\": \"\",\n        \"type\": \"\"\n      }\n    ],\n    \"issuer\": \"\",\n    \"rules\": {\n      \"expiration\": {\n        \"locked\": false,\n        \"validUntil\": \"\"\n      },\n      \"fees\": {\n        \"items\": [\n          {\n            \"address\": \"\",\n            \"tokenId\": \"\",\n            \"value\": \"\"\n          }\n        ],\n        \"locked\": false\n      },\n      \"holders\": [\n        {\n          \"address\": \"\",\n          \"locked\": false\n        }\n      ]\n    },\n    \"tokenName\": \"\",\n    \"urls\": [\n      {\n        \"dataHash\": \"\",\n        \"mimeType\": \"\",\n        \"name\": \"\",\n        \"url\": \"\"\n      }\n    ],\n    \"userData\": {\n      \"meta\": [\n        {\n          \"key\": \"\",\n          \"value\": \"\"\n        }\n      ]\n    }\n  },\n  \"reissuable\": false,\n  \"transfer\": [\n    {\n      \"address\": \"\",\n      \"amount\": \"\"\n    }\n  ]\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/ntp1/issue",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'amount' => '',
    'divisibility' => '',
    'fee' => '',
    'flags' => [
        'splitChange' => null
    ],
    'issueAddress' => '',
    'metadata' => [
        'description' => '',
        'encryptions' => [
                [
                                'format' => '',
                                'key' => '',
                                'pubkey' => '',
                                'type' => ''
                ]
        ],
        'issuer' => '',
        'rules' => [
                'expiration' => [
                                'locked' => null,
                                'validUntil' => ''
                ],
                'fees' => [
                                'items' => [
                                                                [
                                                                                                                                'address' => '',
                                                                                                                                'tokenId' => '',
                                                                                                                                'value' => ''
                                                                ]
                                ],
                                'locked' => null
                ],
                'holders' => [
                                [
                                                                'address' => '',
                                                                'locked' => null
                                ]
                ]
        ],
        'tokenName' => '',
        'urls' => [
                [
                                'dataHash' => '',
                                'mimeType' => '',
                                'name' => '',
                                'url' => ''
                ]
        ],
        'userData' => [
                'meta' => [
                                [
                                                                'key' => '',
                                                                'value' => ''
                                ]
                ]
        ]
    ],
    'reissuable' => null,
    'transfer' => [
        [
                'address' => '',
                'amount' => ''
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/ntp1/issue', [
  'body' => '{
  "amount": "",
  "divisibility": "",
  "fee": "",
  "flags": {
    "splitChange": false
  },
  "issueAddress": "",
  "metadata": {
    "description": "",
    "encryptions": [
      {
        "format": "",
        "key": "",
        "pubkey": "",
        "type": ""
      }
    ],
    "issuer": "",
    "rules": {
      "expiration": {
        "locked": false,
        "validUntil": ""
      },
      "fees": {
        "items": [
          {
            "address": "",
            "tokenId": "",
            "value": ""
          }
        ],
        "locked": false
      },
      "holders": [
        {
          "address": "",
          "locked": false
        }
      ]
    },
    "tokenName": "",
    "urls": [
      {
        "dataHash": "",
        "mimeType": "",
        "name": "",
        "url": ""
      }
    ],
    "userData": {
      "meta": [
        {
          "key": "",
          "value": ""
        }
      ]
    }
  },
  "reissuable": false,
  "transfer": [
    {
      "address": "",
      "amount": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/ntp1/issue');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'amount' => '',
  'divisibility' => '',
  'fee' => '',
  'flags' => [
    'splitChange' => null
  ],
  'issueAddress' => '',
  'metadata' => [
    'description' => '',
    'encryptions' => [
        [
                'format' => '',
                'key' => '',
                'pubkey' => '',
                'type' => ''
        ]
    ],
    'issuer' => '',
    'rules' => [
        'expiration' => [
                'locked' => null,
                'validUntil' => ''
        ],
        'fees' => [
                'items' => [
                                [
                                                                'address' => '',
                                                                'tokenId' => '',
                                                                'value' => ''
                                ]
                ],
                'locked' => null
        ],
        'holders' => [
                [
                                'address' => '',
                                'locked' => null
                ]
        ]
    ],
    'tokenName' => '',
    'urls' => [
        [
                'dataHash' => '',
                'mimeType' => '',
                'name' => '',
                'url' => ''
        ]
    ],
    'userData' => [
        'meta' => [
                [
                                'key' => '',
                                'value' => ''
                ]
        ]
    ]
  ],
  'reissuable' => null,
  'transfer' => [
    [
        'address' => '',
        'amount' => ''
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'amount' => '',
  'divisibility' => '',
  'fee' => '',
  'flags' => [
    'splitChange' => null
  ],
  'issueAddress' => '',
  'metadata' => [
    'description' => '',
    'encryptions' => [
        [
                'format' => '',
                'key' => '',
                'pubkey' => '',
                'type' => ''
        ]
    ],
    'issuer' => '',
    'rules' => [
        'expiration' => [
                'locked' => null,
                'validUntil' => ''
        ],
        'fees' => [
                'items' => [
                                [
                                                                'address' => '',
                                                                'tokenId' => '',
                                                                'value' => ''
                                ]
                ],
                'locked' => null
        ],
        'holders' => [
                [
                                'address' => '',
                                'locked' => null
                ]
        ]
    ],
    'tokenName' => '',
    'urls' => [
        [
                'dataHash' => '',
                'mimeType' => '',
                'name' => '',
                'url' => ''
        ]
    ],
    'userData' => [
        'meta' => [
                [
                                'key' => '',
                                'value' => ''
                ]
        ]
    ]
  ],
  'reissuable' => null,
  'transfer' => [
    [
        'address' => '',
        'amount' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/ntp1/issue');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/ntp1/issue' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "amount": "",
  "divisibility": "",
  "fee": "",
  "flags": {
    "splitChange": false
  },
  "issueAddress": "",
  "metadata": {
    "description": "",
    "encryptions": [
      {
        "format": "",
        "key": "",
        "pubkey": "",
        "type": ""
      }
    ],
    "issuer": "",
    "rules": {
      "expiration": {
        "locked": false,
        "validUntil": ""
      },
      "fees": {
        "items": [
          {
            "address": "",
            "tokenId": "",
            "value": ""
          }
        ],
        "locked": false
      },
      "holders": [
        {
          "address": "",
          "locked": false
        }
      ]
    },
    "tokenName": "",
    "urls": [
      {
        "dataHash": "",
        "mimeType": "",
        "name": "",
        "url": ""
      }
    ],
    "userData": {
      "meta": [
        {
          "key": "",
          "value": ""
        }
      ]
    }
  },
  "reissuable": false,
  "transfer": [
    {
      "address": "",
      "amount": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/ntp1/issue' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "amount": "",
  "divisibility": "",
  "fee": "",
  "flags": {
    "splitChange": false
  },
  "issueAddress": "",
  "metadata": {
    "description": "",
    "encryptions": [
      {
        "format": "",
        "key": "",
        "pubkey": "",
        "type": ""
      }
    ],
    "issuer": "",
    "rules": {
      "expiration": {
        "locked": false,
        "validUntil": ""
      },
      "fees": {
        "items": [
          {
            "address": "",
            "tokenId": "",
            "value": ""
          }
        ],
        "locked": false
      },
      "holders": [
        {
          "address": "",
          "locked": false
        }
      ]
    },
    "tokenName": "",
    "urls": [
      {
        "dataHash": "",
        "mimeType": "",
        "name": "",
        "url": ""
      }
    ],
    "userData": {
      "meta": [
        {
          "key": "",
          "value": ""
        }
      ]
    }
  },
  "reissuable": false,
  "transfer": [
    {
      "address": "",
      "amount": ""
    }
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"amount\": \"\",\n  \"divisibility\": \"\",\n  \"fee\": \"\",\n  \"flags\": {\n    \"splitChange\": false\n  },\n  \"issueAddress\": \"\",\n  \"metadata\": {\n    \"description\": \"\",\n    \"encryptions\": [\n      {\n        \"format\": \"\",\n        \"key\": \"\",\n        \"pubkey\": \"\",\n        \"type\": \"\"\n      }\n    ],\n    \"issuer\": \"\",\n    \"rules\": {\n      \"expiration\": {\n        \"locked\": false,\n        \"validUntil\": \"\"\n      },\n      \"fees\": {\n        \"items\": [\n          {\n            \"address\": \"\",\n            \"tokenId\": \"\",\n            \"value\": \"\"\n          }\n        ],\n        \"locked\": false\n      },\n      \"holders\": [\n        {\n          \"address\": \"\",\n          \"locked\": false\n        }\n      ]\n    },\n    \"tokenName\": \"\",\n    \"urls\": [\n      {\n        \"dataHash\": \"\",\n        \"mimeType\": \"\",\n        \"name\": \"\",\n        \"url\": \"\"\n      }\n    ],\n    \"userData\": {\n      \"meta\": [\n        {\n          \"key\": \"\",\n          \"value\": \"\"\n        }\n      ]\n    }\n  },\n  \"reissuable\": false,\n  \"transfer\": [\n    {\n      \"address\": \"\",\n      \"amount\": \"\"\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/ntp1/issue", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/ntp1/issue"

payload = {
    "amount": "",
    "divisibility": "",
    "fee": "",
    "flags": { "splitChange": False },
    "issueAddress": "",
    "metadata": {
        "description": "",
        "encryptions": [
            {
                "format": "",
                "key": "",
                "pubkey": "",
                "type": ""
            }
        ],
        "issuer": "",
        "rules": {
            "expiration": {
                "locked": False,
                "validUntil": ""
            },
            "fees": {
                "items": [
                    {
                        "address": "",
                        "tokenId": "",
                        "value": ""
                    }
                ],
                "locked": False
            },
            "holders": [
                {
                    "address": "",
                    "locked": False
                }
            ]
        },
        "tokenName": "",
        "urls": [
            {
                "dataHash": "",
                "mimeType": "",
                "name": "",
                "url": ""
            }
        ],
        "userData": { "meta": [
                {
                    "key": "",
                    "value": ""
                }
            ] }
    },
    "reissuable": False,
    "transfer": [
        {
            "address": "",
            "amount": ""
        }
    ]
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/ntp1/issue"

payload <- "{\n  \"amount\": \"\",\n  \"divisibility\": \"\",\n  \"fee\": \"\",\n  \"flags\": {\n    \"splitChange\": false\n  },\n  \"issueAddress\": \"\",\n  \"metadata\": {\n    \"description\": \"\",\n    \"encryptions\": [\n      {\n        \"format\": \"\",\n        \"key\": \"\",\n        \"pubkey\": \"\",\n        \"type\": \"\"\n      }\n    ],\n    \"issuer\": \"\",\n    \"rules\": {\n      \"expiration\": {\n        \"locked\": false,\n        \"validUntil\": \"\"\n      },\n      \"fees\": {\n        \"items\": [\n          {\n            \"address\": \"\",\n            \"tokenId\": \"\",\n            \"value\": \"\"\n          }\n        ],\n        \"locked\": false\n      },\n      \"holders\": [\n        {\n          \"address\": \"\",\n          \"locked\": false\n        }\n      ]\n    },\n    \"tokenName\": \"\",\n    \"urls\": [\n      {\n        \"dataHash\": \"\",\n        \"mimeType\": \"\",\n        \"name\": \"\",\n        \"url\": \"\"\n      }\n    ],\n    \"userData\": {\n      \"meta\": [\n        {\n          \"key\": \"\",\n          \"value\": \"\"\n        }\n      ]\n    }\n  },\n  \"reissuable\": false,\n  \"transfer\": [\n    {\n      \"address\": \"\",\n      \"amount\": \"\"\n    }\n  ]\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/ntp1/issue")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"amount\": \"\",\n  \"divisibility\": \"\",\n  \"fee\": \"\",\n  \"flags\": {\n    \"splitChange\": false\n  },\n  \"issueAddress\": \"\",\n  \"metadata\": {\n    \"description\": \"\",\n    \"encryptions\": [\n      {\n        \"format\": \"\",\n        \"key\": \"\",\n        \"pubkey\": \"\",\n        \"type\": \"\"\n      }\n    ],\n    \"issuer\": \"\",\n    \"rules\": {\n      \"expiration\": {\n        \"locked\": false,\n        \"validUntil\": \"\"\n      },\n      \"fees\": {\n        \"items\": [\n          {\n            \"address\": \"\",\n            \"tokenId\": \"\",\n            \"value\": \"\"\n          }\n        ],\n        \"locked\": false\n      },\n      \"holders\": [\n        {\n          \"address\": \"\",\n          \"locked\": false\n        }\n      ]\n    },\n    \"tokenName\": \"\",\n    \"urls\": [\n      {\n        \"dataHash\": \"\",\n        \"mimeType\": \"\",\n        \"name\": \"\",\n        \"url\": \"\"\n      }\n    ],\n    \"userData\": {\n      \"meta\": [\n        {\n          \"key\": \"\",\n          \"value\": \"\"\n        }\n      ]\n    }\n  },\n  \"reissuable\": false,\n  \"transfer\": [\n    {\n      \"address\": \"\",\n      \"amount\": \"\"\n    }\n  ]\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/ntp1/issue') do |req|
  req.body = "{\n  \"amount\": \"\",\n  \"divisibility\": \"\",\n  \"fee\": \"\",\n  \"flags\": {\n    \"splitChange\": false\n  },\n  \"issueAddress\": \"\",\n  \"metadata\": {\n    \"description\": \"\",\n    \"encryptions\": [\n      {\n        \"format\": \"\",\n        \"key\": \"\",\n        \"pubkey\": \"\",\n        \"type\": \"\"\n      }\n    ],\n    \"issuer\": \"\",\n    \"rules\": {\n      \"expiration\": {\n        \"locked\": false,\n        \"validUntil\": \"\"\n      },\n      \"fees\": {\n        \"items\": [\n          {\n            \"address\": \"\",\n            \"tokenId\": \"\",\n            \"value\": \"\"\n          }\n        ],\n        \"locked\": false\n      },\n      \"holders\": [\n        {\n          \"address\": \"\",\n          \"locked\": false\n        }\n      ]\n    },\n    \"tokenName\": \"\",\n    \"urls\": [\n      {\n        \"dataHash\": \"\",\n        \"mimeType\": \"\",\n        \"name\": \"\",\n        \"url\": \"\"\n      }\n    ],\n    \"userData\": {\n      \"meta\": [\n        {\n          \"key\": \"\",\n          \"value\": \"\"\n        }\n      ]\n    }\n  },\n  \"reissuable\": false,\n  \"transfer\": [\n    {\n      \"address\": \"\",\n      \"amount\": \"\"\n    }\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/ntp1/issue";

    let payload = json!({
        "amount": "",
        "divisibility": "",
        "fee": "",
        "flags": json!({"splitChange": false}),
        "issueAddress": "",
        "metadata": json!({
            "description": "",
            "encryptions": (
                json!({
                    "format": "",
                    "key": "",
                    "pubkey": "",
                    "type": ""
                })
            ),
            "issuer": "",
            "rules": json!({
                "expiration": json!({
                    "locked": false,
                    "validUntil": ""
                }),
                "fees": json!({
                    "items": (
                        json!({
                            "address": "",
                            "tokenId": "",
                            "value": ""
                        })
                    ),
                    "locked": false
                }),
                "holders": (
                    json!({
                        "address": "",
                        "locked": false
                    })
                )
            }),
            "tokenName": "",
            "urls": (
                json!({
                    "dataHash": "",
                    "mimeType": "",
                    "name": "",
                    "url": ""
                })
            ),
            "userData": json!({"meta": (
                    json!({
                        "key": "",
                        "value": ""
                    })
                )})
        }),
        "reissuable": false,
        "transfer": (
            json!({
                "address": "",
                "amount": ""
            })
        )
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/ntp1/issue \
  --header 'content-type: application/json' \
  --data '{
  "amount": "",
  "divisibility": "",
  "fee": "",
  "flags": {
    "splitChange": false
  },
  "issueAddress": "",
  "metadata": {
    "description": "",
    "encryptions": [
      {
        "format": "",
        "key": "",
        "pubkey": "",
        "type": ""
      }
    ],
    "issuer": "",
    "rules": {
      "expiration": {
        "locked": false,
        "validUntil": ""
      },
      "fees": {
        "items": [
          {
            "address": "",
            "tokenId": "",
            "value": ""
          }
        ],
        "locked": false
      },
      "holders": [
        {
          "address": "",
          "locked": false
        }
      ]
    },
    "tokenName": "",
    "urls": [
      {
        "dataHash": "",
        "mimeType": "",
        "name": "",
        "url": ""
      }
    ],
    "userData": {
      "meta": [
        {
          "key": "",
          "value": ""
        }
      ]
    }
  },
  "reissuable": false,
  "transfer": [
    {
      "address": "",
      "amount": ""
    }
  ]
}'

echo '{
  "amount": "",
  "divisibility": "",
  "fee": "",
  "flags": {
    "splitChange": false
  },
  "issueAddress": "",
  "metadata": {
    "description": "",
    "encryptions": [
      {
        "format": "",
        "key": "",
        "pubkey": "",
        "type": ""
      }
    ],
    "issuer": "",
    "rules": {
      "expiration": {
        "locked": false,
        "validUntil": ""
      },
      "fees": {
        "items": [
          {
            "address": "",
            "tokenId": "",
            "value": ""
          }
        ],
        "locked": false
      },
      "holders": [
        {
          "address": "",
          "locked": false
        }
      ]
    },
    "tokenName": "",
    "urls": [
      {
        "dataHash": "",
        "mimeType": "",
        "name": "",
        "url": ""
      }
    ],
    "userData": {
      "meta": [
        {
          "key": "",
          "value": ""
        }
      ]
    }
  },
  "reissuable": false,
  "transfer": [
    {
      "address": "",
      "amount": ""
    }
  ]
}' |  \
  http POST {{baseUrl}}/ntp1/issue \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "amount": "",\n  "divisibility": "",\n  "fee": "",\n  "flags": {\n    "splitChange": false\n  },\n  "issueAddress": "",\n  "metadata": {\n    "description": "",\n    "encryptions": [\n      {\n        "format": "",\n        "key": "",\n        "pubkey": "",\n        "type": ""\n      }\n    ],\n    "issuer": "",\n    "rules": {\n      "expiration": {\n        "locked": false,\n        "validUntil": ""\n      },\n      "fees": {\n        "items": [\n          {\n            "address": "",\n            "tokenId": "",\n            "value": ""\n          }\n        ],\n        "locked": false\n      },\n      "holders": [\n        {\n          "address": "",\n          "locked": false\n        }\n      ]\n    },\n    "tokenName": "",\n    "urls": [\n      {\n        "dataHash": "",\n        "mimeType": "",\n        "name": "",\n        "url": ""\n      }\n    ],\n    "userData": {\n      "meta": [\n        {\n          "key": "",\n          "value": ""\n        }\n      ]\n    }\n  },\n  "reissuable": false,\n  "transfer": [\n    {\n      "address": "",\n      "amount": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/ntp1/issue

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "amount": "",
  "divisibility": "",
  "fee": "",
  "flags": ["splitChange": false],
  "issueAddress": "",
  "metadata": [
    "description": "",
    "encryptions": [
      [
        "format": "",
        "key": "",
        "pubkey": "",
        "type": ""
      ]
    ],
    "issuer": "",
    "rules": [
      "expiration": [
        "locked": false,
        "validUntil": ""
      ],
      "fees": [
        "items": [
          [
            "address": "",
            "tokenId": "",
            "value": ""
          ]
        ],
        "locked": false
      ],
      "holders": [
        [
          "address": "",
          "locked": false
        ]
      ]
    ],
    "tokenName": "",
    "urls": [
      [
        "dataHash": "",
        "mimeType": "",
        "name": "",
        "url": ""
      ]
    ],
    "userData": ["meta": [
        [
          "key": "",
          "value": ""
        ]
      ]]
  ],
  "reissuable": false,
  "transfer": [
    [
      "address": "",
      "amount": ""
    ]
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/ntp1/issue")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Builds a transaction that sends an NTP1 Token

{{baseUrl}}/ntp1/sendtoken

BODY json

{
  "fee": "",
  "flags": {
    "splitChange": false
  },
  "from": [],
  "metadata": {
    "description": "",
    "encryptions": [
      {
        "format": "",
        "key": "",
        "pubkey": "",
        "type": ""
      }
    ],
    "issuer": "",
    "rules": {
      "expiration": {
        "locked": false,
        "validUntil": ""
      },
      "fees": {
        "items": [
          {
            "address": "",
            "tokenId": "",
            "value": ""
          }
        ],
        "locked": false
      },
      "holders": [
        {
          "address": "",
          "locked": false
        }
      ]
    },
    "tokenName": "",
    "urls": [
      {
        "dataHash": "",
        "mimeType": "",
        "name": "",
        "url": ""
      }
    ],
    "userData": {
      "meta": [
        {
          "key": "",
          "value": ""
        }
      ]
    }
  },
  "sendutxo": [],
  "to": [
    {
      "address": "",
      "amount": "",
      "tokenId": ""
    }
  ]
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/ntp1/sendtoken");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"fee\": \"\",\n  \"flags\": {\n    \"splitChange\": false\n  },\n  \"from\": [],\n  \"metadata\": {\n    \"description\": \"\",\n    \"encryptions\": [\n      {\n        \"format\": \"\",\n        \"key\": \"\",\n        \"pubkey\": \"\",\n        \"type\": \"\"\n      }\n    ],\n    \"issuer\": \"\",\n    \"rules\": {\n      \"expiration\": {\n        \"locked\": false,\n        \"validUntil\": \"\"\n      },\n      \"fees\": {\n        \"items\": [\n          {\n            \"address\": \"\",\n            \"tokenId\": \"\",\n            \"value\": \"\"\n          }\n        ],\n        \"locked\": false\n      },\n      \"holders\": [\n        {\n          \"address\": \"\",\n          \"locked\": false\n        }\n      ]\n    },\n    \"tokenName\": \"\",\n    \"urls\": [\n      {\n        \"dataHash\": \"\",\n        \"mimeType\": \"\",\n        \"name\": \"\",\n        \"url\": \"\"\n      }\n    ],\n    \"userData\": {\n      \"meta\": [\n        {\n          \"key\": \"\",\n          \"value\": \"\"\n        }\n      ]\n    }\n  },\n  \"sendutxo\": [],\n  \"to\": [\n    {\n      \"address\": \"\",\n      \"amount\": \"\",\n      \"tokenId\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/ntp1/sendtoken" {:content-type :json
                                                           :form-params {:fee ""
                                                                         :flags {:splitChange false}
                                                                         :from []
                                                                         :metadata {:description ""
                                                                                    :encryptions [{:format ""
                                                                                                   :key ""
                                                                                                   :pubkey ""
                                                                                                   :type ""}]
                                                                                    :issuer ""
                                                                                    :rules {:expiration {:locked false
                                                                                                         :validUntil ""}
                                                                                            :fees {:items [{:address ""
                                                                                                            :tokenId ""
                                                                                                            :value ""}]
                                                                                                   :locked false}
                                                                                            :holders [{:address ""
                                                                                                       :locked false}]}
                                                                                    :tokenName ""
                                                                                    :urls [{:dataHash ""
                                                                                            :mimeType ""
                                                                                            :name ""
                                                                                            :url ""}]
                                                                                    :userData {:meta [{:key ""
                                                                                                       :value ""}]}}
                                                                         :sendutxo []
                                                                         :to [{:address ""
                                                                               :amount ""
                                                                               :tokenId ""}]}})

require "http/client"

url = "{{baseUrl}}/ntp1/sendtoken"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"fee\": \"\",\n  \"flags\": {\n    \"splitChange\": false\n  },\n  \"from\": [],\n  \"metadata\": {\n    \"description\": \"\",\n    \"encryptions\": [\n      {\n        \"format\": \"\",\n        \"key\": \"\",\n        \"pubkey\": \"\",\n        \"type\": \"\"\n      }\n    ],\n    \"issuer\": \"\",\n    \"rules\": {\n      \"expiration\": {\n        \"locked\": false,\n        \"validUntil\": \"\"\n      },\n      \"fees\": {\n        \"items\": [\n          {\n            \"address\": \"\",\n            \"tokenId\": \"\",\n            \"value\": \"\"\n          }\n        ],\n        \"locked\": false\n      },\n      \"holders\": [\n        {\n          \"address\": \"\",\n          \"locked\": false\n        }\n      ]\n    },\n    \"tokenName\": \"\",\n    \"urls\": [\n      {\n        \"dataHash\": \"\",\n        \"mimeType\": \"\",\n        \"name\": \"\",\n        \"url\": \"\"\n      }\n    ],\n    \"userData\": {\n      \"meta\": [\n        {\n          \"key\": \"\",\n          \"value\": \"\"\n        }\n      ]\n    }\n  },\n  \"sendutxo\": [],\n  \"to\": [\n    {\n      \"address\": \"\",\n      \"amount\": \"\",\n      \"tokenId\": \"\"\n    }\n  ]\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/ntp1/sendtoken"),
    Content = new StringContent("{\n  \"fee\": \"\",\n  \"flags\": {\n    \"splitChange\": false\n  },\n  \"from\": [],\n  \"metadata\": {\n    \"description\": \"\",\n    \"encryptions\": [\n      {\n        \"format\": \"\",\n        \"key\": \"\",\n        \"pubkey\": \"\",\n        \"type\": \"\"\n      }\n    ],\n    \"issuer\": \"\",\n    \"rules\": {\n      \"expiration\": {\n        \"locked\": false,\n        \"validUntil\": \"\"\n      },\n      \"fees\": {\n        \"items\": [\n          {\n            \"address\": \"\",\n            \"tokenId\": \"\",\n            \"value\": \"\"\n          }\n        ],\n        \"locked\": false\n      },\n      \"holders\": [\n        {\n          \"address\": \"\",\n          \"locked\": false\n        }\n      ]\n    },\n    \"tokenName\": \"\",\n    \"urls\": [\n      {\n        \"dataHash\": \"\",\n        \"mimeType\": \"\",\n        \"name\": \"\",\n        \"url\": \"\"\n      }\n    ],\n    \"userData\": {\n      \"meta\": [\n        {\n          \"key\": \"\",\n          \"value\": \"\"\n        }\n      ]\n    }\n  },\n  \"sendutxo\": [],\n  \"to\": [\n    {\n      \"address\": \"\",\n      \"amount\": \"\",\n      \"tokenId\": \"\"\n    }\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/ntp1/sendtoken");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"fee\": \"\",\n  \"flags\": {\n    \"splitChange\": false\n  },\n  \"from\": [],\n  \"metadata\": {\n    \"description\": \"\",\n    \"encryptions\": [\n      {\n        \"format\": \"\",\n        \"key\": \"\",\n        \"pubkey\": \"\",\n        \"type\": \"\"\n      }\n    ],\n    \"issuer\": \"\",\n    \"rules\": {\n      \"expiration\": {\n        \"locked\": false,\n        \"validUntil\": \"\"\n      },\n      \"fees\": {\n        \"items\": [\n          {\n            \"address\": \"\",\n            \"tokenId\": \"\",\n            \"value\": \"\"\n          }\n        ],\n        \"locked\": false\n      },\n      \"holders\": [\n        {\n          \"address\": \"\",\n          \"locked\": false\n        }\n      ]\n    },\n    \"tokenName\": \"\",\n    \"urls\": [\n      {\n        \"dataHash\": \"\",\n        \"mimeType\": \"\",\n        \"name\": \"\",\n        \"url\": \"\"\n      }\n    ],\n    \"userData\": {\n      \"meta\": [\n        {\n          \"key\": \"\",\n          \"value\": \"\"\n        }\n      ]\n    }\n  },\n  \"sendutxo\": [],\n  \"to\": [\n    {\n      \"address\": \"\",\n      \"amount\": \"\",\n      \"tokenId\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/ntp1/sendtoken"

	payload := strings.NewReader("{\n  \"fee\": \"\",\n  \"flags\": {\n    \"splitChange\": false\n  },\n  \"from\": [],\n  \"metadata\": {\n    \"description\": \"\",\n    \"encryptions\": [\n      {\n        \"format\": \"\",\n        \"key\": \"\",\n        \"pubkey\": \"\",\n        \"type\": \"\"\n      }\n    ],\n    \"issuer\": \"\",\n    \"rules\": {\n      \"expiration\": {\n        \"locked\": false,\n        \"validUntil\": \"\"\n      },\n      \"fees\": {\n        \"items\": [\n          {\n            \"address\": \"\",\n            \"tokenId\": \"\",\n            \"value\": \"\"\n          }\n        ],\n        \"locked\": false\n      },\n      \"holders\": [\n        {\n          \"address\": \"\",\n          \"locked\": false\n        }\n      ]\n    },\n    \"tokenName\": \"\",\n    \"urls\": [\n      {\n        \"dataHash\": \"\",\n        \"mimeType\": \"\",\n        \"name\": \"\",\n        \"url\": \"\"\n      }\n    ],\n    \"userData\": {\n      \"meta\": [\n        {\n          \"key\": \"\",\n          \"value\": \"\"\n        }\n      ]\n    }\n  },\n  \"sendutxo\": [],\n  \"to\": [\n    {\n      \"address\": \"\",\n      \"amount\": \"\",\n      \"tokenId\": \"\"\n    }\n  ]\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ntp1/sendtoken HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 1003

{
  "fee": "",
  "flags": {
    "splitChange": false
  },
  "from": [],
  "metadata": {
    "description": "",
    "encryptions": [
      {
        "format": "",
        "key": "",
        "pubkey": "",
        "type": ""
      }
    ],
    "issuer": "",
    "rules": {
      "expiration": {
        "locked": false,
        "validUntil": ""
      },
      "fees": {
        "items": [
          {
            "address": "",
            "tokenId": "",
            "value": ""
          }
        ],
        "locked": false
      },
      "holders": [
        {
          "address": "",
          "locked": false
        }
      ]
    },
    "tokenName": "",
    "urls": [
      {
        "dataHash": "",
        "mimeType": "",
        "name": "",
        "url": ""
      }
    ],
    "userData": {
      "meta": [
        {
          "key": "",
          "value": ""
        }
      ]
    }
  },
  "sendutxo": [],
  "to": [
    {
      "address": "",
      "amount": "",
      "tokenId": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/ntp1/sendtoken")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"fee\": \"\",\n  \"flags\": {\n    \"splitChange\": false\n  },\n  \"from\": [],\n  \"metadata\": {\n    \"description\": \"\",\n    \"encryptions\": [\n      {\n        \"format\": \"\",\n        \"key\": \"\",\n        \"pubkey\": \"\",\n        \"type\": \"\"\n      }\n    ],\n    \"issuer\": \"\",\n    \"rules\": {\n      \"expiration\": {\n        \"locked\": false,\n        \"validUntil\": \"\"\n      },\n      \"fees\": {\n        \"items\": [\n          {\n            \"address\": \"\",\n            \"tokenId\": \"\",\n            \"value\": \"\"\n          }\n        ],\n        \"locked\": false\n      },\n      \"holders\": [\n        {\n          \"address\": \"\",\n          \"locked\": false\n        }\n      ]\n    },\n    \"tokenName\": \"\",\n    \"urls\": [\n      {\n        \"dataHash\": \"\",\n        \"mimeType\": \"\",\n        \"name\": \"\",\n        \"url\": \"\"\n      }\n    ],\n    \"userData\": {\n      \"meta\": [\n        {\n          \"key\": \"\",\n          \"value\": \"\"\n        }\n      ]\n    }\n  },\n  \"sendutxo\": [],\n  \"to\": [\n    {\n      \"address\": \"\",\n      \"amount\": \"\",\n      \"tokenId\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/ntp1/sendtoken"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"fee\": \"\",\n  \"flags\": {\n    \"splitChange\": false\n  },\n  \"from\": [],\n  \"metadata\": {\n    \"description\": \"\",\n    \"encryptions\": [\n      {\n        \"format\": \"\",\n        \"key\": \"\",\n        \"pubkey\": \"\",\n        \"type\": \"\"\n      }\n    ],\n    \"issuer\": \"\",\n    \"rules\": {\n      \"expiration\": {\n        \"locked\": false,\n        \"validUntil\": \"\"\n      },\n      \"fees\": {\n        \"items\": [\n          {\n            \"address\": \"\",\n            \"tokenId\": \"\",\n            \"value\": \"\"\n          }\n        ],\n        \"locked\": false\n      },\n      \"holders\": [\n        {\n          \"address\": \"\",\n          \"locked\": false\n        }\n      ]\n    },\n    \"tokenName\": \"\",\n    \"urls\": [\n      {\n        \"dataHash\": \"\",\n        \"mimeType\": \"\",\n        \"name\": \"\",\n        \"url\": \"\"\n      }\n    ],\n    \"userData\": {\n      \"meta\": [\n        {\n          \"key\": \"\",\n          \"value\": \"\"\n        }\n      ]\n    }\n  },\n  \"sendutxo\": [],\n  \"to\": [\n    {\n      \"address\": \"\",\n      \"amount\": \"\",\n      \"tokenId\": \"\"\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"fee\": \"\",\n  \"flags\": {\n    \"splitChange\": false\n  },\n  \"from\": [],\n  \"metadata\": {\n    \"description\": \"\",\n    \"encryptions\": [\n      {\n        \"format\": \"\",\n        \"key\": \"\",\n        \"pubkey\": \"\",\n        \"type\": \"\"\n      }\n    ],\n    \"issuer\": \"\",\n    \"rules\": {\n      \"expiration\": {\n        \"locked\": false,\n        \"validUntil\": \"\"\n      },\n      \"fees\": {\n        \"items\": [\n          {\n            \"address\": \"\",\n            \"tokenId\": \"\",\n            \"value\": \"\"\n          }\n        ],\n        \"locked\": false\n      },\n      \"holders\": [\n        {\n          \"address\": \"\",\n          \"locked\": false\n        }\n      ]\n    },\n    \"tokenName\": \"\",\n    \"urls\": [\n      {\n        \"dataHash\": \"\",\n        \"mimeType\": \"\",\n        \"name\": \"\",\n        \"url\": \"\"\n      }\n    ],\n    \"userData\": {\n      \"meta\": [\n        {\n          \"key\": \"\",\n          \"value\": \"\"\n        }\n      ]\n    }\n  },\n  \"sendutxo\": [],\n  \"to\": [\n    {\n      \"address\": \"\",\n      \"amount\": \"\",\n      \"tokenId\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/ntp1/sendtoken")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/ntp1/sendtoken")
  .header("content-type", "application/json")
  .body("{\n  \"fee\": \"\",\n  \"flags\": {\n    \"splitChange\": false\n  },\n  \"from\": [],\n  \"metadata\": {\n    \"description\": \"\",\n    \"encryptions\": [\n      {\n        \"format\": \"\",\n        \"key\": \"\",\n        \"pubkey\": \"\",\n        \"type\": \"\"\n      }\n    ],\n    \"issuer\": \"\",\n    \"rules\": {\n      \"expiration\": {\n        \"locked\": false,\n        \"validUntil\": \"\"\n      },\n      \"fees\": {\n        \"items\": [\n          {\n            \"address\": \"\",\n            \"tokenId\": \"\",\n            \"value\": \"\"\n          }\n        ],\n        \"locked\": false\n      },\n      \"holders\": [\n        {\n          \"address\": \"\",\n          \"locked\": false\n        }\n      ]\n    },\n    \"tokenName\": \"\",\n    \"urls\": [\n      {\n        \"dataHash\": \"\",\n        \"mimeType\": \"\",\n        \"name\": \"\",\n        \"url\": \"\"\n      }\n    ],\n    \"userData\": {\n      \"meta\": [\n        {\n          \"key\": \"\",\n          \"value\": \"\"\n        }\n      ]\n    }\n  },\n  \"sendutxo\": [],\n  \"to\": [\n    {\n      \"address\": \"\",\n      \"amount\": \"\",\n      \"tokenId\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  fee: '',
  flags: {
    splitChange: false
  },
  from: [],
  metadata: {
    description: '',
    encryptions: [
      {
        format: '',
        key: '',
        pubkey: '',
        type: ''
      }
    ],
    issuer: '',
    rules: {
      expiration: {
        locked: false,
        validUntil: ''
      },
      fees: {
        items: [
          {
            address: '',
            tokenId: '',
            value: ''
          }
        ],
        locked: false
      },
      holders: [
        {
          address: '',
          locked: false
        }
      ]
    },
    tokenName: '',
    urls: [
      {
        dataHash: '',
        mimeType: '',
        name: '',
        url: ''
      }
    ],
    userData: {
      meta: [
        {
          key: '',
          value: ''
        }
      ]
    }
  },
  sendutxo: [],
  to: [
    {
      address: '',
      amount: '',
      tokenId: ''
    }
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/ntp1/sendtoken');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/ntp1/sendtoken',
  headers: {'content-type': 'application/json'},
  data: {
    fee: '',
    flags: {splitChange: false},
    from: [],
    metadata: {
      description: '',
      encryptions: [{format: '', key: '', pubkey: '', type: ''}],
      issuer: '',
      rules: {
        expiration: {locked: false, validUntil: ''},
        fees: {items: [{address: '', tokenId: '', value: ''}], locked: false},
        holders: [{address: '', locked: false}]
      },
      tokenName: '',
      urls: [{dataHash: '', mimeType: '', name: '', url: ''}],
      userData: {meta: [{key: '', value: ''}]}
    },
    sendutxo: [],
    to: [{address: '', amount: '', tokenId: ''}]
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/ntp1/sendtoken';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"fee":"","flags":{"splitChange":false},"from":[],"metadata":{"description":"","encryptions":[{"format":"","key":"","pubkey":"","type":""}],"issuer":"","rules":{"expiration":{"locked":false,"validUntil":""},"fees":{"items":[{"address":"","tokenId":"","value":""}],"locked":false},"holders":[{"address":"","locked":false}]},"tokenName":"","urls":[{"dataHash":"","mimeType":"","name":"","url":""}],"userData":{"meta":[{"key":"","value":""}]}},"sendutxo":[],"to":[{"address":"","amount":"","tokenId":""}]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/ntp1/sendtoken',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "fee": "",\n  "flags": {\n    "splitChange": false\n  },\n  "from": [],\n  "metadata": {\n    "description": "",\n    "encryptions": [\n      {\n        "format": "",\n        "key": "",\n        "pubkey": "",\n        "type": ""\n      }\n    ],\n    "issuer": "",\n    "rules": {\n      "expiration": {\n        "locked": false,\n        "validUntil": ""\n      },\n      "fees": {\n        "items": [\n          {\n            "address": "",\n            "tokenId": "",\n            "value": ""\n          }\n        ],\n        "locked": false\n      },\n      "holders": [\n        {\n          "address": "",\n          "locked": false\n        }\n      ]\n    },\n    "tokenName": "",\n    "urls": [\n      {\n        "dataHash": "",\n        "mimeType": "",\n        "name": "",\n        "url": ""\n      }\n    ],\n    "userData": {\n      "meta": [\n        {\n          "key": "",\n          "value": ""\n        }\n      ]\n    }\n  },\n  "sendutxo": [],\n  "to": [\n    {\n      "address": "",\n      "amount": "",\n      "tokenId": ""\n    }\n  ]\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"fee\": \"\",\n  \"flags\": {\n    \"splitChange\": false\n  },\n  \"from\": [],\n  \"metadata\": {\n    \"description\": \"\",\n    \"encryptions\": [\n      {\n        \"format\": \"\",\n        \"key\": \"\",\n        \"pubkey\": \"\",\n        \"type\": \"\"\n      }\n    ],\n    \"issuer\": \"\",\n    \"rules\": {\n      \"expiration\": {\n        \"locked\": false,\n        \"validUntil\": \"\"\n      },\n      \"fees\": {\n        \"items\": [\n          {\n            \"address\": \"\",\n            \"tokenId\": \"\",\n            \"value\": \"\"\n          }\n        ],\n        \"locked\": false\n      },\n      \"holders\": [\n        {\n          \"address\": \"\",\n          \"locked\": false\n        }\n      ]\n    },\n    \"tokenName\": \"\",\n    \"urls\": [\n      {\n        \"dataHash\": \"\",\n        \"mimeType\": \"\",\n        \"name\": \"\",\n        \"url\": \"\"\n      }\n    ],\n    \"userData\": {\n      \"meta\": [\n        {\n          \"key\": \"\",\n          \"value\": \"\"\n        }\n      ]\n    }\n  },\n  \"sendutxo\": [],\n  \"to\": [\n    {\n      \"address\": \"\",\n      \"amount\": \"\",\n      \"tokenId\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/ntp1/sendtoken")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/ntp1/sendtoken',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  fee: '',
  flags: {splitChange: false},
  from: [],
  metadata: {
    description: '',
    encryptions: [{format: '', key: '', pubkey: '', type: ''}],
    issuer: '',
    rules: {
      expiration: {locked: false, validUntil: ''},
      fees: {items: [{address: '', tokenId: '', value: ''}], locked: false},
      holders: [{address: '', locked: false}]
    },
    tokenName: '',
    urls: [{dataHash: '', mimeType: '', name: '', url: ''}],
    userData: {meta: [{key: '', value: ''}]}
  },
  sendutxo: [],
  to: [{address: '', amount: '', tokenId: ''}]
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/ntp1/sendtoken',
  headers: {'content-type': 'application/json'},
  body: {
    fee: '',
    flags: {splitChange: false},
    from: [],
    metadata: {
      description: '',
      encryptions: [{format: '', key: '', pubkey: '', type: ''}],
      issuer: '',
      rules: {
        expiration: {locked: false, validUntil: ''},
        fees: {items: [{address: '', tokenId: '', value: ''}], locked: false},
        holders: [{address: '', locked: false}]
      },
      tokenName: '',
      urls: [{dataHash: '', mimeType: '', name: '', url: ''}],
      userData: {meta: [{key: '', value: ''}]}
    },
    sendutxo: [],
    to: [{address: '', amount: '', tokenId: ''}]
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/ntp1/sendtoken');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  fee: '',
  flags: {
    splitChange: false
  },
  from: [],
  metadata: {
    description: '',
    encryptions: [
      {
        format: '',
        key: '',
        pubkey: '',
        type: ''
      }
    ],
    issuer: '',
    rules: {
      expiration: {
        locked: false,
        validUntil: ''
      },
      fees: {
        items: [
          {
            address: '',
            tokenId: '',
            value: ''
          }
        ],
        locked: false
      },
      holders: [
        {
          address: '',
          locked: false
        }
      ]
    },
    tokenName: '',
    urls: [
      {
        dataHash: '',
        mimeType: '',
        name: '',
        url: ''
      }
    ],
    userData: {
      meta: [
        {
          key: '',
          value: ''
        }
      ]
    }
  },
  sendutxo: [],
  to: [
    {
      address: '',
      amount: '',
      tokenId: ''
    }
  ]
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/ntp1/sendtoken',
  headers: {'content-type': 'application/json'},
  data: {
    fee: '',
    flags: {splitChange: false},
    from: [],
    metadata: {
      description: '',
      encryptions: [{format: '', key: '', pubkey: '', type: ''}],
      issuer: '',
      rules: {
        expiration: {locked: false, validUntil: ''},
        fees: {items: [{address: '', tokenId: '', value: ''}], locked: false},
        holders: [{address: '', locked: false}]
      },
      tokenName: '',
      urls: [{dataHash: '', mimeType: '', name: '', url: ''}],
      userData: {meta: [{key: '', value: ''}]}
    },
    sendutxo: [],
    to: [{address: '', amount: '', tokenId: ''}]
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/ntp1/sendtoken';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"fee":"","flags":{"splitChange":false},"from":[],"metadata":{"description":"","encryptions":[{"format":"","key":"","pubkey":"","type":""}],"issuer":"","rules":{"expiration":{"locked":false,"validUntil":""},"fees":{"items":[{"address":"","tokenId":"","value":""}],"locked":false},"holders":[{"address":"","locked":false}]},"tokenName":"","urls":[{"dataHash":"","mimeType":"","name":"","url":""}],"userData":{"meta":[{"key":"","value":""}]}},"sendutxo":[],"to":[{"address":"","amount":"","tokenId":""}]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"fee": @"",
                              @"flags": @{ @"splitChange": @NO },
                              @"from": @[  ],
                              @"metadata": @{ @"description": @"", @"encryptions": @[ @{ @"format": @"", @"key": @"", @"pubkey": @"", @"type": @"" } ], @"issuer": @"", @"rules": @{ @"expiration": @{ @"locked": @NO, @"validUntil": @"" }, @"fees": @{ @"items": @[ @{ @"address": @"", @"tokenId": @"", @"value": @"" } ], @"locked": @NO }, @"holders": @[ @{ @"address": @"", @"locked": @NO } ] }, @"tokenName": @"", @"urls": @[ @{ @"dataHash": @"", @"mimeType": @"", @"name": @"", @"url": @"" } ], @"userData": @{ @"meta": @[ @{ @"key": @"", @"value": @"" } ] } },
                              @"sendutxo": @[  ],
                              @"to": @[ @{ @"address": @"", @"amount": @"", @"tokenId": @"" } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/ntp1/sendtoken"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/ntp1/sendtoken" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"fee\": \"\",\n  \"flags\": {\n    \"splitChange\": false\n  },\n  \"from\": [],\n  \"metadata\": {\n    \"description\": \"\",\n    \"encryptions\": [\n      {\n        \"format\": \"\",\n        \"key\": \"\",\n        \"pubkey\": \"\",\n        \"type\": \"\"\n      }\n    ],\n    \"issuer\": \"\",\n    \"rules\": {\n      \"expiration\": {\n        \"locked\": false,\n        \"validUntil\": \"\"\n      },\n      \"fees\": {\n        \"items\": [\n          {\n            \"address\": \"\",\n            \"tokenId\": \"\",\n            \"value\": \"\"\n          }\n        ],\n        \"locked\": false\n      },\n      \"holders\": [\n        {\n          \"address\": \"\",\n          \"locked\": false\n        }\n      ]\n    },\n    \"tokenName\": \"\",\n    \"urls\": [\n      {\n        \"dataHash\": \"\",\n        \"mimeType\": \"\",\n        \"name\": \"\",\n        \"url\": \"\"\n      }\n    ],\n    \"userData\": {\n      \"meta\": [\n        {\n          \"key\": \"\",\n          \"value\": \"\"\n        }\n      ]\n    }\n  },\n  \"sendutxo\": [],\n  \"to\": [\n    {\n      \"address\": \"\",\n      \"amount\": \"\",\n      \"tokenId\": \"\"\n    }\n  ]\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/ntp1/sendtoken",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'fee' => '',
    'flags' => [
        'splitChange' => null
    ],
    'from' => [
        
    ],
    'metadata' => [
        'description' => '',
        'encryptions' => [
                [
                                'format' => '',
                                'key' => '',
                                'pubkey' => '',
                                'type' => ''
                ]
        ],
        'issuer' => '',
        'rules' => [
                'expiration' => [
                                'locked' => null,
                                'validUntil' => ''
                ],
                'fees' => [
                                'items' => [
                                                                [
                                                                                                                                'address' => '',
                                                                                                                                'tokenId' => '',
                                                                                                                                'value' => ''
                                                                ]
                                ],
                                'locked' => null
                ],
                'holders' => [
                                [
                                                                'address' => '',
                                                                'locked' => null
                                ]
                ]
        ],
        'tokenName' => '',
        'urls' => [
                [
                                'dataHash' => '',
                                'mimeType' => '',
                                'name' => '',
                                'url' => ''
                ]
        ],
        'userData' => [
                'meta' => [
                                [
                                                                'key' => '',
                                                                'value' => ''
                                ]
                ]
        ]
    ],
    'sendutxo' => [
        
    ],
    'to' => [
        [
                'address' => '',
                'amount' => '',
                'tokenId' => ''
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/ntp1/sendtoken', [
  'body' => '{
  "fee": "",
  "flags": {
    "splitChange": false
  },
  "from": [],
  "metadata": {
    "description": "",
    "encryptions": [
      {
        "format": "",
        "key": "",
        "pubkey": "",
        "type": ""
      }
    ],
    "issuer": "",
    "rules": {
      "expiration": {
        "locked": false,
        "validUntil": ""
      },
      "fees": {
        "items": [
          {
            "address": "",
            "tokenId": "",
            "value": ""
          }
        ],
        "locked": false
      },
      "holders": [
        {
          "address": "",
          "locked": false
        }
      ]
    },
    "tokenName": "",
    "urls": [
      {
        "dataHash": "",
        "mimeType": "",
        "name": "",
        "url": ""
      }
    ],
    "userData": {
      "meta": [
        {
          "key": "",
          "value": ""
        }
      ]
    }
  },
  "sendutxo": [],
  "to": [
    {
      "address": "",
      "amount": "",
      "tokenId": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/ntp1/sendtoken');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'fee' => '',
  'flags' => [
    'splitChange' => null
  ],
  'from' => [
    
  ],
  'metadata' => [
    'description' => '',
    'encryptions' => [
        [
                'format' => '',
                'key' => '',
                'pubkey' => '',
                'type' => ''
        ]
    ],
    'issuer' => '',
    'rules' => [
        'expiration' => [
                'locked' => null,
                'validUntil' => ''
        ],
        'fees' => [
                'items' => [
                                [
                                                                'address' => '',
                                                                'tokenId' => '',
                                                                'value' => ''
                                ]
                ],
                'locked' => null
        ],
        'holders' => [
                [
                                'address' => '',
                                'locked' => null
                ]
        ]
    ],
    'tokenName' => '',
    'urls' => [
        [
                'dataHash' => '',
                'mimeType' => '',
                'name' => '',
                'url' => ''
        ]
    ],
    'userData' => [
        'meta' => [
                [
                                'key' => '',
                                'value' => ''
                ]
        ]
    ]
  ],
  'sendutxo' => [
    
  ],
  'to' => [
    [
        'address' => '',
        'amount' => '',
        'tokenId' => ''
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'fee' => '',
  'flags' => [
    'splitChange' => null
  ],
  'from' => [
    
  ],
  'metadata' => [
    'description' => '',
    'encryptions' => [
        [
                'format' => '',
                'key' => '',
                'pubkey' => '',
                'type' => ''
        ]
    ],
    'issuer' => '',
    'rules' => [
        'expiration' => [
                'locked' => null,
                'validUntil' => ''
        ],
        'fees' => [
                'items' => [
                                [
                                                                'address' => '',
                                                                'tokenId' => '',
                                                                'value' => ''
                                ]
                ],
                'locked' => null
        ],
        'holders' => [
                [
                                'address' => '',
                                'locked' => null
                ]
        ]
    ],
    'tokenName' => '',
    'urls' => [
        [
                'dataHash' => '',
                'mimeType' => '',
                'name' => '',
                'url' => ''
        ]
    ],
    'userData' => [
        'meta' => [
                [
                                'key' => '',
                                'value' => ''
                ]
        ]
    ]
  ],
  'sendutxo' => [
    
  ],
  'to' => [
    [
        'address' => '',
        'amount' => '',
        'tokenId' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/ntp1/sendtoken');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/ntp1/sendtoken' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "fee": "",
  "flags": {
    "splitChange": false
  },
  "from": [],
  "metadata": {
    "description": "",
    "encryptions": [
      {
        "format": "",
        "key": "",
        "pubkey": "",
        "type": ""
      }
    ],
    "issuer": "",
    "rules": {
      "expiration": {
        "locked": false,
        "validUntil": ""
      },
      "fees": {
        "items": [
          {
            "address": "",
            "tokenId": "",
            "value": ""
          }
        ],
        "locked": false
      },
      "holders": [
        {
          "address": "",
          "locked": false
        }
      ]
    },
    "tokenName": "",
    "urls": [
      {
        "dataHash": "",
        "mimeType": "",
        "name": "",
        "url": ""
      }
    ],
    "userData": {
      "meta": [
        {
          "key": "",
          "value": ""
        }
      ]
    }
  },
  "sendutxo": [],
  "to": [
    {
      "address": "",
      "amount": "",
      "tokenId": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/ntp1/sendtoken' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "fee": "",
  "flags": {
    "splitChange": false
  },
  "from": [],
  "metadata": {
    "description": "",
    "encryptions": [
      {
        "format": "",
        "key": "",
        "pubkey": "",
        "type": ""
      }
    ],
    "issuer": "",
    "rules": {
      "expiration": {
        "locked": false,
        "validUntil": ""
      },
      "fees": {
        "items": [
          {
            "address": "",
            "tokenId": "",
            "value": ""
          }
        ],
        "locked": false
      },
      "holders": [
        {
          "address": "",
          "locked": false
        }
      ]
    },
    "tokenName": "",
    "urls": [
      {
        "dataHash": "",
        "mimeType": "",
        "name": "",
        "url": ""
      }
    ],
    "userData": {
      "meta": [
        {
          "key": "",
          "value": ""
        }
      ]
    }
  },
  "sendutxo": [],
  "to": [
    {
      "address": "",
      "amount": "",
      "tokenId": ""
    }
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"fee\": \"\",\n  \"flags\": {\n    \"splitChange\": false\n  },\n  \"from\": [],\n  \"metadata\": {\n    \"description\": \"\",\n    \"encryptions\": [\n      {\n        \"format\": \"\",\n        \"key\": \"\",\n        \"pubkey\": \"\",\n        \"type\": \"\"\n      }\n    ],\n    \"issuer\": \"\",\n    \"rules\": {\n      \"expiration\": {\n        \"locked\": false,\n        \"validUntil\": \"\"\n      },\n      \"fees\": {\n        \"items\": [\n          {\n            \"address\": \"\",\n            \"tokenId\": \"\",\n            \"value\": \"\"\n          }\n        ],\n        \"locked\": false\n      },\n      \"holders\": [\n        {\n          \"address\": \"\",\n          \"locked\": false\n        }\n      ]\n    },\n    \"tokenName\": \"\",\n    \"urls\": [\n      {\n        \"dataHash\": \"\",\n        \"mimeType\": \"\",\n        \"name\": \"\",\n        \"url\": \"\"\n      }\n    ],\n    \"userData\": {\n      \"meta\": [\n        {\n          \"key\": \"\",\n          \"value\": \"\"\n        }\n      ]\n    }\n  },\n  \"sendutxo\": [],\n  \"to\": [\n    {\n      \"address\": \"\",\n      \"amount\": \"\",\n      \"tokenId\": \"\"\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/ntp1/sendtoken", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/ntp1/sendtoken"

payload = {
    "fee": "",
    "flags": { "splitChange": False },
    "from": [],
    "metadata": {
        "description": "",
        "encryptions": [
            {
                "format": "",
                "key": "",
                "pubkey": "",
                "type": ""
            }
        ],
        "issuer": "",
        "rules": {
            "expiration": {
                "locked": False,
                "validUntil": ""
            },
            "fees": {
                "items": [
                    {
                        "address": "",
                        "tokenId": "",
                        "value": ""
                    }
                ],
                "locked": False
            },
            "holders": [
                {
                    "address": "",
                    "locked": False
                }
            ]
        },
        "tokenName": "",
        "urls": [
            {
                "dataHash": "",
                "mimeType": "",
                "name": "",
                "url": ""
            }
        ],
        "userData": { "meta": [
                {
                    "key": "",
                    "value": ""
                }
            ] }
    },
    "sendutxo": [],
    "to": [
        {
            "address": "",
            "amount": "",
            "tokenId": ""
        }
    ]
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/ntp1/sendtoken"

payload <- "{\n  \"fee\": \"\",\n  \"flags\": {\n    \"splitChange\": false\n  },\n  \"from\": [],\n  \"metadata\": {\n    \"description\": \"\",\n    \"encryptions\": [\n      {\n        \"format\": \"\",\n        \"key\": \"\",\n        \"pubkey\": \"\",\n        \"type\": \"\"\n      }\n    ],\n    \"issuer\": \"\",\n    \"rules\": {\n      \"expiration\": {\n        \"locked\": false,\n        \"validUntil\": \"\"\n      },\n      \"fees\": {\n        \"items\": [\n          {\n            \"address\": \"\",\n            \"tokenId\": \"\",\n            \"value\": \"\"\n          }\n        ],\n        \"locked\": false\n      },\n      \"holders\": [\n        {\n          \"address\": \"\",\n          \"locked\": false\n        }\n      ]\n    },\n    \"tokenName\": \"\",\n    \"urls\": [\n      {\n        \"dataHash\": \"\",\n        \"mimeType\": \"\",\n        \"name\": \"\",\n        \"url\": \"\"\n      }\n    ],\n    \"userData\": {\n      \"meta\": [\n        {\n          \"key\": \"\",\n          \"value\": \"\"\n        }\n      ]\n    }\n  },\n  \"sendutxo\": [],\n  \"to\": [\n    {\n      \"address\": \"\",\n      \"amount\": \"\",\n      \"tokenId\": \"\"\n    }\n  ]\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/ntp1/sendtoken")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"fee\": \"\",\n  \"flags\": {\n    \"splitChange\": false\n  },\n  \"from\": [],\n  \"metadata\": {\n    \"description\": \"\",\n    \"encryptions\": [\n      {\n        \"format\": \"\",\n        \"key\": \"\",\n        \"pubkey\": \"\",\n        \"type\": \"\"\n      }\n    ],\n    \"issuer\": \"\",\n    \"rules\": {\n      \"expiration\": {\n        \"locked\": false,\n        \"validUntil\": \"\"\n      },\n      \"fees\": {\n        \"items\": [\n          {\n            \"address\": \"\",\n            \"tokenId\": \"\",\n            \"value\": \"\"\n          }\n        ],\n        \"locked\": false\n      },\n      \"holders\": [\n        {\n          \"address\": \"\",\n          \"locked\": false\n        }\n      ]\n    },\n    \"tokenName\": \"\",\n    \"urls\": [\n      {\n        \"dataHash\": \"\",\n        \"mimeType\": \"\",\n        \"name\": \"\",\n        \"url\": \"\"\n      }\n    ],\n    \"userData\": {\n      \"meta\": [\n        {\n          \"key\": \"\",\n          \"value\": \"\"\n        }\n      ]\n    }\n  },\n  \"sendutxo\": [],\n  \"to\": [\n    {\n      \"address\": \"\",\n      \"amount\": \"\",\n      \"tokenId\": \"\"\n    }\n  ]\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/ntp1/sendtoken') do |req|
  req.body = "{\n  \"fee\": \"\",\n  \"flags\": {\n    \"splitChange\": false\n  },\n  \"from\": [],\n  \"metadata\": {\n    \"description\": \"\",\n    \"encryptions\": [\n      {\n        \"format\": \"\",\n        \"key\": \"\",\n        \"pubkey\": \"\",\n        \"type\": \"\"\n      }\n    ],\n    \"issuer\": \"\",\n    \"rules\": {\n      \"expiration\": {\n        \"locked\": false,\n        \"validUntil\": \"\"\n      },\n      \"fees\": {\n        \"items\": [\n          {\n            \"address\": \"\",\n            \"tokenId\": \"\",\n            \"value\": \"\"\n          }\n        ],\n        \"locked\": false\n      },\n      \"holders\": [\n        {\n          \"address\": \"\",\n          \"locked\": false\n        }\n      ]\n    },\n    \"tokenName\": \"\",\n    \"urls\": [\n      {\n        \"dataHash\": \"\",\n        \"mimeType\": \"\",\n        \"name\": \"\",\n        \"url\": \"\"\n      }\n    ],\n    \"userData\": {\n      \"meta\": [\n        {\n          \"key\": \"\",\n          \"value\": \"\"\n        }\n      ]\n    }\n  },\n  \"sendutxo\": [],\n  \"to\": [\n    {\n      \"address\": \"\",\n      \"amount\": \"\",\n      \"tokenId\": \"\"\n    }\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/ntp1/sendtoken";

    let payload = json!({
        "fee": "",
        "flags": json!({"splitChange": false}),
        "from": (),
        "metadata": json!({
            "description": "",
            "encryptions": (
                json!({
                    "format": "",
                    "key": "",
                    "pubkey": "",
                    "type": ""
                })
            ),
            "issuer": "",
            "rules": json!({
                "expiration": json!({
                    "locked": false,
                    "validUntil": ""
                }),
                "fees": json!({
                    "items": (
                        json!({
                            "address": "",
                            "tokenId": "",
                            "value": ""
                        })
                    ),
                    "locked": false
                }),
                "holders": (
                    json!({
                        "address": "",
                        "locked": false
                    })
                )
            }),
            "tokenName": "",
            "urls": (
                json!({
                    "dataHash": "",
                    "mimeType": "",
                    "name": "",
                    "url": ""
                })
            ),
            "userData": json!({"meta": (
                    json!({
                        "key": "",
                        "value": ""
                    })
                )})
        }),
        "sendutxo": (),
        "to": (
            json!({
                "address": "",
                "amount": "",
                "tokenId": ""
            })
        )
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/ntp1/sendtoken \
  --header 'content-type: application/json' \
  --data '{
  "fee": "",
  "flags": {
    "splitChange": false
  },
  "from": [],
  "metadata": {
    "description": "",
    "encryptions": [
      {
        "format": "",
        "key": "",
        "pubkey": "",
        "type": ""
      }
    ],
    "issuer": "",
    "rules": {
      "expiration": {
        "locked": false,
        "validUntil": ""
      },
      "fees": {
        "items": [
          {
            "address": "",
            "tokenId": "",
            "value": ""
          }
        ],
        "locked": false
      },
      "holders": [
        {
          "address": "",
          "locked": false
        }
      ]
    },
    "tokenName": "",
    "urls": [
      {
        "dataHash": "",
        "mimeType": "",
        "name": "",
        "url": ""
      }
    ],
    "userData": {
      "meta": [
        {
          "key": "",
          "value": ""
        }
      ]
    }
  },
  "sendutxo": [],
  "to": [
    {
      "address": "",
      "amount": "",
      "tokenId": ""
    }
  ]
}'

echo '{
  "fee": "",
  "flags": {
    "splitChange": false
  },
  "from": [],
  "metadata": {
    "description": "",
    "encryptions": [
      {
        "format": "",
        "key": "",
        "pubkey": "",
        "type": ""
      }
    ],
    "issuer": "",
    "rules": {
      "expiration": {
        "locked": false,
        "validUntil": ""
      },
      "fees": {
        "items": [
          {
            "address": "",
            "tokenId": "",
            "value": ""
          }
        ],
        "locked": false
      },
      "holders": [
        {
          "address": "",
          "locked": false
        }
      ]
    },
    "tokenName": "",
    "urls": [
      {
        "dataHash": "",
        "mimeType": "",
        "name": "",
        "url": ""
      }
    ],
    "userData": {
      "meta": [
        {
          "key": "",
          "value": ""
        }
      ]
    }
  },
  "sendutxo": [],
  "to": [
    {
      "address": "",
      "amount": "",
      "tokenId": ""
    }
  ]
}' |  \
  http POST {{baseUrl}}/ntp1/sendtoken \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "fee": "",\n  "flags": {\n    "splitChange": false\n  },\n  "from": [],\n  "metadata": {\n    "description": "",\n    "encryptions": [\n      {\n        "format": "",\n        "key": "",\n        "pubkey": "",\n        "type": ""\n      }\n    ],\n    "issuer": "",\n    "rules": {\n      "expiration": {\n        "locked": false,\n        "validUntil": ""\n      },\n      "fees": {\n        "items": [\n          {\n            "address": "",\n            "tokenId": "",\n            "value": ""\n          }\n        ],\n        "locked": false\n      },\n      "holders": [\n        {\n          "address": "",\n          "locked": false\n        }\n      ]\n    },\n    "tokenName": "",\n    "urls": [\n      {\n        "dataHash": "",\n        "mimeType": "",\n        "name": "",\n        "url": ""\n      }\n    ],\n    "userData": {\n      "meta": [\n        {\n          "key": "",\n          "value": ""\n        }\n      ]\n    }\n  },\n  "sendutxo": [],\n  "to": [\n    {\n      "address": "",\n      "amount": "",\n      "tokenId": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/ntp1/sendtoken

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "fee": "",
  "flags": ["splitChange": false],
  "from": [],
  "metadata": [
    "description": "",
    "encryptions": [
      [
        "format": "",
        "key": "",
        "pubkey": "",
        "type": ""
      ]
    ],
    "issuer": "",
    "rules": [
      "expiration": [
        "locked": false,
        "validUntil": ""
      ],
      "fees": [
        "items": [
          [
            "address": "",
            "tokenId": "",
            "value": ""
          ]
        ],
        "locked": false
      ],
      "holders": [
        [
          "address": "",
          "locked": false
        ]
      ]
    ],
    "tokenName": "",
    "urls": [
      [
        "dataHash": "",
        "mimeType": "",
        "name": "",
        "url": ""
      ]
    ],
    "userData": ["meta": [
        [
          "key": "",
          "value": ""
        ]
      ]]
  ],
  "sendutxo": [],
  "to": [
    [
      "address": "",
      "amount": "",
      "tokenId": ""
    ]
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/ntp1/sendtoken")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Get Addresses Holding a Token

{{baseUrl}}/ntp1/stakeholders/:tokenid

QUERY PARAMS

tokenid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/ntp1/stakeholders/:tokenid");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/ntp1/stakeholders/:tokenid")

require "http/client"

url = "{{baseUrl}}/ntp1/stakeholders/:tokenid"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/ntp1/stakeholders/:tokenid"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/ntp1/stakeholders/:tokenid");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/ntp1/stakeholders/:tokenid"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/ntp1/stakeholders/:tokenid HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/ntp1/stakeholders/:tokenid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/ntp1/stakeholders/:tokenid"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/ntp1/stakeholders/:tokenid")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/ntp1/stakeholders/:tokenid")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/ntp1/stakeholders/:tokenid');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/ntp1/stakeholders/:tokenid'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/ntp1/stakeholders/:tokenid';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/ntp1/stakeholders/:tokenid',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/ntp1/stakeholders/:tokenid")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/ntp1/stakeholders/:tokenid',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/ntp1/stakeholders/:tokenid'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/ntp1/stakeholders/:tokenid');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/ntp1/stakeholders/:tokenid'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/ntp1/stakeholders/:tokenid';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/ntp1/stakeholders/:tokenid"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/ntp1/stakeholders/:tokenid" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/ntp1/stakeholders/:tokenid",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/ntp1/stakeholders/:tokenid');

echo $response->getBody();

setUrl('{{baseUrl}}/ntp1/stakeholders/:tokenid');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/ntp1/stakeholders/:tokenid');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/ntp1/stakeholders/:tokenid' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/ntp1/stakeholders/:tokenid' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/ntp1/stakeholders/:tokenid")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/ntp1/stakeholders/:tokenid"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/ntp1/stakeholders/:tokenid"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/ntp1/stakeholders/:tokenid")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/ntp1/stakeholders/:tokenid') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/ntp1/stakeholders/:tokenid";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/ntp1/stakeholders/:tokenid

http GET {{baseUrl}}/ntp1/stakeholders/:tokenid

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/ntp1/stakeholders/:tokenid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/ntp1/stakeholders/:tokenid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Get Metadata of Token

{{baseUrl}}/ntp1/tokenmetadata/:tokenid

QUERY PARAMS

tokenid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/ntp1/tokenmetadata/:tokenid");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/ntp1/tokenmetadata/:tokenid")

require "http/client"

url = "{{baseUrl}}/ntp1/tokenmetadata/:tokenid"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/ntp1/tokenmetadata/:tokenid"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/ntp1/tokenmetadata/:tokenid");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/ntp1/tokenmetadata/:tokenid"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/ntp1/tokenmetadata/:tokenid HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/ntp1/tokenmetadata/:tokenid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/ntp1/tokenmetadata/:tokenid"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/ntp1/tokenmetadata/:tokenid")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/ntp1/tokenmetadata/:tokenid")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/ntp1/tokenmetadata/:tokenid');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/ntp1/tokenmetadata/:tokenid'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/ntp1/tokenmetadata/:tokenid';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/ntp1/tokenmetadata/:tokenid',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/ntp1/tokenmetadata/:tokenid")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/ntp1/tokenmetadata/:tokenid',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/ntp1/tokenmetadata/:tokenid'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/ntp1/tokenmetadata/:tokenid');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/ntp1/tokenmetadata/:tokenid'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/ntp1/tokenmetadata/:tokenid';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/ntp1/tokenmetadata/:tokenid"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/ntp1/tokenmetadata/:tokenid" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/ntp1/tokenmetadata/:tokenid",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/ntp1/tokenmetadata/:tokenid');

echo $response->getBody();

setUrl('{{baseUrl}}/ntp1/tokenmetadata/:tokenid');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/ntp1/tokenmetadata/:tokenid');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/ntp1/tokenmetadata/:tokenid' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/ntp1/tokenmetadata/:tokenid' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/ntp1/tokenmetadata/:tokenid")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/ntp1/tokenmetadata/:tokenid"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/ntp1/tokenmetadata/:tokenid"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/ntp1/tokenmetadata/:tokenid")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/ntp1/tokenmetadata/:tokenid') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/ntp1/tokenmetadata/:tokenid";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/ntp1/tokenmetadata/:tokenid

http GET {{baseUrl}}/ntp1/tokenmetadata/:tokenid

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/ntp1/tokenmetadata/:tokenid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/ntp1/tokenmetadata/:tokenid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Get UTXO Metadata of Token

{{baseUrl}}/ntp1/tokenmetadata/:tokenid/:utxo

QUERY PARAMS

tokenid

utxo

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/ntp1/tokenmetadata/:tokenid/:utxo");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/ntp1/tokenmetadata/:tokenid/:utxo")

require "http/client"

url = "{{baseUrl}}/ntp1/tokenmetadata/:tokenid/:utxo"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/ntp1/tokenmetadata/:tokenid/:utxo"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/ntp1/tokenmetadata/:tokenid/:utxo");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/ntp1/tokenmetadata/:tokenid/:utxo"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/ntp1/tokenmetadata/:tokenid/:utxo HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/ntp1/tokenmetadata/:tokenid/:utxo")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/ntp1/tokenmetadata/:tokenid/:utxo"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/ntp1/tokenmetadata/:tokenid/:utxo")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/ntp1/tokenmetadata/:tokenid/:utxo")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/ntp1/tokenmetadata/:tokenid/:utxo');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/ntp1/tokenmetadata/:tokenid/:utxo'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/ntp1/tokenmetadata/:tokenid/:utxo';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/ntp1/tokenmetadata/:tokenid/:utxo',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/ntp1/tokenmetadata/:tokenid/:utxo")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/ntp1/tokenmetadata/:tokenid/:utxo',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/ntp1/tokenmetadata/:tokenid/:utxo'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/ntp1/tokenmetadata/:tokenid/:utxo');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/ntp1/tokenmetadata/:tokenid/:utxo'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/ntp1/tokenmetadata/:tokenid/:utxo';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/ntp1/tokenmetadata/:tokenid/:utxo"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/ntp1/tokenmetadata/:tokenid/:utxo" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/ntp1/tokenmetadata/:tokenid/:utxo",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/ntp1/tokenmetadata/:tokenid/:utxo');

echo $response->getBody();

setUrl('{{baseUrl}}/ntp1/tokenmetadata/:tokenid/:utxo');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/ntp1/tokenmetadata/:tokenid/:utxo');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/ntp1/tokenmetadata/:tokenid/:utxo' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/ntp1/tokenmetadata/:tokenid/:utxo' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/ntp1/tokenmetadata/:tokenid/:utxo")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/ntp1/tokenmetadata/:tokenid/:utxo"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/ntp1/tokenmetadata/:tokenid/:utxo"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/ntp1/tokenmetadata/:tokenid/:utxo")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/ntp1/tokenmetadata/:tokenid/:utxo') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/ntp1/tokenmetadata/:tokenid/:utxo";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/ntp1/tokenmetadata/:tokenid/:utxo

http GET {{baseUrl}}/ntp1/tokenmetadata/:tokenid/:utxo

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/ntp1/tokenmetadata/:tokenid/:utxo

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/ntp1/tokenmetadata/:tokenid/:utxo")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Information On a Neblio Address

{{baseUrl}}/ntp1/addressinfo/:address

QUERY PARAMS

address

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/ntp1/addressinfo/:address");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/ntp1/addressinfo/:address")

require "http/client"

url = "{{baseUrl}}/ntp1/addressinfo/:address"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/ntp1/addressinfo/:address"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/ntp1/addressinfo/:address");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/ntp1/addressinfo/:address"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/ntp1/addressinfo/:address HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/ntp1/addressinfo/:address")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/ntp1/addressinfo/:address"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/ntp1/addressinfo/:address")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/ntp1/addressinfo/:address")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/ntp1/addressinfo/:address');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/ntp1/addressinfo/:address'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/ntp1/addressinfo/:address';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/ntp1/addressinfo/:address',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/ntp1/addressinfo/:address")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/ntp1/addressinfo/:address',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/ntp1/addressinfo/:address'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/ntp1/addressinfo/:address');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/ntp1/addressinfo/:address'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/ntp1/addressinfo/:address';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/ntp1/addressinfo/:address"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/ntp1/addressinfo/:address" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/ntp1/addressinfo/:address",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/ntp1/addressinfo/:address');

echo $response->getBody();

setUrl('{{baseUrl}}/ntp1/addressinfo/:address');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/ntp1/addressinfo/:address');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/ntp1/addressinfo/:address' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/ntp1/addressinfo/:address' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/ntp1/addressinfo/:address")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/ntp1/addressinfo/:address"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/ntp1/addressinfo/:address"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/ntp1/addressinfo/:address")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/ntp1/addressinfo/:address') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/ntp1/addressinfo/:address";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/ntp1/addressinfo/:address

http GET {{baseUrl}}/ntp1/addressinfo/:address

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/ntp1/addressinfo/:address

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/ntp1/addressinfo/:address")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Information On an NTP1 Transaction

{{baseUrl}}/ntp1/transactioninfo/:txid

QUERY PARAMS

txid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/ntp1/transactioninfo/:txid");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/ntp1/transactioninfo/:txid")

require "http/client"

url = "{{baseUrl}}/ntp1/transactioninfo/:txid"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/ntp1/transactioninfo/:txid"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/ntp1/transactioninfo/:txid");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/ntp1/transactioninfo/:txid"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/ntp1/transactioninfo/:txid HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/ntp1/transactioninfo/:txid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/ntp1/transactioninfo/:txid"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/ntp1/transactioninfo/:txid")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/ntp1/transactioninfo/:txid")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/ntp1/transactioninfo/:txid');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/ntp1/transactioninfo/:txid'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/ntp1/transactioninfo/:txid';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/ntp1/transactioninfo/:txid',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/ntp1/transactioninfo/:txid")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/ntp1/transactioninfo/:txid',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/ntp1/transactioninfo/:txid'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/ntp1/transactioninfo/:txid');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/ntp1/transactioninfo/:txid'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/ntp1/transactioninfo/:txid';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/ntp1/transactioninfo/:txid"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/ntp1/transactioninfo/:txid" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/ntp1/transactioninfo/:txid",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/ntp1/transactioninfo/:txid');

echo $response->getBody();

setUrl('{{baseUrl}}/ntp1/transactioninfo/:txid');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/ntp1/transactioninfo/:txid');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/ntp1/transactioninfo/:txid' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/ntp1/transactioninfo/:txid' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/ntp1/transactioninfo/:txid")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/ntp1/transactioninfo/:txid"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/ntp1/transactioninfo/:txid"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/ntp1/transactioninfo/:txid")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/ntp1/transactioninfo/:txid') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/ntp1/transactioninfo/:txid";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/ntp1/transactioninfo/:txid

http GET {{baseUrl}}/ntp1/transactioninfo/:txid

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/ntp1/transactioninfo/:txid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/ntp1/transactioninfo/:txid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Returns the tokenId representing a token

{{baseUrl}}/ntp1/tokenid/:tokensymbol

QUERY PARAMS

tokensymbol

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/ntp1/tokenid/:tokensymbol");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/ntp1/tokenid/:tokensymbol")

require "http/client"

url = "{{baseUrl}}/ntp1/tokenid/:tokensymbol"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/ntp1/tokenid/:tokensymbol"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/ntp1/tokenid/:tokensymbol");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/ntp1/tokenid/:tokensymbol"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/ntp1/tokenid/:tokensymbol HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/ntp1/tokenid/:tokensymbol")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/ntp1/tokenid/:tokensymbol"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/ntp1/tokenid/:tokensymbol")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/ntp1/tokenid/:tokensymbol")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/ntp1/tokenid/:tokensymbol');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/ntp1/tokenid/:tokensymbol'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/ntp1/tokenid/:tokensymbol';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/ntp1/tokenid/:tokensymbol',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/ntp1/tokenid/:tokensymbol")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/ntp1/tokenid/:tokensymbol',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/ntp1/tokenid/:tokensymbol'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/ntp1/tokenid/:tokensymbol');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/ntp1/tokenid/:tokensymbol'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/ntp1/tokenid/:tokensymbol';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/ntp1/tokenid/:tokensymbol"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/ntp1/tokenid/:tokensymbol" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/ntp1/tokenid/:tokensymbol",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/ntp1/tokenid/:tokensymbol');

echo $response->getBody();

setUrl('{{baseUrl}}/ntp1/tokenid/:tokensymbol');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/ntp1/tokenid/:tokensymbol');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/ntp1/tokenid/:tokensymbol' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/ntp1/tokenid/:tokensymbol' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/ntp1/tokenid/:tokensymbol")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/ntp1/tokenid/:tokensymbol"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/ntp1/tokenid/:tokensymbol"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/ntp1/tokenid/:tokensymbol")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/ntp1/tokenid/:tokensymbol') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/ntp1/tokenid/:tokensymbol";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/ntp1/tokenid/:tokensymbol

http GET {{baseUrl}}/ntp1/tokenid/:tokensymbol

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/ntp1/tokenid/:tokensymbol

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/ntp1/tokenid/:tokensymbol")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Withdraws testnet NEBL to the specified address

{{baseUrl}}/testnet/faucet

QUERY PARAMS

address

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/testnet/faucet?address=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/testnet/faucet" {:query-params {:address ""}})

require "http/client"

url = "{{baseUrl}}/testnet/faucet?address="

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/testnet/faucet?address="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/testnet/faucet?address=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/testnet/faucet?address="

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/testnet/faucet?address= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/testnet/faucet?address=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/testnet/faucet?address="))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/testnet/faucet?address=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/testnet/faucet?address=")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/testnet/faucet?address=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/testnet/faucet',
  params: {address: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/testnet/faucet?address=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/testnet/faucet?address=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/testnet/faucet?address=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/testnet/faucet?address=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/testnet/faucet',
  qs: {address: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/testnet/faucet');

req.query({
  address: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/testnet/faucet',
  params: {address: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/testnet/faucet?address=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/testnet/faucet?address="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/testnet/faucet?address=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/testnet/faucet?address=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/testnet/faucet?address=');

echo $response->getBody();

setUrl('{{baseUrl}}/testnet/faucet');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'address' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/testnet/faucet');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'address' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/testnet/faucet?address=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/testnet/faucet?address=' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/testnet/faucet?address=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/testnet/faucet"

querystring = {"address":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/testnet/faucet"

queryString <- list(address = "")

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/testnet/faucet?address=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/testnet/faucet') do |req|
  req.params['address'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/testnet/faucet";

    let querystring = [
        ("address", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/testnet/faucet?address='

http GET '{{baseUrl}}/testnet/faucet?address='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/testnet/faucet?address='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/testnet/faucet?address=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Broadcasts a signed raw transaction to the network (not NTP1 specific) (POST)

{{baseUrl}}/testnet/ins/tx/send

BODY json

{
  "rawtx": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/testnet/ins/tx/send");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"rawtx\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/testnet/ins/tx/send" {:content-type :json
                                                                :form-params {:rawtx ""}})

require "http/client"

url = "{{baseUrl}}/testnet/ins/tx/send"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"rawtx\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/testnet/ins/tx/send"),
    Content = new StringContent("{\n  \"rawtx\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/testnet/ins/tx/send");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"rawtx\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/testnet/ins/tx/send"

	payload := strings.NewReader("{\n  \"rawtx\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/testnet/ins/tx/send HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 17

{
  "rawtx": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/testnet/ins/tx/send")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"rawtx\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/testnet/ins/tx/send"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"rawtx\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"rawtx\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/testnet/ins/tx/send")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/testnet/ins/tx/send")
  .header("content-type", "application/json")
  .body("{\n  \"rawtx\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  rawtx: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/testnet/ins/tx/send');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/testnet/ins/tx/send',
  headers: {'content-type': 'application/json'},
  data: {rawtx: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/testnet/ins/tx/send';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"rawtx":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/testnet/ins/tx/send',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "rawtx": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"rawtx\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/testnet/ins/tx/send")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/testnet/ins/tx/send',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({rawtx: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/testnet/ins/tx/send',
  headers: {'content-type': 'application/json'},
  body: {rawtx: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/testnet/ins/tx/send');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  rawtx: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/testnet/ins/tx/send',
  headers: {'content-type': 'application/json'},
  data: {rawtx: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/testnet/ins/tx/send';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"rawtx":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"rawtx": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/testnet/ins/tx/send"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/testnet/ins/tx/send" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"rawtx\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/testnet/ins/tx/send",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'rawtx' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/testnet/ins/tx/send', [
  'body' => '{
  "rawtx": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/testnet/ins/tx/send');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'rawtx' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'rawtx' => ''
]));
$request->setRequestUrl('{{baseUrl}}/testnet/ins/tx/send');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/testnet/ins/tx/send' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "rawtx": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/testnet/ins/tx/send' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "rawtx": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"rawtx\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/testnet/ins/tx/send", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/testnet/ins/tx/send"

payload = { "rawtx": "" }
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/testnet/ins/tx/send"

payload <- "{\n  \"rawtx\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/testnet/ins/tx/send")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"rawtx\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/testnet/ins/tx/send') do |req|
  req.body = "{\n  \"rawtx\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/testnet/ins/tx/send";

    let payload = json!({"rawtx": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/testnet/ins/tx/send \
  --header 'content-type: application/json' \
  --data '{
  "rawtx": ""
}'

echo '{
  "rawtx": ""
}' |  \
  http POST {{baseUrl}}/testnet/ins/tx/send \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "rawtx": ""\n}' \
  --output-document \
  - {{baseUrl}}/testnet/ins/tx/send

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["rawtx": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/testnet/ins/tx/send")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Get node sync status (GET)

{{baseUrl}}/testnet/ins/sync

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/testnet/ins/sync");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/testnet/ins/sync")

require "http/client"

url = "{{baseUrl}}/testnet/ins/sync"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/testnet/ins/sync"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/testnet/ins/sync");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/testnet/ins/sync"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/testnet/ins/sync HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/testnet/ins/sync")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/testnet/ins/sync"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/testnet/ins/sync")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/testnet/ins/sync")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/testnet/ins/sync');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/testnet/ins/sync'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/testnet/ins/sync';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/testnet/ins/sync',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/testnet/ins/sync")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/testnet/ins/sync',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/testnet/ins/sync'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/testnet/ins/sync');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/testnet/ins/sync'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/testnet/ins/sync';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/testnet/ins/sync"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/testnet/ins/sync" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/testnet/ins/sync",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/testnet/ins/sync');

echo $response->getBody();

setUrl('{{baseUrl}}/testnet/ins/sync');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/testnet/ins/sync');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/testnet/ins/sync' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/testnet/ins/sync' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/testnet/ins/sync")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/testnet/ins/sync"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/testnet/ins/sync"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/testnet/ins/sync")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/testnet/ins/sync') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/testnet/ins/sync";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/testnet/ins/sync

http GET {{baseUrl}}/testnet/ins/sync

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/testnet/ins/sync

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/testnet/ins/sync")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Get transactions by block or address (GET)

{{baseUrl}}/testnet/ins/txs

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/testnet/ins/txs");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/testnet/ins/txs")

require "http/client"

url = "{{baseUrl}}/testnet/ins/txs"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/testnet/ins/txs"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/testnet/ins/txs");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/testnet/ins/txs"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/testnet/ins/txs HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/testnet/ins/txs")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/testnet/ins/txs"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/testnet/ins/txs")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/testnet/ins/txs")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/testnet/ins/txs');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/testnet/ins/txs'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/testnet/ins/txs';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/testnet/ins/txs',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/testnet/ins/txs")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/testnet/ins/txs',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/testnet/ins/txs'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/testnet/ins/txs');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/testnet/ins/txs'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/testnet/ins/txs';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/testnet/ins/txs"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/testnet/ins/txs" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/testnet/ins/txs",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/testnet/ins/txs');

echo $response->getBody();

setUrl('{{baseUrl}}/testnet/ins/txs');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/testnet/ins/txs');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/testnet/ins/txs' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/testnet/ins/txs' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/testnet/ins/txs")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/testnet/ins/txs"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/testnet/ins/txs"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/testnet/ins/txs")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/testnet/ins/txs') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/testnet/ins/txs";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/testnet/ins/txs

http GET {{baseUrl}}/testnet/ins/txs

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/testnet/ins/txs

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/testnet/ins/txs")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Returns address balance in sats (GET)

{{baseUrl}}/testnet/ins/addr/:address/balance

QUERY PARAMS

address

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/testnet/ins/addr/:address/balance");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/testnet/ins/addr/:address/balance")

require "http/client"

url = "{{baseUrl}}/testnet/ins/addr/:address/balance"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/testnet/ins/addr/:address/balance"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/testnet/ins/addr/:address/balance");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/testnet/ins/addr/:address/balance"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/testnet/ins/addr/:address/balance HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/testnet/ins/addr/:address/balance")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/testnet/ins/addr/:address/balance"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/testnet/ins/addr/:address/balance")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/testnet/ins/addr/:address/balance")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/testnet/ins/addr/:address/balance');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/testnet/ins/addr/:address/balance'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/testnet/ins/addr/:address/balance';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/testnet/ins/addr/:address/balance',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/testnet/ins/addr/:address/balance")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/testnet/ins/addr/:address/balance',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/testnet/ins/addr/:address/balance'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/testnet/ins/addr/:address/balance');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/testnet/ins/addr/:address/balance'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/testnet/ins/addr/:address/balance';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/testnet/ins/addr/:address/balance"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/testnet/ins/addr/:address/balance" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/testnet/ins/addr/:address/balance",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/testnet/ins/addr/:address/balance');

echo $response->getBody();

setUrl('{{baseUrl}}/testnet/ins/addr/:address/balance');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/testnet/ins/addr/:address/balance');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/testnet/ins/addr/:address/balance' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/testnet/ins/addr/:address/balance' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/testnet/ins/addr/:address/balance")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/testnet/ins/addr/:address/balance"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/testnet/ins/addr/:address/balance"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/testnet/ins/addr/:address/balance")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/testnet/ins/addr/:address/balance') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/testnet/ins/addr/:address/balance";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/testnet/ins/addr/:address/balance

http GET {{baseUrl}}/testnet/ins/addr/:address/balance

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/testnet/ins/addr/:address/balance

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/testnet/ins/addr/:address/balance")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Returns address object (GET)

{{baseUrl}}/testnet/ins/addr/:address

QUERY PARAMS

address

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/testnet/ins/addr/:address");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/testnet/ins/addr/:address")

require "http/client"

url = "{{baseUrl}}/testnet/ins/addr/:address"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/testnet/ins/addr/:address"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/testnet/ins/addr/:address");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/testnet/ins/addr/:address"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/testnet/ins/addr/:address HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/testnet/ins/addr/:address")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/testnet/ins/addr/:address"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/testnet/ins/addr/:address")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/testnet/ins/addr/:address")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/testnet/ins/addr/:address');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/testnet/ins/addr/:address'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/testnet/ins/addr/:address';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/testnet/ins/addr/:address',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/testnet/ins/addr/:address")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/testnet/ins/addr/:address',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/testnet/ins/addr/:address'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/testnet/ins/addr/:address');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/testnet/ins/addr/:address'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/testnet/ins/addr/:address';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/testnet/ins/addr/:address"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/testnet/ins/addr/:address" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/testnet/ins/addr/:address",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/testnet/ins/addr/:address');

echo $response->getBody();

setUrl('{{baseUrl}}/testnet/ins/addr/:address');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/testnet/ins/addr/:address');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/testnet/ins/addr/:address' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/testnet/ins/addr/:address' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/testnet/ins/addr/:address")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/testnet/ins/addr/:address"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/testnet/ins/addr/:address"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/testnet/ins/addr/:address")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/testnet/ins/addr/:address') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/testnet/ins/addr/:address";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/testnet/ins/addr/:address

http GET {{baseUrl}}/testnet/ins/addr/:address

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/testnet/ins/addr/:address

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/testnet/ins/addr/:address")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Returns address unconfirmed balance in sats (GET)

{{baseUrl}}/testnet/ins/addr/:address/unconfirmedBalance

QUERY PARAMS

address

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/testnet/ins/addr/:address/unconfirmedBalance");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/testnet/ins/addr/:address/unconfirmedBalance")

require "http/client"

url = "{{baseUrl}}/testnet/ins/addr/:address/unconfirmedBalance"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/testnet/ins/addr/:address/unconfirmedBalance"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/testnet/ins/addr/:address/unconfirmedBalance");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/testnet/ins/addr/:address/unconfirmedBalance"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/testnet/ins/addr/:address/unconfirmedBalance HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/testnet/ins/addr/:address/unconfirmedBalance")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/testnet/ins/addr/:address/unconfirmedBalance"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/testnet/ins/addr/:address/unconfirmedBalance")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/testnet/ins/addr/:address/unconfirmedBalance")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/testnet/ins/addr/:address/unconfirmedBalance');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/testnet/ins/addr/:address/unconfirmedBalance'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/testnet/ins/addr/:address/unconfirmedBalance';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/testnet/ins/addr/:address/unconfirmedBalance',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/testnet/ins/addr/:address/unconfirmedBalance")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/testnet/ins/addr/:address/unconfirmedBalance',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/testnet/ins/addr/:address/unconfirmedBalance'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/testnet/ins/addr/:address/unconfirmedBalance');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/testnet/ins/addr/:address/unconfirmedBalance'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/testnet/ins/addr/:address/unconfirmedBalance';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/testnet/ins/addr/:address/unconfirmedBalance"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/testnet/ins/addr/:address/unconfirmedBalance" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/testnet/ins/addr/:address/unconfirmedBalance",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/testnet/ins/addr/:address/unconfirmedBalance');

echo $response->getBody();

setUrl('{{baseUrl}}/testnet/ins/addr/:address/unconfirmedBalance');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/testnet/ins/addr/:address/unconfirmedBalance');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/testnet/ins/addr/:address/unconfirmedBalance' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/testnet/ins/addr/:address/unconfirmedBalance' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/testnet/ins/addr/:address/unconfirmedBalance")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/testnet/ins/addr/:address/unconfirmedBalance"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/testnet/ins/addr/:address/unconfirmedBalance"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/testnet/ins/addr/:address/unconfirmedBalance")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/testnet/ins/addr/:address/unconfirmedBalance') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/testnet/ins/addr/:address/unconfirmedBalance";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/testnet/ins/addr/:address/unconfirmedBalance

http GET {{baseUrl}}/testnet/ins/addr/:address/unconfirmedBalance

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/testnet/ins/addr/:address/unconfirmedBalance

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/testnet/ins/addr/:address/unconfirmedBalance")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Returns all UTXOs at a given address (GET)

{{baseUrl}}/testnet/ins/addr/:address/utxo

QUERY PARAMS

address

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/testnet/ins/addr/:address/utxo");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/testnet/ins/addr/:address/utxo")

require "http/client"

url = "{{baseUrl}}/testnet/ins/addr/:address/utxo"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/testnet/ins/addr/:address/utxo"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/testnet/ins/addr/:address/utxo");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/testnet/ins/addr/:address/utxo"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/testnet/ins/addr/:address/utxo HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/testnet/ins/addr/:address/utxo")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/testnet/ins/addr/:address/utxo"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/testnet/ins/addr/:address/utxo")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/testnet/ins/addr/:address/utxo")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/testnet/ins/addr/:address/utxo');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/testnet/ins/addr/:address/utxo'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/testnet/ins/addr/:address/utxo';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/testnet/ins/addr/:address/utxo',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/testnet/ins/addr/:address/utxo")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/testnet/ins/addr/:address/utxo',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/testnet/ins/addr/:address/utxo'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/testnet/ins/addr/:address/utxo');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/testnet/ins/addr/:address/utxo'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/testnet/ins/addr/:address/utxo';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/testnet/ins/addr/:address/utxo"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/testnet/ins/addr/:address/utxo" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/testnet/ins/addr/:address/utxo",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/testnet/ins/addr/:address/utxo');

echo $response->getBody();

setUrl('{{baseUrl}}/testnet/ins/addr/:address/utxo');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/testnet/ins/addr/:address/utxo');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/testnet/ins/addr/:address/utxo' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/testnet/ins/addr/:address/utxo' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/testnet/ins/addr/:address/utxo")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/testnet/ins/addr/:address/utxo"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/testnet/ins/addr/:address/utxo"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/testnet/ins/addr/:address/utxo")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/testnet/ins/addr/:address/utxo') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/testnet/ins/addr/:address/utxo";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/testnet/ins/addr/:address/utxo

http GET {{baseUrl}}/testnet/ins/addr/:address/utxo

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/testnet/ins/addr/:address/utxo

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/testnet/ins/addr/:address/utxo")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Returns block hash of block (GET)

{{baseUrl}}/testnet/ins/block-index/:blockindex

QUERY PARAMS

blockindex

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/testnet/ins/block-index/:blockindex");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/testnet/ins/block-index/:blockindex")

require "http/client"

url = "{{baseUrl}}/testnet/ins/block-index/:blockindex"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/testnet/ins/block-index/:blockindex"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/testnet/ins/block-index/:blockindex");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/testnet/ins/block-index/:blockindex"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/testnet/ins/block-index/:blockindex HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/testnet/ins/block-index/:blockindex")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/testnet/ins/block-index/:blockindex"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/testnet/ins/block-index/:blockindex")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/testnet/ins/block-index/:blockindex")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/testnet/ins/block-index/:blockindex');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/testnet/ins/block-index/:blockindex'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/testnet/ins/block-index/:blockindex';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/testnet/ins/block-index/:blockindex',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/testnet/ins/block-index/:blockindex")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/testnet/ins/block-index/:blockindex',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/testnet/ins/block-index/:blockindex'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/testnet/ins/block-index/:blockindex');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/testnet/ins/block-index/:blockindex'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/testnet/ins/block-index/:blockindex';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/testnet/ins/block-index/:blockindex"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/testnet/ins/block-index/:blockindex" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/testnet/ins/block-index/:blockindex",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/testnet/ins/block-index/:blockindex');

echo $response->getBody();

setUrl('{{baseUrl}}/testnet/ins/block-index/:blockindex');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/testnet/ins/block-index/:blockindex');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/testnet/ins/block-index/:blockindex' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/testnet/ins/block-index/:blockindex' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/testnet/ins/block-index/:blockindex")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/testnet/ins/block-index/:blockindex"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/testnet/ins/block-index/:blockindex"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/testnet/ins/block-index/:blockindex")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/testnet/ins/block-index/:blockindex') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/testnet/ins/block-index/:blockindex";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/testnet/ins/block-index/:blockindex

http GET {{baseUrl}}/testnet/ins/block-index/:blockindex

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/testnet/ins/block-index/:blockindex

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/testnet/ins/block-index/:blockindex")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Returns information regarding a Neblio block (GET)

{{baseUrl}}/testnet/ins/block/:blockhash

QUERY PARAMS

blockhash

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/testnet/ins/block/:blockhash");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/testnet/ins/block/:blockhash")

require "http/client"

url = "{{baseUrl}}/testnet/ins/block/:blockhash"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/testnet/ins/block/:blockhash"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/testnet/ins/block/:blockhash");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/testnet/ins/block/:blockhash"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/testnet/ins/block/:blockhash HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/testnet/ins/block/:blockhash")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/testnet/ins/block/:blockhash"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/testnet/ins/block/:blockhash")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/testnet/ins/block/:blockhash")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/testnet/ins/block/:blockhash');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/testnet/ins/block/:blockhash'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/testnet/ins/block/:blockhash';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/testnet/ins/block/:blockhash',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/testnet/ins/block/:blockhash")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/testnet/ins/block/:blockhash',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/testnet/ins/block/:blockhash'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/testnet/ins/block/:blockhash');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/testnet/ins/block/:blockhash'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/testnet/ins/block/:blockhash';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/testnet/ins/block/:blockhash"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/testnet/ins/block/:blockhash" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/testnet/ins/block/:blockhash",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/testnet/ins/block/:blockhash');

echo $response->getBody();

setUrl('{{baseUrl}}/testnet/ins/block/:blockhash');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/testnet/ins/block/:blockhash');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/testnet/ins/block/:blockhash' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/testnet/ins/block/:blockhash' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/testnet/ins/block/:blockhash")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/testnet/ins/block/:blockhash"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/testnet/ins/block/:blockhash"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/testnet/ins/block/:blockhash")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/testnet/ins/block/:blockhash') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/testnet/ins/block/:blockhash";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/testnet/ins/block/:blockhash

http GET {{baseUrl}}/testnet/ins/block/:blockhash

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/testnet/ins/block/:blockhash

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/testnet/ins/block/:blockhash")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Returns raw transaction hex (GET)

{{baseUrl}}/testnet/ins/rawtx/:txid

QUERY PARAMS

txid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/testnet/ins/rawtx/:txid");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/testnet/ins/rawtx/:txid")

require "http/client"

url = "{{baseUrl}}/testnet/ins/rawtx/:txid"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/testnet/ins/rawtx/:txid"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/testnet/ins/rawtx/:txid");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/testnet/ins/rawtx/:txid"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/testnet/ins/rawtx/:txid HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/testnet/ins/rawtx/:txid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/testnet/ins/rawtx/:txid"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/testnet/ins/rawtx/:txid")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/testnet/ins/rawtx/:txid")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/testnet/ins/rawtx/:txid');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/testnet/ins/rawtx/:txid'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/testnet/ins/rawtx/:txid';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/testnet/ins/rawtx/:txid',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/testnet/ins/rawtx/:txid")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/testnet/ins/rawtx/:txid',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/testnet/ins/rawtx/:txid'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/testnet/ins/rawtx/:txid');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/testnet/ins/rawtx/:txid'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/testnet/ins/rawtx/:txid';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/testnet/ins/rawtx/:txid"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/testnet/ins/rawtx/:txid" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/testnet/ins/rawtx/:txid",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/testnet/ins/rawtx/:txid');

echo $response->getBody();

setUrl('{{baseUrl}}/testnet/ins/rawtx/:txid');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/testnet/ins/rawtx/:txid');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/testnet/ins/rawtx/:txid' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/testnet/ins/rawtx/:txid' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/testnet/ins/rawtx/:txid")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/testnet/ins/rawtx/:txid"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/testnet/ins/rawtx/:txid"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/testnet/ins/rawtx/:txid")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/testnet/ins/rawtx/:txid') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/testnet/ins/rawtx/:txid";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/testnet/ins/rawtx/:txid

http GET {{baseUrl}}/testnet/ins/rawtx/:txid

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/testnet/ins/rawtx/:txid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/testnet/ins/rawtx/:txid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Returns total received by address in sats (GET)

{{baseUrl}}/testnet/ins/addr/:address/totalReceived

QUERY PARAMS

address

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/testnet/ins/addr/:address/totalReceived");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/testnet/ins/addr/:address/totalReceived")

require "http/client"

url = "{{baseUrl}}/testnet/ins/addr/:address/totalReceived"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/testnet/ins/addr/:address/totalReceived"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/testnet/ins/addr/:address/totalReceived");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/testnet/ins/addr/:address/totalReceived"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/testnet/ins/addr/:address/totalReceived HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/testnet/ins/addr/:address/totalReceived")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/testnet/ins/addr/:address/totalReceived"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/testnet/ins/addr/:address/totalReceived")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/testnet/ins/addr/:address/totalReceived")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/testnet/ins/addr/:address/totalReceived');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/testnet/ins/addr/:address/totalReceived'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/testnet/ins/addr/:address/totalReceived';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/testnet/ins/addr/:address/totalReceived',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/testnet/ins/addr/:address/totalReceived")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/testnet/ins/addr/:address/totalReceived',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/testnet/ins/addr/:address/totalReceived'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/testnet/ins/addr/:address/totalReceived');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/testnet/ins/addr/:address/totalReceived'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/testnet/ins/addr/:address/totalReceived';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/testnet/ins/addr/:address/totalReceived"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/testnet/ins/addr/:address/totalReceived" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/testnet/ins/addr/:address/totalReceived",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/testnet/ins/addr/:address/totalReceived');

echo $response->getBody();

setUrl('{{baseUrl}}/testnet/ins/addr/:address/totalReceived');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/testnet/ins/addr/:address/totalReceived');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/testnet/ins/addr/:address/totalReceived' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/testnet/ins/addr/:address/totalReceived' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/testnet/ins/addr/:address/totalReceived")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/testnet/ins/addr/:address/totalReceived"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/testnet/ins/addr/:address/totalReceived"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/testnet/ins/addr/:address/totalReceived")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/testnet/ins/addr/:address/totalReceived') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/testnet/ins/addr/:address/totalReceived";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/testnet/ins/addr/:address/totalReceived

http GET {{baseUrl}}/testnet/ins/addr/:address/totalReceived

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/testnet/ins/addr/:address/totalReceived

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/testnet/ins/addr/:address/totalReceived")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Returns total sent by address in sats (GET)

{{baseUrl}}/testnet/ins/addr/:address/totalSent

QUERY PARAMS

address

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/testnet/ins/addr/:address/totalSent");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/testnet/ins/addr/:address/totalSent")

require "http/client"

url = "{{baseUrl}}/testnet/ins/addr/:address/totalSent"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/testnet/ins/addr/:address/totalSent"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/testnet/ins/addr/:address/totalSent");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/testnet/ins/addr/:address/totalSent"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/testnet/ins/addr/:address/totalSent HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/testnet/ins/addr/:address/totalSent")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/testnet/ins/addr/:address/totalSent"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/testnet/ins/addr/:address/totalSent")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/testnet/ins/addr/:address/totalSent")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/testnet/ins/addr/:address/totalSent');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/testnet/ins/addr/:address/totalSent'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/testnet/ins/addr/:address/totalSent';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/testnet/ins/addr/:address/totalSent',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/testnet/ins/addr/:address/totalSent")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/testnet/ins/addr/:address/totalSent',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/testnet/ins/addr/:address/totalSent'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/testnet/ins/addr/:address/totalSent');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/testnet/ins/addr/:address/totalSent'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/testnet/ins/addr/:address/totalSent';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/testnet/ins/addr/:address/totalSent"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/testnet/ins/addr/:address/totalSent" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/testnet/ins/addr/:address/totalSent",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/testnet/ins/addr/:address/totalSent');

echo $response->getBody();

setUrl('{{baseUrl}}/testnet/ins/addr/:address/totalSent');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/testnet/ins/addr/:address/totalSent');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/testnet/ins/addr/:address/totalSent' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/testnet/ins/addr/:address/totalSent' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/testnet/ins/addr/:address/totalSent")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/testnet/ins/addr/:address/totalSent"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/testnet/ins/addr/:address/totalSent"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/testnet/ins/addr/:address/totalSent")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/testnet/ins/addr/:address/totalSent') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/testnet/ins/addr/:address/totalSent";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/testnet/ins/addr/:address/totalSent

http GET {{baseUrl}}/testnet/ins/addr/:address/totalSent

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/testnet/ins/addr/:address/totalSent

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/testnet/ins/addr/:address/totalSent")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Returns transaction object (GET)

{{baseUrl}}/testnet/ins/tx/:txid

QUERY PARAMS

txid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/testnet/ins/tx/:txid");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/testnet/ins/tx/:txid")

require "http/client"

url = "{{baseUrl}}/testnet/ins/tx/:txid"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/testnet/ins/tx/:txid"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/testnet/ins/tx/:txid");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/testnet/ins/tx/:txid"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/testnet/ins/tx/:txid HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/testnet/ins/tx/:txid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/testnet/ins/tx/:txid"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/testnet/ins/tx/:txid")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/testnet/ins/tx/:txid")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/testnet/ins/tx/:txid');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/testnet/ins/tx/:txid'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/testnet/ins/tx/:txid';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/testnet/ins/tx/:txid',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/testnet/ins/tx/:txid")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/testnet/ins/tx/:txid',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/testnet/ins/tx/:txid'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/testnet/ins/tx/:txid');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/testnet/ins/tx/:txid'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/testnet/ins/tx/:txid';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/testnet/ins/tx/:txid"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/testnet/ins/tx/:txid" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/testnet/ins/tx/:txid",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/testnet/ins/tx/:txid');

echo $response->getBody();

setUrl('{{baseUrl}}/testnet/ins/tx/:txid');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/testnet/ins/tx/:txid');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/testnet/ins/tx/:txid' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/testnet/ins/tx/:txid' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/testnet/ins/tx/:txid")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/testnet/ins/tx/:txid"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/testnet/ins/tx/:txid"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/testnet/ins/tx/:txid")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/testnet/ins/tx/:txid') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/testnet/ins/tx/:txid";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/testnet/ins/tx/:txid

http GET {{baseUrl}}/testnet/ins/tx/:txid

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/testnet/ins/tx/:txid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/testnet/ins/tx/:txid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Utility API for calling several blockchain node functions (GET)

{{baseUrl}}/testnet/ins/status

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/testnet/ins/status");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/testnet/ins/status")

require "http/client"

url = "{{baseUrl}}/testnet/ins/status"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/testnet/ins/status"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/testnet/ins/status");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/testnet/ins/status"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/testnet/ins/status HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/testnet/ins/status")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/testnet/ins/status"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/testnet/ins/status")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/testnet/ins/status")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/testnet/ins/status');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/testnet/ins/status'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/testnet/ins/status';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/testnet/ins/status',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/testnet/ins/status")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/testnet/ins/status',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/testnet/ins/status'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/testnet/ins/status');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/testnet/ins/status'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/testnet/ins/status';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/testnet/ins/status"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/testnet/ins/status" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/testnet/ins/status",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/testnet/ins/status');

echo $response->getBody();

setUrl('{{baseUrl}}/testnet/ins/status');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/testnet/ins/status');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/testnet/ins/status' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/testnet/ins/status' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/testnet/ins/status")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/testnet/ins/status"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/testnet/ins/status"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/testnet/ins/status")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/testnet/ins/status') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/testnet/ins/status";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/testnet/ins/status

http GET {{baseUrl}}/testnet/ins/status

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/testnet/ins/status

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/testnet/ins/status")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Broadcasts a signed raw transaction to the network (POST)

{{baseUrl}}/testnet/ntp1/broadcast

BODY json

{
  "txHex": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/testnet/ntp1/broadcast");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"txHex\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/testnet/ntp1/broadcast" {:content-type :json
                                                                   :form-params {:txHex ""}})

require "http/client"

url = "{{baseUrl}}/testnet/ntp1/broadcast"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"txHex\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/testnet/ntp1/broadcast"),
    Content = new StringContent("{\n  \"txHex\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/testnet/ntp1/broadcast");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"txHex\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/testnet/ntp1/broadcast"

	payload := strings.NewReader("{\n  \"txHex\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/testnet/ntp1/broadcast HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 17

{
  "txHex": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/testnet/ntp1/broadcast")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"txHex\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/testnet/ntp1/broadcast"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"txHex\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"txHex\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/testnet/ntp1/broadcast")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/testnet/ntp1/broadcast")
  .header("content-type", "application/json")
  .body("{\n  \"txHex\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  txHex: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/testnet/ntp1/broadcast');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/testnet/ntp1/broadcast',
  headers: {'content-type': 'application/json'},
  data: {txHex: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/testnet/ntp1/broadcast';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"txHex":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/testnet/ntp1/broadcast',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "txHex": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"txHex\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/testnet/ntp1/broadcast")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/testnet/ntp1/broadcast',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({txHex: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/testnet/ntp1/broadcast',
  headers: {'content-type': 'application/json'},
  body: {txHex: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/testnet/ntp1/broadcast');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  txHex: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/testnet/ntp1/broadcast',
  headers: {'content-type': 'application/json'},
  data: {txHex: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/testnet/ntp1/broadcast';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"txHex":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"txHex": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/testnet/ntp1/broadcast"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/testnet/ntp1/broadcast" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"txHex\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/testnet/ntp1/broadcast",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'txHex' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/testnet/ntp1/broadcast', [
  'body' => '{
  "txHex": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/testnet/ntp1/broadcast');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'txHex' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'txHex' => ''
]));
$request->setRequestUrl('{{baseUrl}}/testnet/ntp1/broadcast');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/testnet/ntp1/broadcast' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "txHex": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/testnet/ntp1/broadcast' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "txHex": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"txHex\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/testnet/ntp1/broadcast", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/testnet/ntp1/broadcast"

payload = { "txHex": "" }
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/testnet/ntp1/broadcast"

payload <- "{\n  \"txHex\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/testnet/ntp1/broadcast")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"txHex\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/testnet/ntp1/broadcast') do |req|
  req.body = "{\n  \"txHex\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/testnet/ntp1/broadcast";

    let payload = json!({"txHex": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/testnet/ntp1/broadcast \
  --header 'content-type: application/json' \
  --data '{
  "txHex": ""
}'

echo '{
  "txHex": ""
}' |  \
  http POST {{baseUrl}}/testnet/ntp1/broadcast \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "txHex": ""\n}' \
  --output-document \
  - {{baseUrl}}/testnet/ntp1/broadcast

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["txHex": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/testnet/ntp1/broadcast")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Builds a transaction that burns an NTP1 Token (POST)

{{baseUrl}}/testnet/ntp1/burntoken

BODY json

{
  "burn": [
    {
      "amount": "",
      "tokenId": ""
    }
  ],
  "fee": "",
  "from": [],
  "transfer": [
    {
      "address": "",
      "amount": "",
      "tokenId": ""
    }
  ]
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/testnet/ntp1/burntoken");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"burn\": [\n    {\n      \"amount\": \"\",\n      \"tokenId\": \"\"\n    }\n  ],\n  \"fee\": \"\",\n  \"from\": [],\n  \"transfer\": [\n    {\n      \"address\": \"\",\n      \"amount\": \"\",\n      \"tokenId\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/testnet/ntp1/burntoken" {:content-type :json
                                                                   :form-params {:burn [{:amount ""
                                                                                         :tokenId ""}]
                                                                                 :fee ""
                                                                                 :from []
                                                                                 :transfer [{:address ""
                                                                                             :amount ""
                                                                                             :tokenId ""}]}})

require "http/client"

url = "{{baseUrl}}/testnet/ntp1/burntoken"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"burn\": [\n    {\n      \"amount\": \"\",\n      \"tokenId\": \"\"\n    }\n  ],\n  \"fee\": \"\",\n  \"from\": [],\n  \"transfer\": [\n    {\n      \"address\": \"\",\n      \"amount\": \"\",\n      \"tokenId\": \"\"\n    }\n  ]\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/testnet/ntp1/burntoken"),
    Content = new StringContent("{\n  \"burn\": [\n    {\n      \"amount\": \"\",\n      \"tokenId\": \"\"\n    }\n  ],\n  \"fee\": \"\",\n  \"from\": [],\n  \"transfer\": [\n    {\n      \"address\": \"\",\n      \"amount\": \"\",\n      \"tokenId\": \"\"\n    }\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/testnet/ntp1/burntoken");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"burn\": [\n    {\n      \"amount\": \"\",\n      \"tokenId\": \"\"\n    }\n  ],\n  \"fee\": \"\",\n  \"from\": [],\n  \"transfer\": [\n    {\n      \"address\": \"\",\n      \"amount\": \"\",\n      \"tokenId\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/testnet/ntp1/burntoken"

	payload := strings.NewReader("{\n  \"burn\": [\n    {\n      \"amount\": \"\",\n      \"tokenId\": \"\"\n    }\n  ],\n  \"fee\": \"\",\n  \"from\": [],\n  \"transfer\": [\n    {\n      \"address\": \"\",\n      \"amount\": \"\",\n      \"tokenId\": \"\"\n    }\n  ]\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/testnet/ntp1/burntoken HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 192

{
  "burn": [
    {
      "amount": "",
      "tokenId": ""
    }
  ],
  "fee": "",
  "from": [],
  "transfer": [
    {
      "address": "",
      "amount": "",
      "tokenId": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/testnet/ntp1/burntoken")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"burn\": [\n    {\n      \"amount\": \"\",\n      \"tokenId\": \"\"\n    }\n  ],\n  \"fee\": \"\",\n  \"from\": [],\n  \"transfer\": [\n    {\n      \"address\": \"\",\n      \"amount\": \"\",\n      \"tokenId\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/testnet/ntp1/burntoken"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"burn\": [\n    {\n      \"amount\": \"\",\n      \"tokenId\": \"\"\n    }\n  ],\n  \"fee\": \"\",\n  \"from\": [],\n  \"transfer\": [\n    {\n      \"address\": \"\",\n      \"amount\": \"\",\n      \"tokenId\": \"\"\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"burn\": [\n    {\n      \"amount\": \"\",\n      \"tokenId\": \"\"\n    }\n  ],\n  \"fee\": \"\",\n  \"from\": [],\n  \"transfer\": [\n    {\n      \"address\": \"\",\n      \"amount\": \"\",\n      \"tokenId\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/testnet/ntp1/burntoken")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/testnet/ntp1/burntoken")
  .header("content-type", "application/json")
  .body("{\n  \"burn\": [\n    {\n      \"amount\": \"\",\n      \"tokenId\": \"\"\n    }\n  ],\n  \"fee\": \"\",\n  \"from\": [],\n  \"transfer\": [\n    {\n      \"address\": \"\",\n      \"amount\": \"\",\n      \"tokenId\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  burn: [
    {
      amount: '',
      tokenId: ''
    }
  ],
  fee: '',
  from: [],
  transfer: [
    {
      address: '',
      amount: '',
      tokenId: ''
    }
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/testnet/ntp1/burntoken');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/testnet/ntp1/burntoken',
  headers: {'content-type': 'application/json'},
  data: {
    burn: [{amount: '', tokenId: ''}],
    fee: '',
    from: [],
    transfer: [{address: '', amount: '', tokenId: ''}]
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/testnet/ntp1/burntoken';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"burn":[{"amount":"","tokenId":""}],"fee":"","from":[],"transfer":[{"address":"","amount":"","tokenId":""}]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/testnet/ntp1/burntoken',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "burn": [\n    {\n      "amount": "",\n      "tokenId": ""\n    }\n  ],\n  "fee": "",\n  "from": [],\n  "transfer": [\n    {\n      "address": "",\n      "amount": "",\n      "tokenId": ""\n    }\n  ]\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"burn\": [\n    {\n      \"amount\": \"\",\n      \"tokenId\": \"\"\n    }\n  ],\n  \"fee\": \"\",\n  \"from\": [],\n  \"transfer\": [\n    {\n      \"address\": \"\",\n      \"amount\": \"\",\n      \"tokenId\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/testnet/ntp1/burntoken")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/testnet/ntp1/burntoken',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  burn: [{amount: '', tokenId: ''}],
  fee: '',
  from: [],
  transfer: [{address: '', amount: '', tokenId: ''}]
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/testnet/ntp1/burntoken',
  headers: {'content-type': 'application/json'},
  body: {
    burn: [{amount: '', tokenId: ''}],
    fee: '',
    from: [],
    transfer: [{address: '', amount: '', tokenId: ''}]
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/testnet/ntp1/burntoken');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  burn: [
    {
      amount: '',
      tokenId: ''
    }
  ],
  fee: '',
  from: [],
  transfer: [
    {
      address: '',
      amount: '',
      tokenId: ''
    }
  ]
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/testnet/ntp1/burntoken',
  headers: {'content-type': 'application/json'},
  data: {
    burn: [{amount: '', tokenId: ''}],
    fee: '',
    from: [],
    transfer: [{address: '', amount: '', tokenId: ''}]
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/testnet/ntp1/burntoken';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"burn":[{"amount":"","tokenId":""}],"fee":"","from":[],"transfer":[{"address":"","amount":"","tokenId":""}]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"burn": @[ @{ @"amount": @"", @"tokenId": @"" } ],
                              @"fee": @"",
                              @"from": @[  ],
                              @"transfer": @[ @{ @"address": @"", @"amount": @"", @"tokenId": @"" } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/testnet/ntp1/burntoken"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/testnet/ntp1/burntoken" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"burn\": [\n    {\n      \"amount\": \"\",\n      \"tokenId\": \"\"\n    }\n  ],\n  \"fee\": \"\",\n  \"from\": [],\n  \"transfer\": [\n    {\n      \"address\": \"\",\n      \"amount\": \"\",\n      \"tokenId\": \"\"\n    }\n  ]\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/testnet/ntp1/burntoken",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'burn' => [
        [
                'amount' => '',
                'tokenId' => ''
        ]
    ],
    'fee' => '',
    'from' => [
        
    ],
    'transfer' => [
        [
                'address' => '',
                'amount' => '',
                'tokenId' => ''
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/testnet/ntp1/burntoken', [
  'body' => '{
  "burn": [
    {
      "amount": "",
      "tokenId": ""
    }
  ],
  "fee": "",
  "from": [],
  "transfer": [
    {
      "address": "",
      "amount": "",
      "tokenId": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/testnet/ntp1/burntoken');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'burn' => [
    [
        'amount' => '',
        'tokenId' => ''
    ]
  ],
  'fee' => '',
  'from' => [
    
  ],
  'transfer' => [
    [
        'address' => '',
        'amount' => '',
        'tokenId' => ''
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'burn' => [
    [
        'amount' => '',
        'tokenId' => ''
    ]
  ],
  'fee' => '',
  'from' => [
    
  ],
  'transfer' => [
    [
        'address' => '',
        'amount' => '',
        'tokenId' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/testnet/ntp1/burntoken');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/testnet/ntp1/burntoken' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "burn": [
    {
      "amount": "",
      "tokenId": ""
    }
  ],
  "fee": "",
  "from": [],
  "transfer": [
    {
      "address": "",
      "amount": "",
      "tokenId": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/testnet/ntp1/burntoken' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "burn": [
    {
      "amount": "",
      "tokenId": ""
    }
  ],
  "fee": "",
  "from": [],
  "transfer": [
    {
      "address": "",
      "amount": "",
      "tokenId": ""
    }
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"burn\": [\n    {\n      \"amount\": \"\",\n      \"tokenId\": \"\"\n    }\n  ],\n  \"fee\": \"\",\n  \"from\": [],\n  \"transfer\": [\n    {\n      \"address\": \"\",\n      \"amount\": \"\",\n      \"tokenId\": \"\"\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/testnet/ntp1/burntoken", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/testnet/ntp1/burntoken"

payload = {
    "burn": [
        {
            "amount": "",
            "tokenId": ""
        }
    ],
    "fee": "",
    "from": [],
    "transfer": [
        {
            "address": "",
            "amount": "",
            "tokenId": ""
        }
    ]
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/testnet/ntp1/burntoken"

payload <- "{\n  \"burn\": [\n    {\n      \"amount\": \"\",\n      \"tokenId\": \"\"\n    }\n  ],\n  \"fee\": \"\",\n  \"from\": [],\n  \"transfer\": [\n    {\n      \"address\": \"\",\n      \"amount\": \"\",\n      \"tokenId\": \"\"\n    }\n  ]\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/testnet/ntp1/burntoken")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"burn\": [\n    {\n      \"amount\": \"\",\n      \"tokenId\": \"\"\n    }\n  ],\n  \"fee\": \"\",\n  \"from\": [],\n  \"transfer\": [\n    {\n      \"address\": \"\",\n      \"amount\": \"\",\n      \"tokenId\": \"\"\n    }\n  ]\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/testnet/ntp1/burntoken') do |req|
  req.body = "{\n  \"burn\": [\n    {\n      \"amount\": \"\",\n      \"tokenId\": \"\"\n    }\n  ],\n  \"fee\": \"\",\n  \"from\": [],\n  \"transfer\": [\n    {\n      \"address\": \"\",\n      \"amount\": \"\",\n      \"tokenId\": \"\"\n    }\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/testnet/ntp1/burntoken";

    let payload = json!({
        "burn": (
            json!({
                "amount": "",
                "tokenId": ""
            })
        ),
        "fee": "",
        "from": (),
        "transfer": (
            json!({
                "address": "",
                "amount": "",
                "tokenId": ""
            })
        )
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/testnet/ntp1/burntoken \
  --header 'content-type: application/json' \
  --data '{
  "burn": [
    {
      "amount": "",
      "tokenId": ""
    }
  ],
  "fee": "",
  "from": [],
  "transfer": [
    {
      "address": "",
      "amount": "",
      "tokenId": ""
    }
  ]
}'

echo '{
  "burn": [
    {
      "amount": "",
      "tokenId": ""
    }
  ],
  "fee": "",
  "from": [],
  "transfer": [
    {
      "address": "",
      "amount": "",
      "tokenId": ""
    }
  ]
}' |  \
  http POST {{baseUrl}}/testnet/ntp1/burntoken \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "burn": [\n    {\n      "amount": "",\n      "tokenId": ""\n    }\n  ],\n  "fee": "",\n  "from": [],\n  "transfer": [\n    {\n      "address": "",\n      "amount": "",\n      "tokenId": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/testnet/ntp1/burntoken

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "burn": [
    [
      "amount": "",
      "tokenId": ""
    ]
  ],
  "fee": "",
  "from": [],
  "transfer": [
    [
      "address": "",
      "amount": "",
      "tokenId": ""
    ]
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/testnet/ntp1/burntoken")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Builds a transaction that issues a new NTP1 Token (POST)

{{baseUrl}}/testnet/ntp1/issue

BODY json

{
  "amount": "",
  "divisibility": "",
  "fee": "",
  "flags": {
    "splitChange": false
  },
  "issueAddress": "",
  "metadata": {
    "description": "",
    "encryptions": [
      {
        "format": "",
        "key": "",
        "pubkey": "",
        "type": ""
      }
    ],
    "issuer": "",
    "rules": {
      "expiration": {
        "locked": false,
        "validUntil": ""
      },
      "fees": {
        "items": [
          {
            "address": "",
            "tokenId": "",
            "value": ""
          }
        ],
        "locked": false
      },
      "holders": [
        {
          "address": "",
          "locked": false
        }
      ]
    },
    "tokenName": "",
    "urls": [
      {
        "dataHash": "",
        "mimeType": "",
        "name": "",
        "url": ""
      }
    ],
    "userData": {
      "meta": [
        {
          "key": "",
          "value": ""
        }
      ]
    }
  },
  "reissuable": false,
  "transfer": [
    {
      "address": "",
      "amount": ""
    }
  ]
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/testnet/ntp1/issue");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"amount\": \"\",\n  \"divisibility\": \"\",\n  \"fee\": \"\",\n  \"flags\": {\n    \"splitChange\": false\n  },\n  \"issueAddress\": \"\",\n  \"metadata\": {\n    \"description\": \"\",\n    \"encryptions\": [\n      {\n        \"format\": \"\",\n        \"key\": \"\",\n        \"pubkey\": \"\",\n        \"type\": \"\"\n      }\n    ],\n    \"issuer\": \"\",\n    \"rules\": {\n      \"expiration\": {\n        \"locked\": false,\n        \"validUntil\": \"\"\n      },\n      \"fees\": {\n        \"items\": [\n          {\n            \"address\": \"\",\n            \"tokenId\": \"\",\n            \"value\": \"\"\n          }\n        ],\n        \"locked\": false\n      },\n      \"holders\": [\n        {\n          \"address\": \"\",\n          \"locked\": false\n        }\n      ]\n    },\n    \"tokenName\": \"\",\n    \"urls\": [\n      {\n        \"dataHash\": \"\",\n        \"mimeType\": \"\",\n        \"name\": \"\",\n        \"url\": \"\"\n      }\n    ],\n    \"userData\": {\n      \"meta\": [\n        {\n          \"key\": \"\",\n          \"value\": \"\"\n        }\n      ]\n    }\n  },\n  \"reissuable\": false,\n  \"transfer\": [\n    {\n      \"address\": \"\",\n      \"amount\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/testnet/ntp1/issue" {:content-type :json
                                                               :form-params {:amount ""
                                                                             :divisibility ""
                                                                             :fee ""
                                                                             :flags {:splitChange false}
                                                                             :issueAddress ""
                                                                             :metadata {:description ""
                                                                                        :encryptions [{:format ""
                                                                                                       :key ""
                                                                                                       :pubkey ""
                                                                                                       :type ""}]
                                                                                        :issuer ""
                                                                                        :rules {:expiration {:locked false
                                                                                                             :validUntil ""}
                                                                                                :fees {:items [{:address ""
                                                                                                                :tokenId ""
                                                                                                                :value ""}]
                                                                                                       :locked false}
                                                                                                :holders [{:address ""
                                                                                                           :locked false}]}
                                                                                        :tokenName ""
                                                                                        :urls [{:dataHash ""
                                                                                                :mimeType ""
                                                                                                :name ""
                                                                                                :url ""}]
                                                                                        :userData {:meta [{:key ""
                                                                                                           :value ""}]}}
                                                                             :reissuable false
                                                                             :transfer [{:address ""
                                                                                         :amount ""}]}})

require "http/client"

url = "{{baseUrl}}/testnet/ntp1/issue"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"amount\": \"\",\n  \"divisibility\": \"\",\n  \"fee\": \"\",\n  \"flags\": {\n    \"splitChange\": false\n  },\n  \"issueAddress\": \"\",\n  \"metadata\": {\n    \"description\": \"\",\n    \"encryptions\": [\n      {\n        \"format\": \"\",\n        \"key\": \"\",\n        \"pubkey\": \"\",\n        \"type\": \"\"\n      }\n    ],\n    \"issuer\": \"\",\n    \"rules\": {\n      \"expiration\": {\n        \"locked\": false,\n        \"validUntil\": \"\"\n      },\n      \"fees\": {\n        \"items\": [\n          {\n            \"address\": \"\",\n            \"tokenId\": \"\",\n            \"value\": \"\"\n          }\n        ],\n        \"locked\": false\n      },\n      \"holders\": [\n        {\n          \"address\": \"\",\n          \"locked\": false\n        }\n      ]\n    },\n    \"tokenName\": \"\",\n    \"urls\": [\n      {\n        \"dataHash\": \"\",\n        \"mimeType\": \"\",\n        \"name\": \"\",\n        \"url\": \"\"\n      }\n    ],\n    \"userData\": {\n      \"meta\": [\n        {\n          \"key\": \"\",\n          \"value\": \"\"\n        }\n      ]\n    }\n  },\n  \"reissuable\": false,\n  \"transfer\": [\n    {\n      \"address\": \"\",\n      \"amount\": \"\"\n    }\n  ]\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/testnet/ntp1/issue"),
    Content = new StringContent("{\n  \"amount\": \"\",\n  \"divisibility\": \"\",\n  \"fee\": \"\",\n  \"flags\": {\n    \"splitChange\": false\n  },\n  \"issueAddress\": \"\",\n  \"metadata\": {\n    \"description\": \"\",\n    \"encryptions\": [\n      {\n        \"format\": \"\",\n        \"key\": \"\",\n        \"pubkey\": \"\",\n        \"type\": \"\"\n      }\n    ],\n    \"issuer\": \"\",\n    \"rules\": {\n      \"expiration\": {\n        \"locked\": false,\n        \"validUntil\": \"\"\n      },\n      \"fees\": {\n        \"items\": [\n          {\n            \"address\": \"\",\n            \"tokenId\": \"\",\n            \"value\": \"\"\n          }\n        ],\n        \"locked\": false\n      },\n      \"holders\": [\n        {\n          \"address\": \"\",\n          \"locked\": false\n        }\n      ]\n    },\n    \"tokenName\": \"\",\n    \"urls\": [\n      {\n        \"dataHash\": \"\",\n        \"mimeType\": \"\",\n        \"name\": \"\",\n        \"url\": \"\"\n      }\n    ],\n    \"userData\": {\n      \"meta\": [\n        {\n          \"key\": \"\",\n          \"value\": \"\"\n        }\n      ]\n    }\n  },\n  \"reissuable\": false,\n  \"transfer\": [\n    {\n      \"address\": \"\",\n      \"amount\": \"\"\n    }\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/testnet/ntp1/issue");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"amount\": \"\",\n  \"divisibility\": \"\",\n  \"fee\": \"\",\n  \"flags\": {\n    \"splitChange\": false\n  },\n  \"issueAddress\": \"\",\n  \"metadata\": {\n    \"description\": \"\",\n    \"encryptions\": [\n      {\n        \"format\": \"\",\n        \"key\": \"\",\n        \"pubkey\": \"\",\n        \"type\": \"\"\n      }\n    ],\n    \"issuer\": \"\",\n    \"rules\": {\n      \"expiration\": {\n        \"locked\": false,\n        \"validUntil\": \"\"\n      },\n      \"fees\": {\n        \"items\": [\n          {\n            \"address\": \"\",\n            \"tokenId\": \"\",\n            \"value\": \"\"\n          }\n        ],\n        \"locked\": false\n      },\n      \"holders\": [\n        {\n          \"address\": \"\",\n          \"locked\": false\n        }\n      ]\n    },\n    \"tokenName\": \"\",\n    \"urls\": [\n      {\n        \"dataHash\": \"\",\n        \"mimeType\": \"\",\n        \"name\": \"\",\n        \"url\": \"\"\n      }\n    ],\n    \"userData\": {\n      \"meta\": [\n        {\n          \"key\": \"\",\n          \"value\": \"\"\n        }\n      ]\n    }\n  },\n  \"reissuable\": false,\n  \"transfer\": [\n    {\n      \"address\": \"\",\n      \"amount\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/testnet/ntp1/issue"

	payload := strings.NewReader("{\n  \"amount\": \"\",\n  \"divisibility\": \"\",\n  \"fee\": \"\",\n  \"flags\": {\n    \"splitChange\": false\n  },\n  \"issueAddress\": \"\",\n  \"metadata\": {\n    \"description\": \"\",\n    \"encryptions\": [\n      {\n        \"format\": \"\",\n        \"key\": \"\",\n        \"pubkey\": \"\",\n        \"type\": \"\"\n      }\n    ],\n    \"issuer\": \"\",\n    \"rules\": {\n      \"expiration\": {\n        \"locked\": false,\n        \"validUntil\": \"\"\n      },\n      \"fees\": {\n        \"items\": [\n          {\n            \"address\": \"\",\n            \"tokenId\": \"\",\n            \"value\": \"\"\n          }\n        ],\n        \"locked\": false\n      },\n      \"holders\": [\n        {\n          \"address\": \"\",\n          \"locked\": false\n        }\n      ]\n    },\n    \"tokenName\": \"\",\n    \"urls\": [\n      {\n        \"dataHash\": \"\",\n        \"mimeType\": \"\",\n        \"name\": \"\",\n        \"url\": \"\"\n      }\n    ],\n    \"userData\": {\n      \"meta\": [\n        {\n          \"key\": \"\",\n          \"value\": \"\"\n        }\n      ]\n    }\n  },\n  \"reissuable\": false,\n  \"transfer\": [\n    {\n      \"address\": \"\",\n      \"amount\": \"\"\n    }\n  ]\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/testnet/ntp1/issue HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 1039

{
  "amount": "",
  "divisibility": "",
  "fee": "",
  "flags": {
    "splitChange": false
  },
  "issueAddress": "",
  "metadata": {
    "description": "",
    "encryptions": [
      {
        "format": "",
        "key": "",
        "pubkey": "",
        "type": ""
      }
    ],
    "issuer": "",
    "rules": {
      "expiration": {
        "locked": false,
        "validUntil": ""
      },
      "fees": {
        "items": [
          {
            "address": "",
            "tokenId": "",
            "value": ""
          }
        ],
        "locked": false
      },
      "holders": [
        {
          "address": "",
          "locked": false
        }
      ]
    },
    "tokenName": "",
    "urls": [
      {
        "dataHash": "",
        "mimeType": "",
        "name": "",
        "url": ""
      }
    ],
    "userData": {
      "meta": [
        {
          "key": "",
          "value": ""
        }
      ]
    }
  },
  "reissuable": false,
  "transfer": [
    {
      "address": "",
      "amount": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/testnet/ntp1/issue")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"amount\": \"\",\n  \"divisibility\": \"\",\n  \"fee\": \"\",\n  \"flags\": {\n    \"splitChange\": false\n  },\n  \"issueAddress\": \"\",\n  \"metadata\": {\n    \"description\": \"\",\n    \"encryptions\": [\n      {\n        \"format\": \"\",\n        \"key\": \"\",\n        \"pubkey\": \"\",\n        \"type\": \"\"\n      }\n    ],\n    \"issuer\": \"\",\n    \"rules\": {\n      \"expiration\": {\n        \"locked\": false,\n        \"validUntil\": \"\"\n      },\n      \"fees\": {\n        \"items\": [\n          {\n            \"address\": \"\",\n            \"tokenId\": \"\",\n            \"value\": \"\"\n          }\n        ],\n        \"locked\": false\n      },\n      \"holders\": [\n        {\n          \"address\": \"\",\n          \"locked\": false\n        }\n      ]\n    },\n    \"tokenName\": \"\",\n    \"urls\": [\n      {\n        \"dataHash\": \"\",\n        \"mimeType\": \"\",\n        \"name\": \"\",\n        \"url\": \"\"\n      }\n    ],\n    \"userData\": {\n      \"meta\": [\n        {\n          \"key\": \"\",\n          \"value\": \"\"\n        }\n      ]\n    }\n  },\n  \"reissuable\": false,\n  \"transfer\": [\n    {\n      \"address\": \"\",\n      \"amount\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/testnet/ntp1/issue"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"amount\": \"\",\n  \"divisibility\": \"\",\n  \"fee\": \"\",\n  \"flags\": {\n    \"splitChange\": false\n  },\n  \"issueAddress\": \"\",\n  \"metadata\": {\n    \"description\": \"\",\n    \"encryptions\": [\n      {\n        \"format\": \"\",\n        \"key\": \"\",\n        \"pubkey\": \"\",\n        \"type\": \"\"\n      }\n    ],\n    \"issuer\": \"\",\n    \"rules\": {\n      \"expiration\": {\n        \"locked\": false,\n        \"validUntil\": \"\"\n      },\n      \"fees\": {\n        \"items\": [\n          {\n            \"address\": \"\",\n            \"tokenId\": \"\",\n            \"value\": \"\"\n          }\n        ],\n        \"locked\": false\n      },\n      \"holders\": [\n        {\n          \"address\": \"\",\n          \"locked\": false\n        }\n      ]\n    },\n    \"tokenName\": \"\",\n    \"urls\": [\n      {\n        \"dataHash\": \"\",\n        \"mimeType\": \"\",\n        \"name\": \"\",\n        \"url\": \"\"\n      }\n    ],\n    \"userData\": {\n      \"meta\": [\n        {\n          \"key\": \"\",\n          \"value\": \"\"\n        }\n      ]\n    }\n  },\n  \"reissuable\": false,\n  \"transfer\": [\n    {\n      \"address\": \"\",\n      \"amount\": \"\"\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"amount\": \"\",\n  \"divisibility\": \"\",\n  \"fee\": \"\",\n  \"flags\": {\n    \"splitChange\": false\n  },\n  \"issueAddress\": \"\",\n  \"metadata\": {\n    \"description\": \"\",\n    \"encryptions\": [\n      {\n        \"format\": \"\",\n        \"key\": \"\",\n        \"pubkey\": \"\",\n        \"type\": \"\"\n      }\n    ],\n    \"issuer\": \"\",\n    \"rules\": {\n      \"expiration\": {\n        \"locked\": false,\n        \"validUntil\": \"\"\n      },\n      \"fees\": {\n        \"items\": [\n          {\n            \"address\": \"\",\n            \"tokenId\": \"\",\n            \"value\": \"\"\n          }\n        ],\n        \"locked\": false\n      },\n      \"holders\": [\n        {\n          \"address\": \"\",\n          \"locked\": false\n        }\n      ]\n    },\n    \"tokenName\": \"\",\n    \"urls\": [\n      {\n        \"dataHash\": \"\",\n        \"mimeType\": \"\",\n        \"name\": \"\",\n        \"url\": \"\"\n      }\n    ],\n    \"userData\": {\n      \"meta\": [\n        {\n          \"key\": \"\",\n          \"value\": \"\"\n        }\n      ]\n    }\n  },\n  \"reissuable\": false,\n  \"transfer\": [\n    {\n      \"address\": \"\",\n      \"amount\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/testnet/ntp1/issue")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/testnet/ntp1/issue")
  .header("content-type", "application/json")
  .body("{\n  \"amount\": \"\",\n  \"divisibility\": \"\",\n  \"fee\": \"\",\n  \"flags\": {\n    \"splitChange\": false\n  },\n  \"issueAddress\": \"\",\n  \"metadata\": {\n    \"description\": \"\",\n    \"encryptions\": [\n      {\n        \"format\": \"\",\n        \"key\": \"\",\n        \"pubkey\": \"\",\n        \"type\": \"\"\n      }\n    ],\n    \"issuer\": \"\",\n    \"rules\": {\n      \"expiration\": {\n        \"locked\": false,\n        \"validUntil\": \"\"\n      },\n      \"fees\": {\n        \"items\": [\n          {\n            \"address\": \"\",\n            \"tokenId\": \"\",\n            \"value\": \"\"\n          }\n        ],\n        \"locked\": false\n      },\n      \"holders\": [\n        {\n          \"address\": \"\",\n          \"locked\": false\n        }\n      ]\n    },\n    \"tokenName\": \"\",\n    \"urls\": [\n      {\n        \"dataHash\": \"\",\n        \"mimeType\": \"\",\n        \"name\": \"\",\n        \"url\": \"\"\n      }\n    ],\n    \"userData\": {\n      \"meta\": [\n        {\n          \"key\": \"\",\n          \"value\": \"\"\n        }\n      ]\n    }\n  },\n  \"reissuable\": false,\n  \"transfer\": [\n    {\n      \"address\": \"\",\n      \"amount\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  amount: '',
  divisibility: '',
  fee: '',
  flags: {
    splitChange: false
  },
  issueAddress: '',
  metadata: {
    description: '',
    encryptions: [
      {
        format: '',
        key: '',
        pubkey: '',
        type: ''
      }
    ],
    issuer: '',
    rules: {
      expiration: {
        locked: false,
        validUntil: ''
      },
      fees: {
        items: [
          {
            address: '',
            tokenId: '',
            value: ''
          }
        ],
        locked: false
      },
      holders: [
        {
          address: '',
          locked: false
        }
      ]
    },
    tokenName: '',
    urls: [
      {
        dataHash: '',
        mimeType: '',
        name: '',
        url: ''
      }
    ],
    userData: {
      meta: [
        {
          key: '',
          value: ''
        }
      ]
    }
  },
  reissuable: false,
  transfer: [
    {
      address: '',
      amount: ''
    }
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/testnet/ntp1/issue');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/testnet/ntp1/issue',
  headers: {'content-type': 'application/json'},
  data: {
    amount: '',
    divisibility: '',
    fee: '',
    flags: {splitChange: false},
    issueAddress: '',
    metadata: {
      description: '',
      encryptions: [{format: '', key: '', pubkey: '', type: ''}],
      issuer: '',
      rules: {
        expiration: {locked: false, validUntil: ''},
        fees: {items: [{address: '', tokenId: '', value: ''}], locked: false},
        holders: [{address: '', locked: false}]
      },
      tokenName: '',
      urls: [{dataHash: '', mimeType: '', name: '', url: ''}],
      userData: {meta: [{key: '', value: ''}]}
    },
    reissuable: false,
    transfer: [{address: '', amount: ''}]
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/testnet/ntp1/issue';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"amount":"","divisibility":"","fee":"","flags":{"splitChange":false},"issueAddress":"","metadata":{"description":"","encryptions":[{"format":"","key":"","pubkey":"","type":""}],"issuer":"","rules":{"expiration":{"locked":false,"validUntil":""},"fees":{"items":[{"address":"","tokenId":"","value":""}],"locked":false},"holders":[{"address":"","locked":false}]},"tokenName":"","urls":[{"dataHash":"","mimeType":"","name":"","url":""}],"userData":{"meta":[{"key":"","value":""}]}},"reissuable":false,"transfer":[{"address":"","amount":""}]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/testnet/ntp1/issue',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "amount": "",\n  "divisibility": "",\n  "fee": "",\n  "flags": {\n    "splitChange": false\n  },\n  "issueAddress": "",\n  "metadata": {\n    "description": "",\n    "encryptions": [\n      {\n        "format": "",\n        "key": "",\n        "pubkey": "",\n        "type": ""\n      }\n    ],\n    "issuer": "",\n    "rules": {\n      "expiration": {\n        "locked": false,\n        "validUntil": ""\n      },\n      "fees": {\n        "items": [\n          {\n            "address": "",\n            "tokenId": "",\n            "value": ""\n          }\n        ],\n        "locked": false\n      },\n      "holders": [\n        {\n          "address": "",\n          "locked": false\n        }\n      ]\n    },\n    "tokenName": "",\n    "urls": [\n      {\n        "dataHash": "",\n        "mimeType": "",\n        "name": "",\n        "url": ""\n      }\n    ],\n    "userData": {\n      "meta": [\n        {\n          "key": "",\n          "value": ""\n        }\n      ]\n    }\n  },\n  "reissuable": false,\n  "transfer": [\n    {\n      "address": "",\n      "amount": ""\n    }\n  ]\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"amount\": \"\",\n  \"divisibility\": \"\",\n  \"fee\": \"\",\n  \"flags\": {\n    \"splitChange\": false\n  },\n  \"issueAddress\": \"\",\n  \"metadata\": {\n    \"description\": \"\",\n    \"encryptions\": [\n      {\n        \"format\": \"\",\n        \"key\": \"\",\n        \"pubkey\": \"\",\n        \"type\": \"\"\n      }\n    ],\n    \"issuer\": \"\",\n    \"rules\": {\n      \"expiration\": {\n        \"locked\": false,\n        \"validUntil\": \"\"\n      },\n      \"fees\": {\n        \"items\": [\n          {\n            \"address\": \"\",\n            \"tokenId\": \"\",\n            \"value\": \"\"\n          }\n        ],\n        \"locked\": false\n      },\n      \"holders\": [\n        {\n          \"address\": \"\",\n          \"locked\": false\n        }\n      ]\n    },\n    \"tokenName\": \"\",\n    \"urls\": [\n      {\n        \"dataHash\": \"\",\n        \"mimeType\": \"\",\n        \"name\": \"\",\n        \"url\": \"\"\n      }\n    ],\n    \"userData\": {\n      \"meta\": [\n        {\n          \"key\": \"\",\n          \"value\": \"\"\n        }\n      ]\n    }\n  },\n  \"reissuable\": false,\n  \"transfer\": [\n    {\n      \"address\": \"\",\n      \"amount\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/testnet/ntp1/issue")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/testnet/ntp1/issue',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  amount: '',
  divisibility: '',
  fee: '',
  flags: {splitChange: false},
  issueAddress: '',
  metadata: {
    description: '',
    encryptions: [{format: '', key: '', pubkey: '', type: ''}],
    issuer: '',
    rules: {
      expiration: {locked: false, validUntil: ''},
      fees: {items: [{address: '', tokenId: '', value: ''}], locked: false},
      holders: [{address: '', locked: false}]
    },
    tokenName: '',
    urls: [{dataHash: '', mimeType: '', name: '', url: ''}],
    userData: {meta: [{key: '', value: ''}]}
  },
  reissuable: false,
  transfer: [{address: '', amount: ''}]
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/testnet/ntp1/issue',
  headers: {'content-type': 'application/json'},
  body: {
    amount: '',
    divisibility: '',
    fee: '',
    flags: {splitChange: false},
    issueAddress: '',
    metadata: {
      description: '',
      encryptions: [{format: '', key: '', pubkey: '', type: ''}],
      issuer: '',
      rules: {
        expiration: {locked: false, validUntil: ''},
        fees: {items: [{address: '', tokenId: '', value: ''}], locked: false},
        holders: [{address: '', locked: false}]
      },
      tokenName: '',
      urls: [{dataHash: '', mimeType: '', name: '', url: ''}],
      userData: {meta: [{key: '', value: ''}]}
    },
    reissuable: false,
    transfer: [{address: '', amount: ''}]
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/testnet/ntp1/issue');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  amount: '',
  divisibility: '',
  fee: '',
  flags: {
    splitChange: false
  },
  issueAddress: '',
  metadata: {
    description: '',
    encryptions: [
      {
        format: '',
        key: '',
        pubkey: '',
        type: ''
      }
    ],
    issuer: '',
    rules: {
      expiration: {
        locked: false,
        validUntil: ''
      },
      fees: {
        items: [
          {
            address: '',
            tokenId: '',
            value: ''
          }
        ],
        locked: false
      },
      holders: [
        {
          address: '',
          locked: false
        }
      ]
    },
    tokenName: '',
    urls: [
      {
        dataHash: '',
        mimeType: '',
        name: '',
        url: ''
      }
    ],
    userData: {
      meta: [
        {
          key: '',
          value: ''
        }
      ]
    }
  },
  reissuable: false,
  transfer: [
    {
      address: '',
      amount: ''
    }
  ]
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/testnet/ntp1/issue',
  headers: {'content-type': 'application/json'},
  data: {
    amount: '',
    divisibility: '',
    fee: '',
    flags: {splitChange: false},
    issueAddress: '',
    metadata: {
      description: '',
      encryptions: [{format: '', key: '', pubkey: '', type: ''}],
      issuer: '',
      rules: {
        expiration: {locked: false, validUntil: ''},
        fees: {items: [{address: '', tokenId: '', value: ''}], locked: false},
        holders: [{address: '', locked: false}]
      },
      tokenName: '',
      urls: [{dataHash: '', mimeType: '', name: '', url: ''}],
      userData: {meta: [{key: '', value: ''}]}
    },
    reissuable: false,
    transfer: [{address: '', amount: ''}]
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/testnet/ntp1/issue';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"amount":"","divisibility":"","fee":"","flags":{"splitChange":false},"issueAddress":"","metadata":{"description":"","encryptions":[{"format":"","key":"","pubkey":"","type":""}],"issuer":"","rules":{"expiration":{"locked":false,"validUntil":""},"fees":{"items":[{"address":"","tokenId":"","value":""}],"locked":false},"holders":[{"address":"","locked":false}]},"tokenName":"","urls":[{"dataHash":"","mimeType":"","name":"","url":""}],"userData":{"meta":[{"key":"","value":""}]}},"reissuable":false,"transfer":[{"address":"","amount":""}]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"amount": @"",
                              @"divisibility": @"",
                              @"fee": @"",
                              @"flags": @{ @"splitChange": @NO },
                              @"issueAddress": @"",
                              @"metadata": @{ @"description": @"", @"encryptions": @[ @{ @"format": @"", @"key": @"", @"pubkey": @"", @"type": @"" } ], @"issuer": @"", @"rules": @{ @"expiration": @{ @"locked": @NO, @"validUntil": @"" }, @"fees": @{ @"items": @[ @{ @"address": @"", @"tokenId": @"", @"value": @"" } ], @"locked": @NO }, @"holders": @[ @{ @"address": @"", @"locked": @NO } ] }, @"tokenName": @"", @"urls": @[ @{ @"dataHash": @"", @"mimeType": @"", @"name": @"", @"url": @"" } ], @"userData": @{ @"meta": @[ @{ @"key": @"", @"value": @"" } ] } },
                              @"reissuable": @NO,
                              @"transfer": @[ @{ @"address": @"", @"amount": @"" } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/testnet/ntp1/issue"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/testnet/ntp1/issue" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"amount\": \"\",\n  \"divisibility\": \"\",\n  \"fee\": \"\",\n  \"flags\": {\n    \"splitChange\": false\n  },\n  \"issueAddress\": \"\",\n  \"metadata\": {\n    \"description\": \"\",\n    \"encryptions\": [\n      {\n        \"format\": \"\",\n        \"key\": \"\",\n        \"pubkey\": \"\",\n        \"type\": \"\"\n      }\n    ],\n    \"issuer\": \"\",\n    \"rules\": {\n      \"expiration\": {\n        \"locked\": false,\n        \"validUntil\": \"\"\n      },\n      \"fees\": {\n        \"items\": [\n          {\n            \"address\": \"\",\n            \"tokenId\": \"\",\n            \"value\": \"\"\n          }\n        ],\n        \"locked\": false\n      },\n      \"holders\": [\n        {\n          \"address\": \"\",\n          \"locked\": false\n        }\n      ]\n    },\n    \"tokenName\": \"\",\n    \"urls\": [\n      {\n        \"dataHash\": \"\",\n        \"mimeType\": \"\",\n        \"name\": \"\",\n        \"url\": \"\"\n      }\n    ],\n    \"userData\": {\n      \"meta\": [\n        {\n          \"key\": \"\",\n          \"value\": \"\"\n        }\n      ]\n    }\n  },\n  \"reissuable\": false,\n  \"transfer\": [\n    {\n      \"address\": \"\",\n      \"amount\": \"\"\n    }\n  ]\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/testnet/ntp1/issue",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'amount' => '',
    'divisibility' => '',
    'fee' => '',
    'flags' => [
        'splitChange' => null
    ],
    'issueAddress' => '',
    'metadata' => [
        'description' => '',
        'encryptions' => [
                [
                                'format' => '',
                                'key' => '',
                                'pubkey' => '',
                                'type' => ''
                ]
        ],
        'issuer' => '',
        'rules' => [
                'expiration' => [
                                'locked' => null,
                                'validUntil' => ''
                ],
                'fees' => [
                                'items' => [
                                                                [
                                                                                                                                'address' => '',
                                                                                                                                'tokenId' => '',
                                                                                                                                'value' => ''
                                                                ]
                                ],
                                'locked' => null
                ],
                'holders' => [
                                [
                                                                'address' => '',
                                                                'locked' => null
                                ]
                ]
        ],
        'tokenName' => '',
        'urls' => [
                [
                                'dataHash' => '',
                                'mimeType' => '',
                                'name' => '',
                                'url' => ''
                ]
        ],
        'userData' => [
                'meta' => [
                                [
                                                                'key' => '',
                                                                'value' => ''
                                ]
                ]
        ]
    ],
    'reissuable' => null,
    'transfer' => [
        [
                'address' => '',
                'amount' => ''
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/testnet/ntp1/issue', [
  'body' => '{
  "amount": "",
  "divisibility": "",
  "fee": "",
  "flags": {
    "splitChange": false
  },
  "issueAddress": "",
  "metadata": {
    "description": "",
    "encryptions": [
      {
        "format": "",
        "key": "",
        "pubkey": "",
        "type": ""
      }
    ],
    "issuer": "",
    "rules": {
      "expiration": {
        "locked": false,
        "validUntil": ""
      },
      "fees": {
        "items": [
          {
            "address": "",
            "tokenId": "",
            "value": ""
          }
        ],
        "locked": false
      },
      "holders": [
        {
          "address": "",
          "locked": false
        }
      ]
    },
    "tokenName": "",
    "urls": [
      {
        "dataHash": "",
        "mimeType": "",
        "name": "",
        "url": ""
      }
    ],
    "userData": {
      "meta": [
        {
          "key": "",
          "value": ""
        }
      ]
    }
  },
  "reissuable": false,
  "transfer": [
    {
      "address": "",
      "amount": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/testnet/ntp1/issue');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'amount' => '',
  'divisibility' => '',
  'fee' => '',
  'flags' => [
    'splitChange' => null
  ],
  'issueAddress' => '',
  'metadata' => [
    'description' => '',
    'encryptions' => [
        [
                'format' => '',
                'key' => '',
                'pubkey' => '',
                'type' => ''
        ]
    ],
    'issuer' => '',
    'rules' => [
        'expiration' => [
                'locked' => null,
                'validUntil' => ''
        ],
        'fees' => [
                'items' => [
                                [
                                                                'address' => '',
                                                                'tokenId' => '',
                                                                'value' => ''
                                ]
                ],
                'locked' => null
        ],
        'holders' => [
                [
                                'address' => '',
                                'locked' => null
                ]
        ]
    ],
    'tokenName' => '',
    'urls' => [
        [
                'dataHash' => '',
                'mimeType' => '',
                'name' => '',
                'url' => ''
        ]
    ],
    'userData' => [
        'meta' => [
                [
                                'key' => '',
                                'value' => ''
                ]
        ]
    ]
  ],
  'reissuable' => null,
  'transfer' => [
    [
        'address' => '',
        'amount' => ''
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'amount' => '',
  'divisibility' => '',
  'fee' => '',
  'flags' => [
    'splitChange' => null
  ],
  'issueAddress' => '',
  'metadata' => [
    'description' => '',
    'encryptions' => [
        [
                'format' => '',
                'key' => '',
                'pubkey' => '',
                'type' => ''
        ]
    ],
    'issuer' => '',
    'rules' => [
        'expiration' => [
                'locked' => null,
                'validUntil' => ''
        ],
        'fees' => [
                'items' => [
                                [
                                                                'address' => '',
                                                                'tokenId' => '',
                                                                'value' => ''
                                ]
                ],
                'locked' => null
        ],
        'holders' => [
                [
                                'address' => '',
                                'locked' => null
                ]
        ]
    ],
    'tokenName' => '',
    'urls' => [
        [
                'dataHash' => '',
                'mimeType' => '',
                'name' => '',
                'url' => ''
        ]
    ],
    'userData' => [
        'meta' => [
                [
                                'key' => '',
                                'value' => ''
                ]
        ]
    ]
  ],
  'reissuable' => null,
  'transfer' => [
    [
        'address' => '',
        'amount' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/testnet/ntp1/issue');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/testnet/ntp1/issue' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "amount": "",
  "divisibility": "",
  "fee": "",
  "flags": {
    "splitChange": false
  },
  "issueAddress": "",
  "metadata": {
    "description": "",
    "encryptions": [
      {
        "format": "",
        "key": "",
        "pubkey": "",
        "type": ""
      }
    ],
    "issuer": "",
    "rules": {
      "expiration": {
        "locked": false,
        "validUntil": ""
      },
      "fees": {
        "items": [
          {
            "address": "",
            "tokenId": "",
            "value": ""
          }
        ],
        "locked": false
      },
      "holders": [
        {
          "address": "",
          "locked": false
        }
      ]
    },
    "tokenName": "",
    "urls": [
      {
        "dataHash": "",
        "mimeType": "",
        "name": "",
        "url": ""
      }
    ],
    "userData": {
      "meta": [
        {
          "key": "",
          "value": ""
        }
      ]
    }
  },
  "reissuable": false,
  "transfer": [
    {
      "address": "",
      "amount": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/testnet/ntp1/issue' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "amount": "",
  "divisibility": "",
  "fee": "",
  "flags": {
    "splitChange": false
  },
  "issueAddress": "",
  "metadata": {
    "description": "",
    "encryptions": [
      {
        "format": "",
        "key": "",
        "pubkey": "",
        "type": ""
      }
    ],
    "issuer": "",
    "rules": {
      "expiration": {
        "locked": false,
        "validUntil": ""
      },
      "fees": {
        "items": [
          {
            "address": "",
            "tokenId": "",
            "value": ""
          }
        ],
        "locked": false
      },
      "holders": [
        {
          "address": "",
          "locked": false
        }
      ]
    },
    "tokenName": "",
    "urls": [
      {
        "dataHash": "",
        "mimeType": "",
        "name": "",
        "url": ""
      }
    ],
    "userData": {
      "meta": [
        {
          "key": "",
          "value": ""
        }
      ]
    }
  },
  "reissuable": false,
  "transfer": [
    {
      "address": "",
      "amount": ""
    }
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"amount\": \"\",\n  \"divisibility\": \"\",\n  \"fee\": \"\",\n  \"flags\": {\n    \"splitChange\": false\n  },\n  \"issueAddress\": \"\",\n  \"metadata\": {\n    \"description\": \"\",\n    \"encryptions\": [\n      {\n        \"format\": \"\",\n        \"key\": \"\",\n        \"pubkey\": \"\",\n        \"type\": \"\"\n      }\n    ],\n    \"issuer\": \"\",\n    \"rules\": {\n      \"expiration\": {\n        \"locked\": false,\n        \"validUntil\": \"\"\n      },\n      \"fees\": {\n        \"items\": [\n          {\n            \"address\": \"\",\n            \"tokenId\": \"\",\n            \"value\": \"\"\n          }\n        ],\n        \"locked\": false\n      },\n      \"holders\": [\n        {\n          \"address\": \"\",\n          \"locked\": false\n        }\n      ]\n    },\n    \"tokenName\": \"\",\n    \"urls\": [\n      {\n        \"dataHash\": \"\",\n        \"mimeType\": \"\",\n        \"name\": \"\",\n        \"url\": \"\"\n      }\n    ],\n    \"userData\": {\n      \"meta\": [\n        {\n          \"key\": \"\",\n          \"value\": \"\"\n        }\n      ]\n    }\n  },\n  \"reissuable\": false,\n  \"transfer\": [\n    {\n      \"address\": \"\",\n      \"amount\": \"\"\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/testnet/ntp1/issue", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/testnet/ntp1/issue"

payload = {
    "amount": "",
    "divisibility": "",
    "fee": "",
    "flags": { "splitChange": False },
    "issueAddress": "",
    "metadata": {
        "description": "",
        "encryptions": [
            {
                "format": "",
                "key": "",
                "pubkey": "",
                "type": ""
            }
        ],
        "issuer": "",
        "rules": {
            "expiration": {
                "locked": False,
                "validUntil": ""
            },
            "fees": {
                "items": [
                    {
                        "address": "",
                        "tokenId": "",
                        "value": ""
                    }
                ],
                "locked": False
            },
            "holders": [
                {
                    "address": "",
                    "locked": False
                }
            ]
        },
        "tokenName": "",
        "urls": [
            {
                "dataHash": "",
                "mimeType": "",
                "name": "",
                "url": ""
            }
        ],
        "userData": { "meta": [
                {
                    "key": "",
                    "value": ""
                }
            ] }
    },
    "reissuable": False,
    "transfer": [
        {
            "address": "",
            "amount": ""
        }
    ]
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/testnet/ntp1/issue"

payload <- "{\n  \"amount\": \"\",\n  \"divisibility\": \"\",\n  \"fee\": \"\",\n  \"flags\": {\n    \"splitChange\": false\n  },\n  \"issueAddress\": \"\",\n  \"metadata\": {\n    \"description\": \"\",\n    \"encryptions\": [\n      {\n        \"format\": \"\",\n        \"key\": \"\",\n        \"pubkey\": \"\",\n        \"type\": \"\"\n      }\n    ],\n    \"issuer\": \"\",\n    \"rules\": {\n      \"expiration\": {\n        \"locked\": false,\n        \"validUntil\": \"\"\n      },\n      \"fees\": {\n        \"items\": [\n          {\n            \"address\": \"\",\n            \"tokenId\": \"\",\n            \"value\": \"\"\n          }\n        ],\n        \"locked\": false\n      },\n      \"holders\": [\n        {\n          \"address\": \"\",\n          \"locked\": false\n        }\n      ]\n    },\n    \"tokenName\": \"\",\n    \"urls\": [\n      {\n        \"dataHash\": \"\",\n        \"mimeType\": \"\",\n        \"name\": \"\",\n        \"url\": \"\"\n      }\n    ],\n    \"userData\": {\n      \"meta\": [\n        {\n          \"key\": \"\",\n          \"value\": \"\"\n        }\n      ]\n    }\n  },\n  \"reissuable\": false,\n  \"transfer\": [\n    {\n      \"address\": \"\",\n      \"amount\": \"\"\n    }\n  ]\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/testnet/ntp1/issue")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"amount\": \"\",\n  \"divisibility\": \"\",\n  \"fee\": \"\",\n  \"flags\": {\n    \"splitChange\": false\n  },\n  \"issueAddress\": \"\",\n  \"metadata\": {\n    \"description\": \"\",\n    \"encryptions\": [\n      {\n        \"format\": \"\",\n        \"key\": \"\",\n        \"pubkey\": \"\",\n        \"type\": \"\"\n      }\n    ],\n    \"issuer\": \"\",\n    \"rules\": {\n      \"expiration\": {\n        \"locked\": false,\n        \"validUntil\": \"\"\n      },\n      \"fees\": {\n        \"items\": [\n          {\n            \"address\": \"\",\n            \"tokenId\": \"\",\n            \"value\": \"\"\n          }\n        ],\n        \"locked\": false\n      },\n      \"holders\": [\n        {\n          \"address\": \"\",\n          \"locked\": false\n        }\n      ]\n    },\n    \"tokenName\": \"\",\n    \"urls\": [\n      {\n        \"dataHash\": \"\",\n        \"mimeType\": \"\",\n        \"name\": \"\",\n        \"url\": \"\"\n      }\n    ],\n    \"userData\": {\n      \"meta\": [\n        {\n          \"key\": \"\",\n          \"value\": \"\"\n        }\n      ]\n    }\n  },\n  \"reissuable\": false,\n  \"transfer\": [\n    {\n      \"address\": \"\",\n      \"amount\": \"\"\n    }\n  ]\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/testnet/ntp1/issue') do |req|
  req.body = "{\n  \"amount\": \"\",\n  \"divisibility\": \"\",\n  \"fee\": \"\",\n  \"flags\": {\n    \"splitChange\": false\n  },\n  \"issueAddress\": \"\",\n  \"metadata\": {\n    \"description\": \"\",\n    \"encryptions\": [\n      {\n        \"format\": \"\",\n        \"key\": \"\",\n        \"pubkey\": \"\",\n        \"type\": \"\"\n      }\n    ],\n    \"issuer\": \"\",\n    \"rules\": {\n      \"expiration\": {\n        \"locked\": false,\n        \"validUntil\": \"\"\n      },\n      \"fees\": {\n        \"items\": [\n          {\n            \"address\": \"\",\n            \"tokenId\": \"\",\n            \"value\": \"\"\n          }\n        ],\n        \"locked\": false\n      },\n      \"holders\": [\n        {\n          \"address\": \"\",\n          \"locked\": false\n        }\n      ]\n    },\n    \"tokenName\": \"\",\n    \"urls\": [\n      {\n        \"dataHash\": \"\",\n        \"mimeType\": \"\",\n        \"name\": \"\",\n        \"url\": \"\"\n      }\n    ],\n    \"userData\": {\n      \"meta\": [\n        {\n          \"key\": \"\",\n          \"value\": \"\"\n        }\n      ]\n    }\n  },\n  \"reissuable\": false,\n  \"transfer\": [\n    {\n      \"address\": \"\",\n      \"amount\": \"\"\n    }\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/testnet/ntp1/issue";

    let payload = json!({
        "amount": "",
        "divisibility": "",
        "fee": "",
        "flags": json!({"splitChange": false}),
        "issueAddress": "",
        "metadata": json!({
            "description": "",
            "encryptions": (
                json!({
                    "format": "",
                    "key": "",
                    "pubkey": "",
                    "type": ""
                })
            ),
            "issuer": "",
            "rules": json!({
                "expiration": json!({
                    "locked": false,
                    "validUntil": ""
                }),
                "fees": json!({
                    "items": (
                        json!({
                            "address": "",
                            "tokenId": "",
                            "value": ""
                        })
                    ),
                    "locked": false
                }),
                "holders": (
                    json!({
                        "address": "",
                        "locked": false
                    })
                )
            }),
            "tokenName": "",
            "urls": (
                json!({
                    "dataHash": "",
                    "mimeType": "",
                    "name": "",
                    "url": ""
                })
            ),
            "userData": json!({"meta": (
                    json!({
                        "key": "",
                        "value": ""
                    })
                )})
        }),
        "reissuable": false,
        "transfer": (
            json!({
                "address": "",
                "amount": ""
            })
        )
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/testnet/ntp1/issue \
  --header 'content-type: application/json' \
  --data '{
  "amount": "",
  "divisibility": "",
  "fee": "",
  "flags": {
    "splitChange": false
  },
  "issueAddress": "",
  "metadata": {
    "description": "",
    "encryptions": [
      {
        "format": "",
        "key": "",
        "pubkey": "",
        "type": ""
      }
    ],
    "issuer": "",
    "rules": {
      "expiration": {
        "locked": false,
        "validUntil": ""
      },
      "fees": {
        "items": [
          {
            "address": "",
            "tokenId": "",
            "value": ""
          }
        ],
        "locked": false
      },
      "holders": [
        {
          "address": "",
          "locked": false
        }
      ]
    },
    "tokenName": "",
    "urls": [
      {
        "dataHash": "",
        "mimeType": "",
        "name": "",
        "url": ""
      }
    ],
    "userData": {
      "meta": [
        {
          "key": "",
          "value": ""
        }
      ]
    }
  },
  "reissuable": false,
  "transfer": [
    {
      "address": "",
      "amount": ""
    }
  ]
}'

echo '{
  "amount": "",
  "divisibility": "",
  "fee": "",
  "flags": {
    "splitChange": false
  },
  "issueAddress": "",
  "metadata": {
    "description": "",
    "encryptions": [
      {
        "format": "",
        "key": "",
        "pubkey": "",
        "type": ""
      }
    ],
    "issuer": "",
    "rules": {
      "expiration": {
        "locked": false,
        "validUntil": ""
      },
      "fees": {
        "items": [
          {
            "address": "",
            "tokenId": "",
            "value": ""
          }
        ],
        "locked": false
      },
      "holders": [
        {
          "address": "",
          "locked": false
        }
      ]
    },
    "tokenName": "",
    "urls": [
      {
        "dataHash": "",
        "mimeType": "",
        "name": "",
        "url": ""
      }
    ],
    "userData": {
      "meta": [
        {
          "key": "",
          "value": ""
        }
      ]
    }
  },
  "reissuable": false,
  "transfer": [
    {
      "address": "",
      "amount": ""
    }
  ]
}' |  \
  http POST {{baseUrl}}/testnet/ntp1/issue \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "amount": "",\n  "divisibility": "",\n  "fee": "",\n  "flags": {\n    "splitChange": false\n  },\n  "issueAddress": "",\n  "metadata": {\n    "description": "",\n    "encryptions": [\n      {\n        "format": "",\n        "key": "",\n        "pubkey": "",\n        "type": ""\n      }\n    ],\n    "issuer": "",\n    "rules": {\n      "expiration": {\n        "locked": false,\n        "validUntil": ""\n      },\n      "fees": {\n        "items": [\n          {\n            "address": "",\n            "tokenId": "",\n            "value": ""\n          }\n        ],\n        "locked": false\n      },\n      "holders": [\n        {\n          "address": "",\n          "locked": false\n        }\n      ]\n    },\n    "tokenName": "",\n    "urls": [\n      {\n        "dataHash": "",\n        "mimeType": "",\n        "name": "",\n        "url": ""\n      }\n    ],\n    "userData": {\n      "meta": [\n        {\n          "key": "",\n          "value": ""\n        }\n      ]\n    }\n  },\n  "reissuable": false,\n  "transfer": [\n    {\n      "address": "",\n      "amount": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/testnet/ntp1/issue

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "amount": "",
  "divisibility": "",
  "fee": "",
  "flags": ["splitChange": false],
  "issueAddress": "",
  "metadata": [
    "description": "",
    "encryptions": [
      [
        "format": "",
        "key": "",
        "pubkey": "",
        "type": ""
      ]
    ],
    "issuer": "",
    "rules": [
      "expiration": [
        "locked": false,
        "validUntil": ""
      ],
      "fees": [
        "items": [
          [
            "address": "",
            "tokenId": "",
            "value": ""
          ]
        ],
        "locked": false
      ],
      "holders": [
        [
          "address": "",
          "locked": false
        ]
      ]
    ],
    "tokenName": "",
    "urls": [
      [
        "dataHash": "",
        "mimeType": "",
        "name": "",
        "url": ""
      ]
    ],
    "userData": ["meta": [
        [
          "key": "",
          "value": ""
        ]
      ]]
  ],
  "reissuable": false,
  "transfer": [
    [
      "address": "",
      "amount": ""
    ]
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/testnet/ntp1/issue")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Builds a transaction that sends an NTP1 Token (POST)

{{baseUrl}}/testnet/ntp1/sendtoken

BODY json

{
  "fee": "",
  "flags": {
    "splitChange": false
  },
  "from": [],
  "metadata": {
    "description": "",
    "encryptions": [
      {
        "format": "",
        "key": "",
        "pubkey": "",
        "type": ""
      }
    ],
    "issuer": "",
    "rules": {
      "expiration": {
        "locked": false,
        "validUntil": ""
      },
      "fees": {
        "items": [
          {
            "address": "",
            "tokenId": "",
            "value": ""
          }
        ],
        "locked": false
      },
      "holders": [
        {
          "address": "",
          "locked": false
        }
      ]
    },
    "tokenName": "",
    "urls": [
      {
        "dataHash": "",
        "mimeType": "",
        "name": "",
        "url": ""
      }
    ],
    "userData": {
      "meta": [
        {
          "key": "",
          "value": ""
        }
      ]
    }
  },
  "sendutxo": [],
  "to": [
    {
      "address": "",
      "amount": "",
      "tokenId": ""
    }
  ]
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/testnet/ntp1/sendtoken");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"fee\": \"\",\n  \"flags\": {\n    \"splitChange\": false\n  },\n  \"from\": [],\n  \"metadata\": {\n    \"description\": \"\",\n    \"encryptions\": [\n      {\n        \"format\": \"\",\n        \"key\": \"\",\n        \"pubkey\": \"\",\n        \"type\": \"\"\n      }\n    ],\n    \"issuer\": \"\",\n    \"rules\": {\n      \"expiration\": {\n        \"locked\": false,\n        \"validUntil\": \"\"\n      },\n      \"fees\": {\n        \"items\": [\n          {\n            \"address\": \"\",\n            \"tokenId\": \"\",\n            \"value\": \"\"\n          }\n        ],\n        \"locked\": false\n      },\n      \"holders\": [\n        {\n          \"address\": \"\",\n          \"locked\": false\n        }\n      ]\n    },\n    \"tokenName\": \"\",\n    \"urls\": [\n      {\n        \"dataHash\": \"\",\n        \"mimeType\": \"\",\n        \"name\": \"\",\n        \"url\": \"\"\n      }\n    ],\n    \"userData\": {\n      \"meta\": [\n        {\n          \"key\": \"\",\n          \"value\": \"\"\n        }\n      ]\n    }\n  },\n  \"sendutxo\": [],\n  \"to\": [\n    {\n      \"address\": \"\",\n      \"amount\": \"\",\n      \"tokenId\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/testnet/ntp1/sendtoken" {:content-type :json
                                                                   :form-params {:fee ""
                                                                                 :flags {:splitChange false}
                                                                                 :from []
                                                                                 :metadata {:description ""
                                                                                            :encryptions [{:format ""
                                                                                                           :key ""
                                                                                                           :pubkey ""
                                                                                                           :type ""}]
                                                                                            :issuer ""
                                                                                            :rules {:expiration {:locked false
                                                                                                                 :validUntil ""}
                                                                                                    :fees {:items [{:address ""
                                                                                                                    :tokenId ""
                                                                                                                    :value ""}]
                                                                                                           :locked false}
                                                                                                    :holders [{:address ""
                                                                                                               :locked false}]}
                                                                                            :tokenName ""
                                                                                            :urls [{:dataHash ""
                                                                                                    :mimeType ""
                                                                                                    :name ""
                                                                                                    :url ""}]
                                                                                            :userData {:meta [{:key ""
                                                                                                               :value ""}]}}
                                                                                 :sendutxo []
                                                                                 :to [{:address ""
                                                                                       :amount ""
                                                                                       :tokenId ""}]}})

require "http/client"

url = "{{baseUrl}}/testnet/ntp1/sendtoken"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"fee\": \"\",\n  \"flags\": {\n    \"splitChange\": false\n  },\n  \"from\": [],\n  \"metadata\": {\n    \"description\": \"\",\n    \"encryptions\": [\n      {\n        \"format\": \"\",\n        \"key\": \"\",\n        \"pubkey\": \"\",\n        \"type\": \"\"\n      }\n    ],\n    \"issuer\": \"\",\n    \"rules\": {\n      \"expiration\": {\n        \"locked\": false,\n        \"validUntil\": \"\"\n      },\n      \"fees\": {\n        \"items\": [\n          {\n            \"address\": \"\",\n            \"tokenId\": \"\",\n            \"value\": \"\"\n          }\n        ],\n        \"locked\": false\n      },\n      \"holders\": [\n        {\n          \"address\": \"\",\n          \"locked\": false\n        }\n      ]\n    },\n    \"tokenName\": \"\",\n    \"urls\": [\n      {\n        \"dataHash\": \"\",\n        \"mimeType\": \"\",\n        \"name\": \"\",\n        \"url\": \"\"\n      }\n    ],\n    \"userData\": {\n      \"meta\": [\n        {\n          \"key\": \"\",\n          \"value\": \"\"\n        }\n      ]\n    }\n  },\n  \"sendutxo\": [],\n  \"to\": [\n    {\n      \"address\": \"\",\n      \"amount\": \"\",\n      \"tokenId\": \"\"\n    }\n  ]\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/testnet/ntp1/sendtoken"),
    Content = new StringContent("{\n  \"fee\": \"\",\n  \"flags\": {\n    \"splitChange\": false\n  },\n  \"from\": [],\n  \"metadata\": {\n    \"description\": \"\",\n    \"encryptions\": [\n      {\n        \"format\": \"\",\n        \"key\": \"\",\n        \"pubkey\": \"\",\n        \"type\": \"\"\n      }\n    ],\n    \"issuer\": \"\",\n    \"rules\": {\n      \"expiration\": {\n        \"locked\": false,\n        \"validUntil\": \"\"\n      },\n      \"fees\": {\n        \"items\": [\n          {\n            \"address\": \"\",\n            \"tokenId\": \"\",\n            \"value\": \"\"\n          }\n        ],\n        \"locked\": false\n      },\n      \"holders\": [\n        {\n          \"address\": \"\",\n          \"locked\": false\n        }\n      ]\n    },\n    \"tokenName\": \"\",\n    \"urls\": [\n      {\n        \"dataHash\": \"\",\n        \"mimeType\": \"\",\n        \"name\": \"\",\n        \"url\": \"\"\n      }\n    ],\n    \"userData\": {\n      \"meta\": [\n        {\n          \"key\": \"\",\n          \"value\": \"\"\n        }\n      ]\n    }\n  },\n  \"sendutxo\": [],\n  \"to\": [\n    {\n      \"address\": \"\",\n      \"amount\": \"\",\n      \"tokenId\": \"\"\n    }\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/testnet/ntp1/sendtoken");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"fee\": \"\",\n  \"flags\": {\n    \"splitChange\": false\n  },\n  \"from\": [],\n  \"metadata\": {\n    \"description\": \"\",\n    \"encryptions\": [\n      {\n        \"format\": \"\",\n        \"key\": \"\",\n        \"pubkey\": \"\",\n        \"type\": \"\"\n      }\n    ],\n    \"issuer\": \"\",\n    \"rules\": {\n      \"expiration\": {\n        \"locked\": false,\n        \"validUntil\": \"\"\n      },\n      \"fees\": {\n        \"items\": [\n          {\n            \"address\": \"\",\n            \"tokenId\": \"\",\n            \"value\": \"\"\n          }\n        ],\n        \"locked\": false\n      },\n      \"holders\": [\n        {\n          \"address\": \"\",\n          \"locked\": false\n        }\n      ]\n    },\n    \"tokenName\": \"\",\n    \"urls\": [\n      {\n        \"dataHash\": \"\",\n        \"mimeType\": \"\",\n        \"name\": \"\",\n        \"url\": \"\"\n      }\n    ],\n    \"userData\": {\n      \"meta\": [\n        {\n          \"key\": \"\",\n          \"value\": \"\"\n        }\n      ]\n    }\n  },\n  \"sendutxo\": [],\n  \"to\": [\n    {\n      \"address\": \"\",\n      \"amount\": \"\",\n      \"tokenId\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/testnet/ntp1/sendtoken"

	payload := strings.NewReader("{\n  \"fee\": \"\",\n  \"flags\": {\n    \"splitChange\": false\n  },\n  \"from\": [],\n  \"metadata\": {\n    \"description\": \"\",\n    \"encryptions\": [\n      {\n        \"format\": \"\",\n        \"key\": \"\",\n        \"pubkey\": \"\",\n        \"type\": \"\"\n      }\n    ],\n    \"issuer\": \"\",\n    \"rules\": {\n      \"expiration\": {\n        \"locked\": false,\n        \"validUntil\": \"\"\n      },\n      \"fees\": {\n        \"items\": [\n          {\n            \"address\": \"\",\n            \"tokenId\": \"\",\n            \"value\": \"\"\n          }\n        ],\n        \"locked\": false\n      },\n      \"holders\": [\n        {\n          \"address\": \"\",\n          \"locked\": false\n        }\n      ]\n    },\n    \"tokenName\": \"\",\n    \"urls\": [\n      {\n        \"dataHash\": \"\",\n        \"mimeType\": \"\",\n        \"name\": \"\",\n        \"url\": \"\"\n      }\n    ],\n    \"userData\": {\n      \"meta\": [\n        {\n          \"key\": \"\",\n          \"value\": \"\"\n        }\n      ]\n    }\n  },\n  \"sendutxo\": [],\n  \"to\": [\n    {\n      \"address\": \"\",\n      \"amount\": \"\",\n      \"tokenId\": \"\"\n    }\n  ]\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/testnet/ntp1/sendtoken HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 1003

{
  "fee": "",
  "flags": {
    "splitChange": false
  },
  "from": [],
  "metadata": {
    "description": "",
    "encryptions": [
      {
        "format": "",
        "key": "",
        "pubkey": "",
        "type": ""
      }
    ],
    "issuer": "",
    "rules": {
      "expiration": {
        "locked": false,
        "validUntil": ""
      },
      "fees": {
        "items": [
          {
            "address": "",
            "tokenId": "",
            "value": ""
          }
        ],
        "locked": false
      },
      "holders": [
        {
          "address": "",
          "locked": false
        }
      ]
    },
    "tokenName": "",
    "urls": [
      {
        "dataHash": "",
        "mimeType": "",
        "name": "",
        "url": ""
      }
    ],
    "userData": {
      "meta": [
        {
          "key": "",
          "value": ""
        }
      ]
    }
  },
  "sendutxo": [],
  "to": [
    {
      "address": "",
      "amount": "",
      "tokenId": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/testnet/ntp1/sendtoken")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"fee\": \"\",\n  \"flags\": {\n    \"splitChange\": false\n  },\n  \"from\": [],\n  \"metadata\": {\n    \"description\": \"\",\n    \"encryptions\": [\n      {\n        \"format\": \"\",\n        \"key\": \"\",\n        \"pubkey\": \"\",\n        \"type\": \"\"\n      }\n    ],\n    \"issuer\": \"\",\n    \"rules\": {\n      \"expiration\": {\n        \"locked\": false,\n        \"validUntil\": \"\"\n      },\n      \"fees\": {\n        \"items\": [\n          {\n            \"address\": \"\",\n            \"tokenId\": \"\",\n            \"value\": \"\"\n          }\n        ],\n        \"locked\": false\n      },\n      \"holders\": [\n        {\n          \"address\": \"\",\n          \"locked\": false\n        }\n      ]\n    },\n    \"tokenName\": \"\",\n    \"urls\": [\n      {\n        \"dataHash\": \"\",\n        \"mimeType\": \"\",\n        \"name\": \"\",\n        \"url\": \"\"\n      }\n    ],\n    \"userData\": {\n      \"meta\": [\n        {\n          \"key\": \"\",\n          \"value\": \"\"\n        }\n      ]\n    }\n  },\n  \"sendutxo\": [],\n  \"to\": [\n    {\n      \"address\": \"\",\n      \"amount\": \"\",\n      \"tokenId\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/testnet/ntp1/sendtoken"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"fee\": \"\",\n  \"flags\": {\n    \"splitChange\": false\n  },\n  \"from\": [],\n  \"metadata\": {\n    \"description\": \"\",\n    \"encryptions\": [\n      {\n        \"format\": \"\",\n        \"key\": \"\",\n        \"pubkey\": \"\",\n        \"type\": \"\"\n      }\n    ],\n    \"issuer\": \"\",\n    \"rules\": {\n      \"expiration\": {\n        \"locked\": false,\n        \"validUntil\": \"\"\n      },\n      \"fees\": {\n        \"items\": [\n          {\n            \"address\": \"\",\n            \"tokenId\": \"\",\n            \"value\": \"\"\n          }\n        ],\n        \"locked\": false\n      },\n      \"holders\": [\n        {\n          \"address\": \"\",\n          \"locked\": false\n        }\n      ]\n    },\n    \"tokenName\": \"\",\n    \"urls\": [\n      {\n        \"dataHash\": \"\",\n        \"mimeType\": \"\",\n        \"name\": \"\",\n        \"url\": \"\"\n      }\n    ],\n    \"userData\": {\n      \"meta\": [\n        {\n          \"key\": \"\",\n          \"value\": \"\"\n        }\n      ]\n    }\n  },\n  \"sendutxo\": [],\n  \"to\": [\n    {\n      \"address\": \"\",\n      \"amount\": \"\",\n      \"tokenId\": \"\"\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"fee\": \"\",\n  \"flags\": {\n    \"splitChange\": false\n  },\n  \"from\": [],\n  \"metadata\": {\n    \"description\": \"\",\n    \"encryptions\": [\n      {\n        \"format\": \"\",\n        \"key\": \"\",\n        \"pubkey\": \"\",\n        \"type\": \"\"\n      }\n    ],\n    \"issuer\": \"\",\n    \"rules\": {\n      \"expiration\": {\n        \"locked\": false,\n        \"validUntil\": \"\"\n      },\n      \"fees\": {\n        \"items\": [\n          {\n            \"address\": \"\",\n            \"tokenId\": \"\",\n            \"value\": \"\"\n          }\n        ],\n        \"locked\": false\n      },\n      \"holders\": [\n        {\n          \"address\": \"\",\n          \"locked\": false\n        }\n      ]\n    },\n    \"tokenName\": \"\",\n    \"urls\": [\n      {\n        \"dataHash\": \"\",\n        \"mimeType\": \"\",\n        \"name\": \"\",\n        \"url\": \"\"\n      }\n    ],\n    \"userData\": {\n      \"meta\": [\n        {\n          \"key\": \"\",\n          \"value\": \"\"\n        }\n      ]\n    }\n  },\n  \"sendutxo\": [],\n  \"to\": [\n    {\n      \"address\": \"\",\n      \"amount\": \"\",\n      \"tokenId\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/testnet/ntp1/sendtoken")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/testnet/ntp1/sendtoken")
  .header("content-type", "application/json")
  .body("{\n  \"fee\": \"\",\n  \"flags\": {\n    \"splitChange\": false\n  },\n  \"from\": [],\n  \"metadata\": {\n    \"description\": \"\",\n    \"encryptions\": [\n      {\n        \"format\": \"\",\n        \"key\": \"\",\n        \"pubkey\": \"\",\n        \"type\": \"\"\n      }\n    ],\n    \"issuer\": \"\",\n    \"rules\": {\n      \"expiration\": {\n        \"locked\": false,\n        \"validUntil\": \"\"\n      },\n      \"fees\": {\n        \"items\": [\n          {\n            \"address\": \"\",\n            \"tokenId\": \"\",\n            \"value\": \"\"\n          }\n        ],\n        \"locked\": false\n      },\n      \"holders\": [\n        {\n          \"address\": \"\",\n          \"locked\": false\n        }\n      ]\n    },\n    \"tokenName\": \"\",\n    \"urls\": [\n      {\n        \"dataHash\": \"\",\n        \"mimeType\": \"\",\n        \"name\": \"\",\n        \"url\": \"\"\n      }\n    ],\n    \"userData\": {\n      \"meta\": [\n        {\n          \"key\": \"\",\n          \"value\": \"\"\n        }\n      ]\n    }\n  },\n  \"sendutxo\": [],\n  \"to\": [\n    {\n      \"address\": \"\",\n      \"amount\": \"\",\n      \"tokenId\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  fee: '',
  flags: {
    splitChange: false
  },
  from: [],
  metadata: {
    description: '',
    encryptions: [
      {
        format: '',
        key: '',
        pubkey: '',
        type: ''
      }
    ],
    issuer: '',
    rules: {
      expiration: {
        locked: false,
        validUntil: ''
      },
      fees: {
        items: [
          {
            address: '',
            tokenId: '',
            value: ''
          }
        ],
        locked: false
      },
      holders: [
        {
          address: '',
          locked: false
        }
      ]
    },
    tokenName: '',
    urls: [
      {
        dataHash: '',
        mimeType: '',
        name: '',
        url: ''
      }
    ],
    userData: {
      meta: [
        {
          key: '',
          value: ''
        }
      ]
    }
  },
  sendutxo: [],
  to: [
    {
      address: '',
      amount: '',
      tokenId: ''
    }
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/testnet/ntp1/sendtoken');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/testnet/ntp1/sendtoken',
  headers: {'content-type': 'application/json'},
  data: {
    fee: '',
    flags: {splitChange: false},
    from: [],
    metadata: {
      description: '',
      encryptions: [{format: '', key: '', pubkey: '', type: ''}],
      issuer: '',
      rules: {
        expiration: {locked: false, validUntil: ''},
        fees: {items: [{address: '', tokenId: '', value: ''}], locked: false},
        holders: [{address: '', locked: false}]
      },
      tokenName: '',
      urls: [{dataHash: '', mimeType: '', name: '', url: ''}],
      userData: {meta: [{key: '', value: ''}]}
    },
    sendutxo: [],
    to: [{address: '', amount: '', tokenId: ''}]
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/testnet/ntp1/sendtoken';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"fee":"","flags":{"splitChange":false},"from":[],"metadata":{"description":"","encryptions":[{"format":"","key":"","pubkey":"","type":""}],"issuer":"","rules":{"expiration":{"locked":false,"validUntil":""},"fees":{"items":[{"address":"","tokenId":"","value":""}],"locked":false},"holders":[{"address":"","locked":false}]},"tokenName":"","urls":[{"dataHash":"","mimeType":"","name":"","url":""}],"userData":{"meta":[{"key":"","value":""}]}},"sendutxo":[],"to":[{"address":"","amount":"","tokenId":""}]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/testnet/ntp1/sendtoken',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "fee": "",\n  "flags": {\n    "splitChange": false\n  },\n  "from": [],\n  "metadata": {\n    "description": "",\n    "encryptions": [\n      {\n        "format": "",\n        "key": "",\n        "pubkey": "",\n        "type": ""\n      }\n    ],\n    "issuer": "",\n    "rules": {\n      "expiration": {\n        "locked": false,\n        "validUntil": ""\n      },\n      "fees": {\n        "items": [\n          {\n            "address": "",\n            "tokenId": "",\n            "value": ""\n          }\n        ],\n        "locked": false\n      },\n      "holders": [\n        {\n          "address": "",\n          "locked": false\n        }\n      ]\n    },\n    "tokenName": "",\n    "urls": [\n      {\n        "dataHash": "",\n        "mimeType": "",\n        "name": "",\n        "url": ""\n      }\n    ],\n    "userData": {\n      "meta": [\n        {\n          "key": "",\n          "value": ""\n        }\n      ]\n    }\n  },\n  "sendutxo": [],\n  "to": [\n    {\n      "address": "",\n      "amount": "",\n      "tokenId": ""\n    }\n  ]\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"fee\": \"\",\n  \"flags\": {\n    \"splitChange\": false\n  },\n  \"from\": [],\n  \"metadata\": {\n    \"description\": \"\",\n    \"encryptions\": [\n      {\n        \"format\": \"\",\n        \"key\": \"\",\n        \"pubkey\": \"\",\n        \"type\": \"\"\n      }\n    ],\n    \"issuer\": \"\",\n    \"rules\": {\n      \"expiration\": {\n        \"locked\": false,\n        \"validUntil\": \"\"\n      },\n      \"fees\": {\n        \"items\": [\n          {\n            \"address\": \"\",\n            \"tokenId\": \"\",\n            \"value\": \"\"\n          }\n        ],\n        \"locked\": false\n      },\n      \"holders\": [\n        {\n          \"address\": \"\",\n          \"locked\": false\n        }\n      ]\n    },\n    \"tokenName\": \"\",\n    \"urls\": [\n      {\n        \"dataHash\": \"\",\n        \"mimeType\": \"\",\n        \"name\": \"\",\n        \"url\": \"\"\n      }\n    ],\n    \"userData\": {\n      \"meta\": [\n        {\n          \"key\": \"\",\n          \"value\": \"\"\n        }\n      ]\n    }\n  },\n  \"sendutxo\": [],\n  \"to\": [\n    {\n      \"address\": \"\",\n      \"amount\": \"\",\n      \"tokenId\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/testnet/ntp1/sendtoken")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/testnet/ntp1/sendtoken',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  fee: '',
  flags: {splitChange: false},
  from: [],
  metadata: {
    description: '',
    encryptions: [{format: '', key: '', pubkey: '', type: ''}],
    issuer: '',
    rules: {
      expiration: {locked: false, validUntil: ''},
      fees: {items: [{address: '', tokenId: '', value: ''}], locked: false},
      holders: [{address: '', locked: false}]
    },
    tokenName: '',
    urls: [{dataHash: '', mimeType: '', name: '', url: ''}],
    userData: {meta: [{key: '', value: ''}]}
  },
  sendutxo: [],
  to: [{address: '', amount: '', tokenId: ''}]
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/testnet/ntp1/sendtoken',
  headers: {'content-type': 'application/json'},
  body: {
    fee: '',
    flags: {splitChange: false},
    from: [],
    metadata: {
      description: '',
      encryptions: [{format: '', key: '', pubkey: '', type: ''}],
      issuer: '',
      rules: {
        expiration: {locked: false, validUntil: ''},
        fees: {items: [{address: '', tokenId: '', value: ''}], locked: false},
        holders: [{address: '', locked: false}]
      },
      tokenName: '',
      urls: [{dataHash: '', mimeType: '', name: '', url: ''}],
      userData: {meta: [{key: '', value: ''}]}
    },
    sendutxo: [],
    to: [{address: '', amount: '', tokenId: ''}]
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/testnet/ntp1/sendtoken');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  fee: '',
  flags: {
    splitChange: false
  },
  from: [],
  metadata: {
    description: '',
    encryptions: [
      {
        format: '',
        key: '',
        pubkey: '',
        type: ''
      }
    ],
    issuer: '',
    rules: {
      expiration: {
        locked: false,
        validUntil: ''
      },
      fees: {
        items: [
          {
            address: '',
            tokenId: '',
            value: ''
          }
        ],
        locked: false
      },
      holders: [
        {
          address: '',
          locked: false
        }
      ]
    },
    tokenName: '',
    urls: [
      {
        dataHash: '',
        mimeType: '',
        name: '',
        url: ''
      }
    ],
    userData: {
      meta: [
        {
          key: '',
          value: ''
        }
      ]
    }
  },
  sendutxo: [],
  to: [
    {
      address: '',
      amount: '',
      tokenId: ''
    }
  ]
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/testnet/ntp1/sendtoken',
  headers: {'content-type': 'application/json'},
  data: {
    fee: '',
    flags: {splitChange: false},
    from: [],
    metadata: {
      description: '',
      encryptions: [{format: '', key: '', pubkey: '', type: ''}],
      issuer: '',
      rules: {
        expiration: {locked: false, validUntil: ''},
        fees: {items: [{address: '', tokenId: '', value: ''}], locked: false},
        holders: [{address: '', locked: false}]
      },
      tokenName: '',
      urls: [{dataHash: '', mimeType: '', name: '', url: ''}],
      userData: {meta: [{key: '', value: ''}]}
    },
    sendutxo: [],
    to: [{address: '', amount: '', tokenId: ''}]
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/testnet/ntp1/sendtoken';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"fee":"","flags":{"splitChange":false},"from":[],"metadata":{"description":"","encryptions":[{"format":"","key":"","pubkey":"","type":""}],"issuer":"","rules":{"expiration":{"locked":false,"validUntil":""},"fees":{"items":[{"address":"","tokenId":"","value":""}],"locked":false},"holders":[{"address":"","locked":false}]},"tokenName":"","urls":[{"dataHash":"","mimeType":"","name":"","url":""}],"userData":{"meta":[{"key":"","value":""}]}},"sendutxo":[],"to":[{"address":"","amount":"","tokenId":""}]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"fee": @"",
                              @"flags": @{ @"splitChange": @NO },
                              @"from": @[  ],
                              @"metadata": @{ @"description": @"", @"encryptions": @[ @{ @"format": @"", @"key": @"", @"pubkey": @"", @"type": @"" } ], @"issuer": @"", @"rules": @{ @"expiration": @{ @"locked": @NO, @"validUntil": @"" }, @"fees": @{ @"items": @[ @{ @"address": @"", @"tokenId": @"", @"value": @"" } ], @"locked": @NO }, @"holders": @[ @{ @"address": @"", @"locked": @NO } ] }, @"tokenName": @"", @"urls": @[ @{ @"dataHash": @"", @"mimeType": @"", @"name": @"", @"url": @"" } ], @"userData": @{ @"meta": @[ @{ @"key": @"", @"value": @"" } ] } },
                              @"sendutxo": @[  ],
                              @"to": @[ @{ @"address": @"", @"amount": @"", @"tokenId": @"" } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/testnet/ntp1/sendtoken"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/testnet/ntp1/sendtoken" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"fee\": \"\",\n  \"flags\": {\n    \"splitChange\": false\n  },\n  \"from\": [],\n  \"metadata\": {\n    \"description\": \"\",\n    \"encryptions\": [\n      {\n        \"format\": \"\",\n        \"key\": \"\",\n        \"pubkey\": \"\",\n        \"type\": \"\"\n      }\n    ],\n    \"issuer\": \"\",\n    \"rules\": {\n      \"expiration\": {\n        \"locked\": false,\n        \"validUntil\": \"\"\n      },\n      \"fees\": {\n        \"items\": [\n          {\n            \"address\": \"\",\n            \"tokenId\": \"\",\n            \"value\": \"\"\n          }\n        ],\n        \"locked\": false\n      },\n      \"holders\": [\n        {\n          \"address\": \"\",\n          \"locked\": false\n        }\n      ]\n    },\n    \"tokenName\": \"\",\n    \"urls\": [\n      {\n        \"dataHash\": \"\",\n        \"mimeType\": \"\",\n        \"name\": \"\",\n        \"url\": \"\"\n      }\n    ],\n    \"userData\": {\n      \"meta\": [\n        {\n          \"key\": \"\",\n          \"value\": \"\"\n        }\n      ]\n    }\n  },\n  \"sendutxo\": [],\n  \"to\": [\n    {\n      \"address\": \"\",\n      \"amount\": \"\",\n      \"tokenId\": \"\"\n    }\n  ]\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/testnet/ntp1/sendtoken",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'fee' => '',
    'flags' => [
        'splitChange' => null
    ],
    'from' => [
        
    ],
    'metadata' => [
        'description' => '',
        'encryptions' => [
                [
                                'format' => '',
                                'key' => '',
                                'pubkey' => '',
                                'type' => ''
                ]
        ],
        'issuer' => '',
        'rules' => [
                'expiration' => [
                                'locked' => null,
                                'validUntil' => ''
                ],
                'fees' => [
                                'items' => [
                                                                [
                                                                                                                                'address' => '',
                                                                                                                                'tokenId' => '',
                                                                                                                                'value' => ''
                                                                ]
                                ],
                                'locked' => null
                ],
                'holders' => [
                                [
                                                                'address' => '',
                                                                'locked' => null
                                ]
                ]
        ],
        'tokenName' => '',
        'urls' => [
                [
                                'dataHash' => '',
                                'mimeType' => '',
                                'name' => '',
                                'url' => ''
                ]
        ],
        'userData' => [
                'meta' => [
                                [
                                                                'key' => '',
                                                                'value' => ''
                                ]
                ]
        ]
    ],
    'sendutxo' => [
        
    ],
    'to' => [
        [
                'address' => '',
                'amount' => '',
                'tokenId' => ''
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/testnet/ntp1/sendtoken', [
  'body' => '{
  "fee": "",
  "flags": {
    "splitChange": false
  },
  "from": [],
  "metadata": {
    "description": "",
    "encryptions": [
      {
        "format": "",
        "key": "",
        "pubkey": "",
        "type": ""
      }
    ],
    "issuer": "",
    "rules": {
      "expiration": {
        "locked": false,
        "validUntil": ""
      },
      "fees": {
        "items": [
          {
            "address": "",
            "tokenId": "",
            "value": ""
          }
        ],
        "locked": false
      },
      "holders": [
        {
          "address": "",
          "locked": false
        }
      ]
    },
    "tokenName": "",
    "urls": [
      {
        "dataHash": "",
        "mimeType": "",
        "name": "",
        "url": ""
      }
    ],
    "userData": {
      "meta": [
        {
          "key": "",
          "value": ""
        }
      ]
    }
  },
  "sendutxo": [],
  "to": [
    {
      "address": "",
      "amount": "",
      "tokenId": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/testnet/ntp1/sendtoken');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'fee' => '',
  'flags' => [
    'splitChange' => null
  ],
  'from' => [
    
  ],
  'metadata' => [
    'description' => '',
    'encryptions' => [
        [
                'format' => '',
                'key' => '',
                'pubkey' => '',
                'type' => ''
        ]
    ],
    'issuer' => '',
    'rules' => [
        'expiration' => [
                'locked' => null,
                'validUntil' => ''
        ],
        'fees' => [
                'items' => [
                                [
                                                                'address' => '',
                                                                'tokenId' => '',
                                                                'value' => ''
                                ]
                ],
                'locked' => null
        ],
        'holders' => [
                [
                                'address' => '',
                                'locked' => null
                ]
        ]
    ],
    'tokenName' => '',
    'urls' => [
        [
                'dataHash' => '',
                'mimeType' => '',
                'name' => '',
                'url' => ''
        ]
    ],
    'userData' => [
        'meta' => [
                [
                                'key' => '',
                                'value' => ''
                ]
        ]
    ]
  ],
  'sendutxo' => [
    
  ],
  'to' => [
    [
        'address' => '',
        'amount' => '',
        'tokenId' => ''
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'fee' => '',
  'flags' => [
    'splitChange' => null
  ],
  'from' => [
    
  ],
  'metadata' => [
    'description' => '',
    'encryptions' => [
        [
                'format' => '',
                'key' => '',
                'pubkey' => '',
                'type' => ''
        ]
    ],
    'issuer' => '',
    'rules' => [
        'expiration' => [
                'locked' => null,
                'validUntil' => ''
        ],
        'fees' => [
                'items' => [
                                [
                                                                'address' => '',
                                                                'tokenId' => '',
                                                                'value' => ''
                                ]
                ],
                'locked' => null
        ],
        'holders' => [
                [
                                'address' => '',
                                'locked' => null
                ]
        ]
    ],
    'tokenName' => '',
    'urls' => [
        [
                'dataHash' => '',
                'mimeType' => '',
                'name' => '',
                'url' => ''
        ]
    ],
    'userData' => [
        'meta' => [
                [
                                'key' => '',
                                'value' => ''
                ]
        ]
    ]
  ],
  'sendutxo' => [
    
  ],
  'to' => [
    [
        'address' => '',
        'amount' => '',
        'tokenId' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/testnet/ntp1/sendtoken');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/testnet/ntp1/sendtoken' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "fee": "",
  "flags": {
    "splitChange": false
  },
  "from": [],
  "metadata": {
    "description": "",
    "encryptions": [
      {
        "format": "",
        "key": "",
        "pubkey": "",
        "type": ""
      }
    ],
    "issuer": "",
    "rules": {
      "expiration": {
        "locked": false,
        "validUntil": ""
      },
      "fees": {
        "items": [
          {
            "address": "",
            "tokenId": "",
            "value": ""
          }
        ],
        "locked": false
      },
      "holders": [
        {
          "address": "",
          "locked": false
        }
      ]
    },
    "tokenName": "",
    "urls": [
      {
        "dataHash": "",
        "mimeType": "",
        "name": "",
        "url": ""
      }
    ],
    "userData": {
      "meta": [
        {
          "key": "",
          "value": ""
        }
      ]
    }
  },
  "sendutxo": [],
  "to": [
    {
      "address": "",
      "amount": "",
      "tokenId": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/testnet/ntp1/sendtoken' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "fee": "",
  "flags": {
    "splitChange": false
  },
  "from": [],
  "metadata": {
    "description": "",
    "encryptions": [
      {
        "format": "",
        "key": "",
        "pubkey": "",
        "type": ""
      }
    ],
    "issuer": "",
    "rules": {
      "expiration": {
        "locked": false,
        "validUntil": ""
      },
      "fees": {
        "items": [
          {
            "address": "",
            "tokenId": "",
            "value": ""
          }
        ],
        "locked": false
      },
      "holders": [
        {
          "address": "",
          "locked": false
        }
      ]
    },
    "tokenName": "",
    "urls": [
      {
        "dataHash": "",
        "mimeType": "",
        "name": "",
        "url": ""
      }
    ],
    "userData": {
      "meta": [
        {
          "key": "",
          "value": ""
        }
      ]
    }
  },
  "sendutxo": [],
  "to": [
    {
      "address": "",
      "amount": "",
      "tokenId": ""
    }
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"fee\": \"\",\n  \"flags\": {\n    \"splitChange\": false\n  },\n  \"from\": [],\n  \"metadata\": {\n    \"description\": \"\",\n    \"encryptions\": [\n      {\n        \"format\": \"\",\n        \"key\": \"\",\n        \"pubkey\": \"\",\n        \"type\": \"\"\n      }\n    ],\n    \"issuer\": \"\",\n    \"rules\": {\n      \"expiration\": {\n        \"locked\": false,\n        \"validUntil\": \"\"\n      },\n      \"fees\": {\n        \"items\": [\n          {\n            \"address\": \"\",\n            \"tokenId\": \"\",\n            \"value\": \"\"\n          }\n        ],\n        \"locked\": false\n      },\n      \"holders\": [\n        {\n          \"address\": \"\",\n          \"locked\": false\n        }\n      ]\n    },\n    \"tokenName\": \"\",\n    \"urls\": [\n      {\n        \"dataHash\": \"\",\n        \"mimeType\": \"\",\n        \"name\": \"\",\n        \"url\": \"\"\n      }\n    ],\n    \"userData\": {\n      \"meta\": [\n        {\n          \"key\": \"\",\n          \"value\": \"\"\n        }\n      ]\n    }\n  },\n  \"sendutxo\": [],\n  \"to\": [\n    {\n      \"address\": \"\",\n      \"amount\": \"\",\n      \"tokenId\": \"\"\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/testnet/ntp1/sendtoken", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/testnet/ntp1/sendtoken"

payload = {
    "fee": "",
    "flags": { "splitChange": False },
    "from": [],
    "metadata": {
        "description": "",
        "encryptions": [
            {
                "format": "",
                "key": "",
                "pubkey": "",
                "type": ""
            }
        ],
        "issuer": "",
        "rules": {
            "expiration": {
                "locked": False,
                "validUntil": ""
            },
            "fees": {
                "items": [
                    {
                        "address": "",
                        "tokenId": "",
                        "value": ""
                    }
                ],
                "locked": False
            },
            "holders": [
                {
                    "address": "",
                    "locked": False
                }
            ]
        },
        "tokenName": "",
        "urls": [
            {
                "dataHash": "",
                "mimeType": "",
                "name": "",
                "url": ""
            }
        ],
        "userData": { "meta": [
                {
                    "key": "",
                    "value": ""
                }
            ] }
    },
    "sendutxo": [],
    "to": [
        {
            "address": "",
            "amount": "",
            "tokenId": ""
        }
    ]
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/testnet/ntp1/sendtoken"

payload <- "{\n  \"fee\": \"\",\n  \"flags\": {\n    \"splitChange\": false\n  },\n  \"from\": [],\n  \"metadata\": {\n    \"description\": \"\",\n    \"encryptions\": [\n      {\n        \"format\": \"\",\n        \"key\": \"\",\n        \"pubkey\": \"\",\n        \"type\": \"\"\n      }\n    ],\n    \"issuer\": \"\",\n    \"rules\": {\n      \"expiration\": {\n        \"locked\": false,\n        \"validUntil\": \"\"\n      },\n      \"fees\": {\n        \"items\": [\n          {\n            \"address\": \"\",\n            \"tokenId\": \"\",\n            \"value\": \"\"\n          }\n        ],\n        \"locked\": false\n      },\n      \"holders\": [\n        {\n          \"address\": \"\",\n          \"locked\": false\n        }\n      ]\n    },\n    \"tokenName\": \"\",\n    \"urls\": [\n      {\n        \"dataHash\": \"\",\n        \"mimeType\": \"\",\n        \"name\": \"\",\n        \"url\": \"\"\n      }\n    ],\n    \"userData\": {\n      \"meta\": [\n        {\n          \"key\": \"\",\n          \"value\": \"\"\n        }\n      ]\n    }\n  },\n  \"sendutxo\": [],\n  \"to\": [\n    {\n      \"address\": \"\",\n      \"amount\": \"\",\n      \"tokenId\": \"\"\n    }\n  ]\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/testnet/ntp1/sendtoken")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"fee\": \"\",\n  \"flags\": {\n    \"splitChange\": false\n  },\n  \"from\": [],\n  \"metadata\": {\n    \"description\": \"\",\n    \"encryptions\": [\n      {\n        \"format\": \"\",\n        \"key\": \"\",\n        \"pubkey\": \"\",\n        \"type\": \"\"\n      }\n    ],\n    \"issuer\": \"\",\n    \"rules\": {\n      \"expiration\": {\n        \"locked\": false,\n        \"validUntil\": \"\"\n      },\n      \"fees\": {\n        \"items\": [\n          {\n            \"address\": \"\",\n            \"tokenId\": \"\",\n            \"value\": \"\"\n          }\n        ],\n        \"locked\": false\n      },\n      \"holders\": [\n        {\n          \"address\": \"\",\n          \"locked\": false\n        }\n      ]\n    },\n    \"tokenName\": \"\",\n    \"urls\": [\n      {\n        \"dataHash\": \"\",\n        \"mimeType\": \"\",\n        \"name\": \"\",\n        \"url\": \"\"\n      }\n    ],\n    \"userData\": {\n      \"meta\": [\n        {\n          \"key\": \"\",\n          \"value\": \"\"\n        }\n      ]\n    }\n  },\n  \"sendutxo\": [],\n  \"to\": [\n    {\n      \"address\": \"\",\n      \"amount\": \"\",\n      \"tokenId\": \"\"\n    }\n  ]\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/testnet/ntp1/sendtoken') do |req|
  req.body = "{\n  \"fee\": \"\",\n  \"flags\": {\n    \"splitChange\": false\n  },\n  \"from\": [],\n  \"metadata\": {\n    \"description\": \"\",\n    \"encryptions\": [\n      {\n        \"format\": \"\",\n        \"key\": \"\",\n        \"pubkey\": \"\",\n        \"type\": \"\"\n      }\n    ],\n    \"issuer\": \"\",\n    \"rules\": {\n      \"expiration\": {\n        \"locked\": false,\n        \"validUntil\": \"\"\n      },\n      \"fees\": {\n        \"items\": [\n          {\n            \"address\": \"\",\n            \"tokenId\": \"\",\n            \"value\": \"\"\n          }\n        ],\n        \"locked\": false\n      },\n      \"holders\": [\n        {\n          \"address\": \"\",\n          \"locked\": false\n        }\n      ]\n    },\n    \"tokenName\": \"\",\n    \"urls\": [\n      {\n        \"dataHash\": \"\",\n        \"mimeType\": \"\",\n        \"name\": \"\",\n        \"url\": \"\"\n      }\n    ],\n    \"userData\": {\n      \"meta\": [\n        {\n          \"key\": \"\",\n          \"value\": \"\"\n        }\n      ]\n    }\n  },\n  \"sendutxo\": [],\n  \"to\": [\n    {\n      \"address\": \"\",\n      \"amount\": \"\",\n      \"tokenId\": \"\"\n    }\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/testnet/ntp1/sendtoken";

    let payload = json!({
        "fee": "",
        "flags": json!({"splitChange": false}),
        "from": (),
        "metadata": json!({
            "description": "",
            "encryptions": (
                json!({
                    "format": "",
                    "key": "",
                    "pubkey": "",
                    "type": ""
                })
            ),
            "issuer": "",
            "rules": json!({
                "expiration": json!({
                    "locked": false,
                    "validUntil": ""
                }),
                "fees": json!({
                    "items": (
                        json!({
                            "address": "",
                            "tokenId": "",
                            "value": ""
                        })
                    ),
                    "locked": false
                }),
                "holders": (
                    json!({
                        "address": "",
                        "locked": false
                    })
                )
            }),
            "tokenName": "",
            "urls": (
                json!({
                    "dataHash": "",
                    "mimeType": "",
                    "name": "",
                    "url": ""
                })
            ),
            "userData": json!({"meta": (
                    json!({
                        "key": "",
                        "value": ""
                    })
                )})
        }),
        "sendutxo": (),
        "to": (
            json!({
                "address": "",
                "amount": "",
                "tokenId": ""
            })
        )
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/testnet/ntp1/sendtoken \
  --header 'content-type: application/json' \
  --data '{
  "fee": "",
  "flags": {
    "splitChange": false
  },
  "from": [],
  "metadata": {
    "description": "",
    "encryptions": [
      {
        "format": "",
        "key": "",
        "pubkey": "",
        "type": ""
      }
    ],
    "issuer": "",
    "rules": {
      "expiration": {
        "locked": false,
        "validUntil": ""
      },
      "fees": {
        "items": [
          {
            "address": "",
            "tokenId": "",
            "value": ""
          }
        ],
        "locked": false
      },
      "holders": [
        {
          "address": "",
          "locked": false
        }
      ]
    },
    "tokenName": "",
    "urls": [
      {
        "dataHash": "",
        "mimeType": "",
        "name": "",
        "url": ""
      }
    ],
    "userData": {
      "meta": [
        {
          "key": "",
          "value": ""
        }
      ]
    }
  },
  "sendutxo": [],
  "to": [
    {
      "address": "",
      "amount": "",
      "tokenId": ""
    }
  ]
}'

echo '{
  "fee": "",
  "flags": {
    "splitChange": false
  },
  "from": [],
  "metadata": {
    "description": "",
    "encryptions": [
      {
        "format": "",
        "key": "",
        "pubkey": "",
        "type": ""
      }
    ],
    "issuer": "",
    "rules": {
      "expiration": {
        "locked": false,
        "validUntil": ""
      },
      "fees": {
        "items": [
          {
            "address": "",
            "tokenId": "",
            "value": ""
          }
        ],
        "locked": false
      },
      "holders": [
        {
          "address": "",
          "locked": false
        }
      ]
    },
    "tokenName": "",
    "urls": [
      {
        "dataHash": "",
        "mimeType": "",
        "name": "",
        "url": ""
      }
    ],
    "userData": {
      "meta": [
        {
          "key": "",
          "value": ""
        }
      ]
    }
  },
  "sendutxo": [],
  "to": [
    {
      "address": "",
      "amount": "",
      "tokenId": ""
    }
  ]
}' |  \
  http POST {{baseUrl}}/testnet/ntp1/sendtoken \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "fee": "",\n  "flags": {\n    "splitChange": false\n  },\n  "from": [],\n  "metadata": {\n    "description": "",\n    "encryptions": [\n      {\n        "format": "",\n        "key": "",\n        "pubkey": "",\n        "type": ""\n      }\n    ],\n    "issuer": "",\n    "rules": {\n      "expiration": {\n        "locked": false,\n        "validUntil": ""\n      },\n      "fees": {\n        "items": [\n          {\n            "address": "",\n            "tokenId": "",\n            "value": ""\n          }\n        ],\n        "locked": false\n      },\n      "holders": [\n        {\n          "address": "",\n          "locked": false\n        }\n      ]\n    },\n    "tokenName": "",\n    "urls": [\n      {\n        "dataHash": "",\n        "mimeType": "",\n        "name": "",\n        "url": ""\n      }\n    ],\n    "userData": {\n      "meta": [\n        {\n          "key": "",\n          "value": ""\n        }\n      ]\n    }\n  },\n  "sendutxo": [],\n  "to": [\n    {\n      "address": "",\n      "amount": "",\n      "tokenId": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/testnet/ntp1/sendtoken

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "fee": "",
  "flags": ["splitChange": false],
  "from": [],
  "metadata": [
    "description": "",
    "encryptions": [
      [
        "format": "",
        "key": "",
        "pubkey": "",
        "type": ""
      ]
    ],
    "issuer": "",
    "rules": [
      "expiration": [
        "locked": false,
        "validUntil": ""
      ],
      "fees": [
        "items": [
          [
            "address": "",
            "tokenId": "",
            "value": ""
          ]
        ],
        "locked": false
      ],
      "holders": [
        [
          "address": "",
          "locked": false
        ]
      ]
    ],
    "tokenName": "",
    "urls": [
      [
        "dataHash": "",
        "mimeType": "",
        "name": "",
        "url": ""
      ]
    ],
    "userData": ["meta": [
        [
          "key": "",
          "value": ""
        ]
      ]]
  ],
  "sendutxo": [],
  "to": [
    [
      "address": "",
      "amount": "",
      "tokenId": ""
    ]
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/testnet/ntp1/sendtoken")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Get Addresses Holding a Token (GET)

{{baseUrl}}/testnet/ntp1/stakeholders/:tokenid

QUERY PARAMS

tokenid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/testnet/ntp1/stakeholders/:tokenid");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/testnet/ntp1/stakeholders/:tokenid")

require "http/client"

url = "{{baseUrl}}/testnet/ntp1/stakeholders/:tokenid"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/testnet/ntp1/stakeholders/:tokenid"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/testnet/ntp1/stakeholders/:tokenid");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/testnet/ntp1/stakeholders/:tokenid"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/testnet/ntp1/stakeholders/:tokenid HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/testnet/ntp1/stakeholders/:tokenid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/testnet/ntp1/stakeholders/:tokenid"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/testnet/ntp1/stakeholders/:tokenid")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/testnet/ntp1/stakeholders/:tokenid")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/testnet/ntp1/stakeholders/:tokenid');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/testnet/ntp1/stakeholders/:tokenid'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/testnet/ntp1/stakeholders/:tokenid';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/testnet/ntp1/stakeholders/:tokenid',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/testnet/ntp1/stakeholders/:tokenid")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/testnet/ntp1/stakeholders/:tokenid',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/testnet/ntp1/stakeholders/:tokenid'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/testnet/ntp1/stakeholders/:tokenid');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/testnet/ntp1/stakeholders/:tokenid'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/testnet/ntp1/stakeholders/:tokenid';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/testnet/ntp1/stakeholders/:tokenid"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/testnet/ntp1/stakeholders/:tokenid" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/testnet/ntp1/stakeholders/:tokenid",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/testnet/ntp1/stakeholders/:tokenid');

echo $response->getBody();

setUrl('{{baseUrl}}/testnet/ntp1/stakeholders/:tokenid');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/testnet/ntp1/stakeholders/:tokenid');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/testnet/ntp1/stakeholders/:tokenid' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/testnet/ntp1/stakeholders/:tokenid' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/testnet/ntp1/stakeholders/:tokenid")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/testnet/ntp1/stakeholders/:tokenid"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/testnet/ntp1/stakeholders/:tokenid"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/testnet/ntp1/stakeholders/:tokenid")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/testnet/ntp1/stakeholders/:tokenid') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/testnet/ntp1/stakeholders/:tokenid";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/testnet/ntp1/stakeholders/:tokenid

http GET {{baseUrl}}/testnet/ntp1/stakeholders/:tokenid

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/testnet/ntp1/stakeholders/:tokenid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/testnet/ntp1/stakeholders/:tokenid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Get Metadata of Token (GET)

{{baseUrl}}/testnet/ntp1/tokenmetadata/:tokenid

QUERY PARAMS

tokenid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/testnet/ntp1/tokenmetadata/:tokenid");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/testnet/ntp1/tokenmetadata/:tokenid")

require "http/client"

url = "{{baseUrl}}/testnet/ntp1/tokenmetadata/:tokenid"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/testnet/ntp1/tokenmetadata/:tokenid"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/testnet/ntp1/tokenmetadata/:tokenid");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/testnet/ntp1/tokenmetadata/:tokenid"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/testnet/ntp1/tokenmetadata/:tokenid HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/testnet/ntp1/tokenmetadata/:tokenid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/testnet/ntp1/tokenmetadata/:tokenid"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/testnet/ntp1/tokenmetadata/:tokenid")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/testnet/ntp1/tokenmetadata/:tokenid")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/testnet/ntp1/tokenmetadata/:tokenid');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/testnet/ntp1/tokenmetadata/:tokenid'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/testnet/ntp1/tokenmetadata/:tokenid';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/testnet/ntp1/tokenmetadata/:tokenid',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/testnet/ntp1/tokenmetadata/:tokenid")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/testnet/ntp1/tokenmetadata/:tokenid',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/testnet/ntp1/tokenmetadata/:tokenid'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/testnet/ntp1/tokenmetadata/:tokenid');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/testnet/ntp1/tokenmetadata/:tokenid'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/testnet/ntp1/tokenmetadata/:tokenid';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/testnet/ntp1/tokenmetadata/:tokenid"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/testnet/ntp1/tokenmetadata/:tokenid" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/testnet/ntp1/tokenmetadata/:tokenid",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/testnet/ntp1/tokenmetadata/:tokenid');

echo $response->getBody();

setUrl('{{baseUrl}}/testnet/ntp1/tokenmetadata/:tokenid');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/testnet/ntp1/tokenmetadata/:tokenid');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/testnet/ntp1/tokenmetadata/:tokenid' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/testnet/ntp1/tokenmetadata/:tokenid' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/testnet/ntp1/tokenmetadata/:tokenid")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/testnet/ntp1/tokenmetadata/:tokenid"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/testnet/ntp1/tokenmetadata/:tokenid"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/testnet/ntp1/tokenmetadata/:tokenid")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/testnet/ntp1/tokenmetadata/:tokenid') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/testnet/ntp1/tokenmetadata/:tokenid";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/testnet/ntp1/tokenmetadata/:tokenid

http GET {{baseUrl}}/testnet/ntp1/tokenmetadata/:tokenid

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/testnet/ntp1/tokenmetadata/:tokenid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/testnet/ntp1/tokenmetadata/:tokenid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Get UTXO Metadata of Token (GET)

{{baseUrl}}/testnet/ntp1/tokenmetadata/:tokenid/:utxo

QUERY PARAMS

tokenid

utxo

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/testnet/ntp1/tokenmetadata/:tokenid/:utxo");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/testnet/ntp1/tokenmetadata/:tokenid/:utxo")

require "http/client"

url = "{{baseUrl}}/testnet/ntp1/tokenmetadata/:tokenid/:utxo"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/testnet/ntp1/tokenmetadata/:tokenid/:utxo"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/testnet/ntp1/tokenmetadata/:tokenid/:utxo");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/testnet/ntp1/tokenmetadata/:tokenid/:utxo"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/testnet/ntp1/tokenmetadata/:tokenid/:utxo HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/testnet/ntp1/tokenmetadata/:tokenid/:utxo")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/testnet/ntp1/tokenmetadata/:tokenid/:utxo"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/testnet/ntp1/tokenmetadata/:tokenid/:utxo")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/testnet/ntp1/tokenmetadata/:tokenid/:utxo")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/testnet/ntp1/tokenmetadata/:tokenid/:utxo');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/testnet/ntp1/tokenmetadata/:tokenid/:utxo'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/testnet/ntp1/tokenmetadata/:tokenid/:utxo';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/testnet/ntp1/tokenmetadata/:tokenid/:utxo',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/testnet/ntp1/tokenmetadata/:tokenid/:utxo")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/testnet/ntp1/tokenmetadata/:tokenid/:utxo',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/testnet/ntp1/tokenmetadata/:tokenid/:utxo'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/testnet/ntp1/tokenmetadata/:tokenid/:utxo');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/testnet/ntp1/tokenmetadata/:tokenid/:utxo'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/testnet/ntp1/tokenmetadata/:tokenid/:utxo';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/testnet/ntp1/tokenmetadata/:tokenid/:utxo"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/testnet/ntp1/tokenmetadata/:tokenid/:utxo" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/testnet/ntp1/tokenmetadata/:tokenid/:utxo",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/testnet/ntp1/tokenmetadata/:tokenid/:utxo');

echo $response->getBody();

setUrl('{{baseUrl}}/testnet/ntp1/tokenmetadata/:tokenid/:utxo');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/testnet/ntp1/tokenmetadata/:tokenid/:utxo');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/testnet/ntp1/tokenmetadata/:tokenid/:utxo' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/testnet/ntp1/tokenmetadata/:tokenid/:utxo' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/testnet/ntp1/tokenmetadata/:tokenid/:utxo")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/testnet/ntp1/tokenmetadata/:tokenid/:utxo"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/testnet/ntp1/tokenmetadata/:tokenid/:utxo"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/testnet/ntp1/tokenmetadata/:tokenid/:utxo")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/testnet/ntp1/tokenmetadata/:tokenid/:utxo') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/testnet/ntp1/tokenmetadata/:tokenid/:utxo";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/testnet/ntp1/tokenmetadata/:tokenid/:utxo

http GET {{baseUrl}}/testnet/ntp1/tokenmetadata/:tokenid/:utxo

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/testnet/ntp1/tokenmetadata/:tokenid/:utxo

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/testnet/ntp1/tokenmetadata/:tokenid/:utxo")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Information On a Neblio Address (GET)

{{baseUrl}}/testnet/ntp1/addressinfo/:address

QUERY PARAMS

address

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/testnet/ntp1/addressinfo/:address");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/testnet/ntp1/addressinfo/:address")

require "http/client"

url = "{{baseUrl}}/testnet/ntp1/addressinfo/:address"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/testnet/ntp1/addressinfo/:address"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/testnet/ntp1/addressinfo/:address");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/testnet/ntp1/addressinfo/:address"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/testnet/ntp1/addressinfo/:address HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/testnet/ntp1/addressinfo/:address")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/testnet/ntp1/addressinfo/:address"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/testnet/ntp1/addressinfo/:address")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/testnet/ntp1/addressinfo/:address")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/testnet/ntp1/addressinfo/:address');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/testnet/ntp1/addressinfo/:address'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/testnet/ntp1/addressinfo/:address';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/testnet/ntp1/addressinfo/:address',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/testnet/ntp1/addressinfo/:address")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/testnet/ntp1/addressinfo/:address',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/testnet/ntp1/addressinfo/:address'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/testnet/ntp1/addressinfo/:address');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/testnet/ntp1/addressinfo/:address'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/testnet/ntp1/addressinfo/:address';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/testnet/ntp1/addressinfo/:address"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/testnet/ntp1/addressinfo/:address" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/testnet/ntp1/addressinfo/:address",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/testnet/ntp1/addressinfo/:address');

echo $response->getBody();

setUrl('{{baseUrl}}/testnet/ntp1/addressinfo/:address');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/testnet/ntp1/addressinfo/:address');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/testnet/ntp1/addressinfo/:address' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/testnet/ntp1/addressinfo/:address' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/testnet/ntp1/addressinfo/:address")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/testnet/ntp1/addressinfo/:address"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/testnet/ntp1/addressinfo/:address"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/testnet/ntp1/addressinfo/:address")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/testnet/ntp1/addressinfo/:address') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/testnet/ntp1/addressinfo/:address";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/testnet/ntp1/addressinfo/:address

http GET {{baseUrl}}/testnet/ntp1/addressinfo/:address

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/testnet/ntp1/addressinfo/:address

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/testnet/ntp1/addressinfo/:address")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Information On an NTP1 Transaction (GET)

{{baseUrl}}/testnet/ntp1/transactioninfo/:txid

QUERY PARAMS

txid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/testnet/ntp1/transactioninfo/:txid");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/testnet/ntp1/transactioninfo/:txid")

require "http/client"

url = "{{baseUrl}}/testnet/ntp1/transactioninfo/:txid"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/testnet/ntp1/transactioninfo/:txid"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/testnet/ntp1/transactioninfo/:txid");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/testnet/ntp1/transactioninfo/:txid"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/testnet/ntp1/transactioninfo/:txid HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/testnet/ntp1/transactioninfo/:txid")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/testnet/ntp1/transactioninfo/:txid"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/testnet/ntp1/transactioninfo/:txid")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/testnet/ntp1/transactioninfo/:txid")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/testnet/ntp1/transactioninfo/:txid');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/testnet/ntp1/transactioninfo/:txid'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/testnet/ntp1/transactioninfo/:txid';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/testnet/ntp1/transactioninfo/:txid',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/testnet/ntp1/transactioninfo/:txid")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/testnet/ntp1/transactioninfo/:txid',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/testnet/ntp1/transactioninfo/:txid'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/testnet/ntp1/transactioninfo/:txid');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/testnet/ntp1/transactioninfo/:txid'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/testnet/ntp1/transactioninfo/:txid';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/testnet/ntp1/transactioninfo/:txid"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/testnet/ntp1/transactioninfo/:txid" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/testnet/ntp1/transactioninfo/:txid",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/testnet/ntp1/transactioninfo/:txid');

echo $response->getBody();

setUrl('{{baseUrl}}/testnet/ntp1/transactioninfo/:txid');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/testnet/ntp1/transactioninfo/:txid');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/testnet/ntp1/transactioninfo/:txid' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/testnet/ntp1/transactioninfo/:txid' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/testnet/ntp1/transactioninfo/:txid")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/testnet/ntp1/transactioninfo/:txid"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/testnet/ntp1/transactioninfo/:txid"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/testnet/ntp1/transactioninfo/:txid")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/testnet/ntp1/transactioninfo/:txid') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/testnet/ntp1/transactioninfo/:txid";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/testnet/ntp1/transactioninfo/:txid

http GET {{baseUrl}}/testnet/ntp1/transactioninfo/:txid

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/testnet/ntp1/transactioninfo/:txid

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/testnet/ntp1/transactioninfo/:txid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Returns the tokenId representing a token (GET)

{{baseUrl}}/testnet/ntp1/tokenid/:tokensymbol

QUERY PARAMS

tokensymbol

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/testnet/ntp1/tokenid/:tokensymbol");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/testnet/ntp1/tokenid/:tokensymbol")

require "http/client"

url = "{{baseUrl}}/testnet/ntp1/tokenid/:tokensymbol"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/testnet/ntp1/tokenid/:tokensymbol"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/testnet/ntp1/tokenid/:tokensymbol");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/testnet/ntp1/tokenid/:tokensymbol"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/testnet/ntp1/tokenid/:tokensymbol HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/testnet/ntp1/tokenid/:tokensymbol")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/testnet/ntp1/tokenid/:tokensymbol"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/testnet/ntp1/tokenid/:tokensymbol")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/testnet/ntp1/tokenid/:tokensymbol")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/testnet/ntp1/tokenid/:tokensymbol');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/testnet/ntp1/tokenid/:tokensymbol'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/testnet/ntp1/tokenid/:tokensymbol';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/testnet/ntp1/tokenid/:tokensymbol',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/testnet/ntp1/tokenid/:tokensymbol")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/testnet/ntp1/tokenid/:tokensymbol',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/testnet/ntp1/tokenid/:tokensymbol'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/testnet/ntp1/tokenid/:tokensymbol');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/testnet/ntp1/tokenid/:tokensymbol'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/testnet/ntp1/tokenid/:tokensymbol';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/testnet/ntp1/tokenid/:tokensymbol"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/testnet/ntp1/tokenid/:tokensymbol" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/testnet/ntp1/tokenid/:tokensymbol",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/testnet/ntp1/tokenid/:tokensymbol');

echo $response->getBody();

setUrl('{{baseUrl}}/testnet/ntp1/tokenid/:tokensymbol');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/testnet/ntp1/tokenid/:tokensymbol');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/testnet/ntp1/tokenid/:tokensymbol' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/testnet/ntp1/tokenid/:tokensymbol' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/testnet/ntp1/tokenid/:tokensymbol")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/testnet/ntp1/tokenid/:tokensymbol"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/testnet/ntp1/tokenid/:tokensymbol"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/testnet/ntp1/tokenid/:tokensymbol")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/testnet/ntp1/tokenid/:tokensymbol') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/testnet/ntp1/tokenid/:tokensymbol";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/testnet/ntp1/tokenid/:tokensymbol

http GET {{baseUrl}}/testnet/ntp1/tokenid/:tokensymbol

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/testnet/ntp1/tokenid/:tokensymbol

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/testnet/ntp1/tokenid/:tokensymbol")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()