Before we get started with working with Kuknos in code, consider going through the following
examples using the Kuknos Laboratory. The lab allows you create accounts, fund accounts on the Kuknos test network, build transactions, run any operation, and inspect responses from Horizon via the Endpoint Explorer.

The first thing you’ll need to do anything on the Kuknos network is an account. Accounts hold all
your money inside Kuknos and allow you to send and receive payments—in fact, pretty much
everything in Kuknos is in some way tied to an account.

Every Kuknos account has a public key and a secret seed. Kuknos uses public key
cryptography to ensure that every transaction is secure. The public key is always safe to
share—other people need it to identify your account and verify that you authorized a transaction.
The seed, however, is private information that proves you own your account. You should never share
the seed with anyone. It’s kind of like the combination to a lock—anyone who knows the combination
can open the lock. In the same way, anyone who knows your account’s seed can control your account.

If you’re familiar with public key cryptography, you might be wondering how the seed differs from a
private key. The seed is actually the single secret piece of data that is used to generate both the
public and private key for your account. Kuknos’s tools use the seed instead of the private key
for convenience: To have full access to an account, you only need to provide a seed instead of both
a public key and a private key.

Because the seed must be kept secret, the first step in creating an account is creating your own
seed and key—when you finally create the account, you’ll send only the public key to a Kuknos
server. You can generate the seed and key with the following command:

// create a completely new and unique pair of keys
// see more about KeyPair objects:
const pair = StellarSdk.Keypair.random();

import org.stellar.sdk.KeyPair;
KeyPair pair = KeyPair.random();

System.out.println(new String(pair.getSecretSeed()));
package main

import (


func main() {
    pair, err := keypair.Random()
    if err != nil {

# stellar-sdk >= 2.0.0 required
# create a completely new and unique pair of keys
from stellar_sdk.keypair import Keypair

pair = Keypair.random()
print(f"Secret: {pair.secret}")
print(f"Public Key: {pair.public_key}")

Now that you have a seed and public key, you can create an account. In order to prevent people from
making a huge number of unnecessary accounts, each account must have a minimum balance of 1 paymon
(paymons are the built-in currency of the Kuknos network). Since you don’t yet have any paymons,
though, you can’t pay for an account. In the real world, you’ll usually pay an exchange that sells
paymons in order to create a new account. On Kuknos’s test network, however, you can ask
Friendbot, our friendly robot with a very fat wallet, to create an account for you.

To create a test account, send Friendbot the public key you created. It’ll create and fund a new
account using that public key as the account ID.

(async function main() {
  try {
    const response = await fetch(
    const responseJSON = await response.json();
    console.log("SUCCESS! You have a new account :)\n", responseJSON);
  } catch (e) {
    console.error("ERROR!", e);
import java.util.*;

String friendbotUrl = String.format(
InputStream response = new URL(friendbotUrl).openStream();
String body = new Scanner(response, "UTF-8").useDelimiter("\\A").next();
System.out.println("SUCCESS! You have a new account :)\n" + body);
package main

import (

func main() {
    // pair is the pair that was generated from previous example, or create a pair based on
    // existing keys.
    address := pair.Address()
    resp, err := http.Get("" + address)
    if err != nil {

    defer resp.Body.Close()
    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
# The SDK does not have tools for creating test accounts, so you'll have to
# make your own HTTP request.

# if you're trying this on Python, install the `requests` library.
import requests

response = requests.get(f"{public_key}")
if response.status_code == 200:
    print(f"SUCCESS! You have a new account :)\n{response.text}")
    print(f"ERROR! Response: \n{response.text}")

Now for the last step: Getting the account’s details and checking its balance. Accounts can carry
multiple balances—one for each type of currency they hold.

const server = new StellarSdk.Server("");

// the JS SDK uses promises for most actions, such as retrieving an account
const account = await server.loadAccount(pair.publicKey());
console.log("Balances for account: " + pair.publicKey());
account.balances.forEach(function(balance) {
  console.log("Type:", balance.asset_type, ", Balance:", balance.balance);
import org.stellar.sdk.Server;
import org.stellar.sdk.responses.AccountResponse;

Server server = new Server("");
AccountResponse account = server.accounts().account(pair);
System.out.println("Balances for account " + pair.getAccountId());
for (AccountResponse.Balance balance : account.getBalances()) {
    "Type: %s, Code: %s, Balance: %s",
package main

import (


func main() {
    account, err := horizon.DefaultTestNetClient.LoadAccount(pair.Address())
    if err != nil {

    fmt.Println("Balances for account:", pair.Address())

    for _, balance := range account.Balances {
from stellar_sdk.server import Server

server = Server("")
account = server.accounts().account_id(public_key).call()
for balance in account['balances']:
    print(f"Type: {balance['asset_type']}, Balance: {balance['balance']}")

Now that you’ve got an account, you can start sending and receiving payments.

[1]: A private key is still used to encrypt data and sign transactions. When you create a KeyPair object using a seed, the private key is immediately generated and stored internally.
[2]: Other features of Kuknos, like trust lines, require higher minimum balances.