Algorand tools

Algorand Helper Tools

The open-source, command-line tools inspect the Algorand blockchain, and also compose, sign, and submit transactions to Algorand. See


go get


Algo tools require an algod node. Set up the node first, then put the connection details into file $HOME/.config/algo/algo.cfg. For example if Algorand has provided you a token to use with the "hackathon" testnet node, the file looks like this:

    address =
    token = _PASTE_TOKEN_HERE_

Using a testnet node is recommended to follow the tutorial below. When the time comes to use mainnet, your algo.cfg might look like this:

    address =


Here's a description of how to send algos from one account to another.

First, create two accounts:

algo-key generate -count=2

The algo-key generate operation saves secret key information to two files named ADDRESS.algo-key. These contain private key information, so do not share them with anyone. Don't move or rename the files, as algo-key will find them by address when signing later in the tutorial.

Next, create a (paper) backup of the private key information:

algo-key backup -nick DEMO *.algo-key

This command runs interactively, you will be prompted on the command line. When shown the secret mnemonic, write it down and store the copy securely. (Optionally, skip writing down the mnemonic for testnet accounts; however, do run algo-key backup because doing so create additional configuration files.)

The "-nick DEMO" argument gives the new accounts nicknames. This will make them easy to refer to. In this example, two configuration files "DEMO1.cfg" and "DEMO2.cfg" should be created by algo-key backup. These configuration files include newly created public addresses. The ".cfg" files are not secrets, the ".algo-key" files are secrets.

Next, move the address configuration files where algo can find them:

mv *.cfg $HOME/.config/algo/

Check the balances on these accounts. They are brand new, you will see zero algos.

algo account DEMO1 DEMO2

Note that the "-v" flag makes algo more verbose. Try:

algo -v account DEMO1

to see the entire address of the account with nicknam "DEMO1". Copy the full address. If using testnet, visit the Algorand testnet faucet. Paste the address there to receive testnet algos.

At this point, you should have a balance of algos in DEMO1 account. The remainder of this tutorial constructs a payment to send ten algos from DEMO1 to DEMO2.

Use algo payment to compose a pay transaction:

algo -as DEMO1 payment DEMO2 10

Note that "-as ADDRESS" is a flag on the algo command that specifies which account must sign the transaction. In the case of payment, it is the originating account. The next argument, payment, is the "operation" of the algo command; in this case, construct a payment transaction. The final arguments specify the beneficiary "DEMO2" and the amount, 10 algos.

The output of algo payment is a JSON-encoded transaction. The details are not important, but if you're curious, you can inspect the output and see the amount field (note that it is micro-algos), the transaction fee, and all the other details. Address are encoded differently in the JSON, so don't be surprised not to see the full address of DEMO1 or DEMO2.

Note that algo payment composed a transaction but did nothing else. To complete the payment, we must sign and submit the transaction. In Algo tools, the compose, sign, and submit steps are three distinct operations. This allows signing to be isolated to a secure environment. For convenience though, the three steps can be "pipelined" together, and that's what we'll do next:

algo -as DEMO1 payment DEMO2 10 | algo-key sign | algo submit

The above pipeline composes a transaction, exactly as before. The JSON-encoded transaction is sent to algo-key sign, which adds a signature. To do so, algo-key must find the ".algo-key" file that was created earlier. Finally the transaction with signature is sent to algo submit, which broadcasts the transaciton to our algod node, and from there to the entire network.

Lastly, check that our account balances have changed. You should see that DEMO2 now has a positive balance:

algo account DEMO1 DEMO2

Note that algo can compose other transaction types, which can be signed and submitting as described above. See algo -h for a description of all supported operations.

Command algo

Operation assetconfig

Configure an Algorand Standard Asset. See

Operation assetcreate

Creates an Algorand Standard Asset. See

Operation assettransfer

Compose an Asset Transfer Transaction, to send Algorand Standard Assets from one account to another.

The composed transaction is unsigned. See algo-key sign to sign, and algo submit to publish after signing.

Operation payment

Compose a pay transaction, to send Algos from one account to another.

Operation submit

Submit one (or more) signed transactions.

Optional arguments are files containing JSON-encoded signed transactions (output of algo-key sign).

If no arguments, algo submit expects JSON-encoded signed transaction(s) on stdin.

Operation backup

Shows a secret key, encoded as mnemonic string. The shown string can be written or copied as a (paper) backup of the secret key.

Command algo-key


algo-key [FLAGS...] OPERATION [OPFLAGS...]

Operation generate

The generate operation creates a new keypair. The public address and private mnemonic are saved to the a file. The file saved is named after the public address: "ADDRESS.algo-key".

Operation genmulti

Creates multisign addresses for Algorand.

A multisign address is produced by combining several Algorand addresses. This operation expects a list of addresses on stdin. If you have multiple address in .cfg files, as produced by algo-key backup, you can generate a multisign address with:

grep "address" *.cfg | algo-key genmulti -m 2 -n 3

(algo-key will use a regexp to parse addresses from the results of grep.)

Operation sign

Signs Algorand transaction(s).

Optional arguments are files, containing JSON-encoded transactions to sign.

If no arguments, JSON-encoded transactions are expected on stdin.

Use the "-as ADDRESS" flag to algo-key to specific a signing key. This is required when producing multi-signatures. For single signatures, algo-key attempt to learn the signing key from the transaction.

algo-key expects to find private keys in a files named "ADDRESS.algo-key", in the format produced by algo-key generate.