Registering a Stake Pool
Registering a stake pool to join the Cardano network involves preparing a stake pool registration certificate, and then submitting the certificate to the blockchain.
To create a stake pool registration certificate, you need to plan and prepare the following details:
- Optional metadata that helps the Cardano community learn about your stake pool
- Optionally, the URLs where you publish the files containing metadata for your stake pool online
- The domain name or static IP address of the relay node(s) in your stake pool configuration, as well as the port number where the Cardano Node instance on each relay listens
- The amount of pledge to commit
- The fixed and variable fees that you, as the stake pool operator, earn in every epoch when the pool successfully produces a block
The most recent stake pool registration certificate that you submit to the blockchain applies. For example, to update metadata related to your stake pool, prepare and submit a revised stake pool registration certificate.
When registering a stake pool or updating a stake pool registration, some details may take up to two epochs to apply.
Creating Metadata
If you choose to create metadata for a stake pool that you operate, then you publish the metadata on the Internet—off the Cardano blockchain—in files using JSON format, as well as PNG image format. Typically, metadata includes:
- Name—The official name of the stake pool that you operate, up to 50 characters in length
- Description—A brief explanation of the purpose of the stake pool, up to 255 characters in length
- Ticker—A short, unique identifier for the stake pool, 3 to 5 characters in length and using only the characters A to Z and 0 to 9
- Home Page—The URL of the official Web site for the stake pool
- Logo—Two image files using PNG format containing a logo for the stake pool, having dimensions of 64 x 64 and 250 x 250 pixels respectively
- Additional Details—Further background on the stake pool and operator, as well as social media contact information
To create metadata for a stake pool:
- Create a logo for the stake pool, and then save the logo using PNG format in two files having the dimensions 64 x 64 pixels and 250 x 250 pixels respectively.
- Using a text editor on the block-producing node in your stake pool configuration, create a new file named
$NODE_HOME/metadata-extended.json - In the
metadata-extended.jsonfile, add the following lines where<SmallIconURL>is the URL where you plan to publish the logo image having dimensions 64 x 64 pixels on the Internet;<LargeIconURL>is the URL where you plan to publish the logo image having dimensions 250 x 250 pixels on the Internet;<City>is the name of the city or town where the stake pool operates; and,<Country>is the name of the country where the stake pool operates:{
"info": {
"url_png_icon_64x64": "<SmallIconURL>",
"url_png_logo": "<LargeIconURL>",
"location": "<City>, <Country",
"social": {
"instagram_handle": "",
"reddit_handle": "",
"twitter_handle": "",
"telegram_handle": "",
"facebook_handle": "",
"youtube_handle": "",
"twitch_handle": "",
"discord_handle": "",
"github_handle": ""
},
"company": {
"name": "",
"addr": "",
"city": "",
"country": "",
"company_id": "",
"vat_id": ""
},
"about": {
"me": "",
"server": "",
"company": ""
},
"rss": ""
},
"telegram-admin-handle": [
""
],
"my-pool-ids": {
"0": "<HexPoolID>"
}
}Note

All metadata values are optional.
<HexPoolID>is a unique stake pool ID available after registering a pool. The topic Verifying Stake Pool Registration shows you how to retrieve a stake pool ID. For now, leave the value empty. Complete available values in themetadata-extended.jsonfile as needed. In the future, third parties may implement functionality supporting new keys to include in themetadata-extended.jsonfile. - Save and close the
metadata-extended.jsonfile. - Create a new text file named
$NODE_HOME/metadata.json - In the
metadata.jsonfile, add the following lines where<PoolName>is the name of the stake pool;<PoolDescription>briefly explains the stake pool;<PoolTicker>is the short identifier for the pool;<PoolWebSite>is the URL for the pool Web site; and,<ExtendedMetadataURL>is the URL where you plan to publish themetadata-extended.jsonfile that you created in steps 2 to 4 on the Internet:{
"name": "<PoolName>",
"description": "<PoolDescription>",
"ticker": "<PoolTicker>",
"homepage": "<PoolWebSite>",
"extended": "<ExtendedMetadataURL>"
} - Save and close the
metadata.jsonfile. - Publish the
metadata.jsonandmetadata-extended.jsonfiles, as well as the two PNG image files containing the stake pool logo, on the Internet at the URLs that you specified in the metadata. For example, host the files using the official Web site for your stake pool. Hosting Files Using GitHub is another option.Note

The length of the URL for the
metadata.jsonfile must be less than 64 characters. To shorten a URL, use a free URL shortener such as ShortURL or TinyURL, for example. - To compare the unique hash of the
metadata.jsonfile that you published in step 8 with the hash of the local copy of the file, type the following commands using a terminal window where<MetadataURL>is the URL of the file that you published on the Internet:cd $NODE_HOME
cardano-cli conway stake-pool metadata-hash --pool-metadata-file metadata.json > metadata.hash
cardano-cli conway stake-pool metadata-hash --pool-metadata-file <(curl -k -s -L <MetadataURL>) > metadataOnline.hash
diff -s metadata.hash metadataOnline.hash - If the hashes that you compare in step 9 are not identical, then ensure that the
metadata.jsonfile you published is identical to the local copy of the file, and then repeat steps 8 to 9 until the hashes are identical.Note

If you are sure that the files are identical and the hashes still do not match, then try a different hosting option.
Querying the Minimum Fixed Pool Fee
The Cardano protocol establishes a minimum fee that you, as the stake pool operator, receive in each epoch when the stake pool you operate successfully produces one or more blocks. If needed, you can set the fixed fee that you receive to a higher value.
Setting the fixed fee to a value lower than the minimum causes pool registration to fail.
Note | Cardano CLI commands throughout the How to Set Up a Cardano Stake Pool guide may use the |
To determine the minimum fixed fee:
- On the block-producing node in your stake pool configuration, using a terminal window type the following commands to save protocol parameters:
cd $NODE_HOME
cardano-cli conway query protocol-parameters \
--mainnet \
--out-file params.json - To query the
params.jsonfile that you saved in step 1, type:minPoolCost=$(cat $NODE_HOME/params.json | jq -r .minPoolCost)
echo minPoolCost: ${minPoolCost}
Generating a Stake Pool Registration Certificate
The following procedure shows you how to generate a stake pool registration certificate using a domain name to register one relay node in your stake pool configuration. For details on registering multiple relay nodes using domain names, IP addresses or round-robin DNS, see the section Options for Registering Relay Nodes.
To generate a stake pool registration certificate:
- Using a terminal window on the computer designated as the block-producing node in your stake pool configuration, type the following command where
<PledgeAmount>is the amount of pledge to commit in Lovelace;<VariableFee>is a rational number between 0 and 1 representing the percent of fees that the stake pool operator earns after the fixed fee is deducted;<RelayDomainName>is the domain name for a relay node in your stake pool configuration without the HTTP(S) prefix;<RelayPort>is the port number where the relay node listens; and,<MetadataURL>is the URL where you published themetadata.jsonfile on the Internet:cardano-cli conway stake-pool registration-certificate \
--cold-verification-key-file $NODE_HOME/node.vkey \
--vrf-verification-key-file $NODE_HOME/vrf.vkey \
--pool-pledge <PledgeAmount> \
--pool-cost ${minPoolCost} \
--pool-margin <VariableFee> \
--pool-reward-account-verification-key-file $NODE_HOME/stake.vkey \
--pool-owner-stake-verification-key-file $NODE_HOME/stake.vkey \
--mainnet \
--single-host-pool-relay <RelayDomainName> \
--pool-relay-port <RelayPort> \
--metadata-url <MetadataURL> \
--metadata-hash $(cat metadataOnline.hash) \
--out-file $NODE_HOME/pool.cert
For example:
cardano-cli conway stake-pool registration-certificate \
--cold-verification-key-file $NODE_HOME/node.vkey \
--vrf-verification-key-file $NODE_HOME/vrf.vkey \
--pool-pledge 100000000 \
--pool-cost 170000000 \
--pool-margin 0.15 \
--pool-reward-account-verification-key-file $NODE_HOME/stake.vkey \
--pool-owner-stake-verification-key-file $NODE_HOME/stake.vkey \
--mainnet \
--single-host-pool-relay relaynode1.pool.example.net \
--pool-relay-port 6000 \
--metadata-url https://pool.example.net/metadata.json \
--metadata-hash afdf5aa90ad33073ed75f0a72bc72b952e774deac00e7f4cb1020bfb7c6e91ef \
--out-file $NODE_HOME/pool.cert
Options For Registering Relay Nodes
The example stake-pool registration-certificate command in the Generating a Stake Pool Registration Certificate section registers one relay node using the --single-host-pool-relay option to specify a domain name corresponding to an IPv4 A or IPv6 AAAA DNS record.
Sometimes, in Cardano CLI commands—such as when registering relay nodes—you may use multiple instances of an option and the order of options matters. The following example registers two relay nodes having the URLs relaynode1.pool.example.net:6000 and relaynode2.pool.example.net:6000 respectively:
...
--single-host-pool-relay relaynode1.pool.example.net \
--pool-relay-port 6000 \
--single-host-pool-relay relaynode2.pool.example.net \
--pool-relay-port 6000 \
...
Note | Registering the domain name for a relay node offers the advantage of allowing you to change the computer hosting the relay node, if needed, by editing the DNS record without submitting an updated stake pool registration certificate to the Cardano network. |
Alternately, use the --pool-relay-ipv4 or --pool-relay-ipv6 options to register a relay node using an IPv4 or IPv6 IP address, respectively. For example, the following options register two relay nodes having the URLs 192.0.2.1:6000 and 192.0.2.2:6000:
...
--pool-relay-ipv4 192.0.2.1 \
--pool-relay-port 6000 \
--pool-relay-ipv4 192.0.2.2 \
--pool-relay-port 6000 \
...
Using the --multi-host-pool-relay option, you can register multiple relay nodes using round-robin DNS corresponding to an SRV record. For example, the following options register the URL relaynodes.pool.example.net:6000
...
--multi-host-pool-relay relaynodes.pool.example.net \
--pool-relay-port 6000 \
...
Note | The Cardano protocol is secure and does NOT require using HTTPS for relay nodes. |
In a stake pool configuration, you must register at least one relay node. If you operate multiple relay nodes, then registering all your relay nodes publicly on the blockchain using a stake pool registration certificate may create a security risk. You can operate one or more unregistered relays by Enabling Peer Sharing.
Important | Do NOT register your block-producing node on the blockchain. |
Generating a Stake Delegation Certificate
To commit pledge to your stake pool, you need to generate a stake delegation certificate. When you commit pledge, funds are NOT locked or moved to another account. You can transfer funds that you pledge anytime. However, if the total balance in the account(s) containing your pledge is less than the amount that you set in the stake pool registration certificate using the --pool-pledge option, then your stake pool does not earn rewards and is unlikely to produce blocks.
To generate a stake delegation certificate:
- Using a terminal window on the computer designated as the block-producing node in your stake pool configuration, type:
cardano-cli conway stake-address stake-delegation-certificate \
--stake-verification-key-file $NODE_HOME/stake.vkey \
--cold-verification-key-file $NODE_HOME/node.vkey \
--out-file $NODE_HOME/deleg.cert
Using the address build command when Creating a Wallet, you can use the same stake address public verification key with different payment address public verification keys to generate many different payment addresses. The stake-address stake-delegation-certificate command generates a certificate to delegate funds in all accounts associated with the specified stake address public verification key to the stake pool having the specified cold public verification key.
Submitting a Stake Pool Registration Certificate
To submit a stake pool registration certificate to the Cardano blockchain ledger:
- On the computer designated as the block-producing node in your stake pool configuration, when the local copy of the Cardano blockchain ledger is fully synchronized type the following command using a terminal window to query the slot number of the current tip of the ledger:
currentSlot=$(cardano-cli conway query tip --mainnet | jq -r '.slot')
echo "Current Slot: ${currentSlot}" - To retrieve the amount in Lovelace of the deposit required to register a stake pool, type:
stakePoolDeposit=$(cat $NODE_HOME/params.json | jq -r '.stakePoolDeposit')
echo stakePoolDeposit: ${stakePoolDeposit} - To retrieve the UTXOs available for your payment address and calculate the balance, type:
# Retrieve the list of UTXOs available for your payment address
utxo_json=$(cardano-cli conway query utxo --output-json \
--address $(cat $NODE_HOME/payment.addr) \
--mainnet)
# Initialize variables
tx_in=""
total_balance=0
# Loop through the list of UTXOs
while read -r utxo; do
# Retrieve the values for the current UTXO
values=$(jq -r --arg k "${utxo}" '.[$k]' <<< "${utxo_json}")
# Retrieve datum associated with the UTXO
datum=$(jq -r '.datum' <<< "${values}")
# Retrieve the reference script associated with the UTXO
script=$(jq -r '.referenceScript' <<< "${values}")
# If limits on spending the UTXO may exist, then skip the UTXO
if [[ ${datum} == 'null' && ${script} == 'null' ]]
then
hash=${utxo%%#*}
idx=${utxo#*#}
utxo_balance=$(jq -r '.value.lovelace' <<< "${values}")
total_balance=$((${total_balance}+${utxo_balance}))
echo "TxHash: ${hash}#${idx}"
echo "UTXO Balance: ${utxo_balance} Lovelace"
tx_in="${tx_in} --tx-in ${hash}#${idx}"
fi
done <<< "$(jq -r 'keys[]' <<< "${utxo_json}")"
echo
echo "Total available balance: ${total_balance} Lovelace"
echo "Final --tx-in string:${tx_in}" - To build a draft transaction for calculating the transaction fee, type:
cardano-cli conway transaction build-raw \
${tx_in} \
--tx-out $(cat $NODE_HOME/payment.addr)+$(( ${total_balance} - 200000 - ${stakePoolDeposit} )) \
--invalid-hereafter $(( ${currentSlot} + 10000 )) \
--fee 200000 \
--certificate-file $NODE_HOME/pool.cert \
--certificate-file $NODE_HOME/deleg.cert \
--out-file $NODE_HOME/tx.tmp - To calculate the fee for the transaction, type:
fee=$(cardano-cli conway transaction calculate-min-fee --output-json \
--tx-body-file $NODE_HOME/tx.tmp \
--witness-count 3 \
--byron-witness-count 0 \
--protocol-params-file $NODE_HOME/params.json | jq -r '.fee')
echo "Fee: ${fee}" - To calculate change from the transaction, type:
txOut=$(( ${total_balance} - ${fee} - ${stakePoolDeposit} ))
echo Change: ${txOut}Note

If change from the transaction is less than 1₳ then funds are insufficient. Transactions having insufficient funds fail when submitted to the network.
- To build the transaction, type:
cardano-cli conway transaction build-raw \
${tx_in} \
--tx-out $(cat $NODE_HOME/payment.addr)+${txOut} \
--invalid-hereafter $(( ${currentSlot} + 10000 )) \
--fee ${fee} \
--certificate-file $NODE_HOME/pool.cert \
--certificate-file $NODE_HOME/deleg.cert \
--out-file $NODE_HOME/tx.raw - Copy the
tx.rawfile that you created in step 7 to the$NODE_HOMEfolder on your air-gapped, offline computer, and then using a terminal window type the following commands to sign the transaction:cd $NODE_HOME
cardano-cli conway transaction sign \
--tx-body-file tx.raw \
--signing-key-file payment.skey \
--signing-key-file $HOME/cold-keys/node.skey \
--signing-key-file stake.skey \
--mainnet \
--out-file tx.signed - Copy the
tx.signedfile that you created in step 8 to the$NODE_HOMEfolder on the block-producing node, and then using a terminal window type the following command to submit the transaction to the network:cardano-cli conway transaction submit \
--tx-file $NODE_HOME/tx.signed \
--mainnet
