More

Claim a Top 200 spot from the command line

7 min readView as markdown ↗

Use btcli and provider to register a hotkey on SN25, publish your fleet manifest from it, and bind your devices to it. The Top 200 page at ur.io/app/account/top200 takes the same steps. Read the limits first: the burn isn't refundable, and a bound device leaves the pool.

Commands last checked on 2026-11-17, provider 2026.11.16-1100466640 (register, publish and bind on mainnet).

Before you start

Check that claiming is open:

Shell
curl -s https://api.bringyour.com/sn/top | python3 -c 'import json,sys; print(json.load(sys.stdin)["snapshot"]["binding_open"])'

If that prints False, stop here. You can't complete a claim yet, and the burn isn't refundable.

Nothing here asks for your recovery phrase, and no step sends a key anywhere. Your keys stay on your machines. Never paste a recovery phrase into a website, a form or a chat.

Know the limits first

  • The burn costs TAO and isn't refundable. It's paid from your coldkey. Each registration raises it by about a quarter, and it halves about every 72 minutes, down to a floor of 0.0005 TAO. Check it right before you pay: btcli subnets burn-cost 25. If it's high, wait.
  • Binding costs gas. About 263,640 gas per device, or 0.0013 TAO at 5 gwei, from your EVM wallet.
  • Register in the 3 days before the epoch your binding starts. A binding starts no earlier than the next 7-day settlement epoch, and a UID with no emission can be replaced once its immunity ends, about 3 days (21,600 blocks) after it registers. The Top 200 page shows when the next epoch starts. Leave time to publish and bind: a binding that lands after that epoch's first block has to wait for the next epoch.
  • A full subnet replaces someone. SN25 has 256 UIDs. Each registration replaces the UID that isn't immune and has the lowest emission, and among equals the oldest registration. A UID has no emission until its fleet is measured and selected, or while the validator isn't steering. Coming back means paying the burn and binding again: see If your UID is replaced.
  • A spot pays only while the validator steers, and in proportion to your score, not your rank. All selected fleets share one channel: 3% of miner emission until epoch 8, and 5% from epoch 8. A claimed fleet ranked 201 or lower earns nothing from the head tier.
  • Bind at most 7 devices, unless the others are already measured. Validators only measure providers in the verify cohort. Live members of a claimed fleet draw into it first, up to a per-fleet share, and stale members rotate out to make room (server controller/sn_fleet_binding.go, model/verify_cohort_model.go). The share is the cohort size divided by 200 seats, which is 7 devices at a 1,500 cohort. A bound device outside the cohort earns no head score and has left the pool, so it earns nothing.
  • Bound devices leave the pool. While a device's binding is active at either boundary of an epoch, it earns no pool share, whether or not the fleet is earning: its row is flagged head_excluded, and the ledger skips it (sn protocol/ledger_allocation.go, server controller/st_head_exclusion.go). A device earns in one tier at a time. Coldkeys keep what their pool accounts already accrued.
  • A commitment older than 14 days can't bind new devices. That's 100,800 blocks. To add devices later, publish again first. If you published before, you may need to publish again: commitments in the old format aren't mirrored, and provider fleet status tells you to republish one.
  • A binding lasts at most 12 epochs. Bind again before its last epoch.
  • Bind only when the Top 200 page or app shows your network as measurable and prompts you to claim.

What you need

  • A computer with btcli and a coldkey holding enough free TAO for the burn and fees. pip install bittensor gives you the current btcli.
  • A hotkey for this fleet, which is not your coldkey.
  • provider on a device of the fleet. Its client key is at ~/.urnetwork/.provider.key.
  • An EVM wallet on chain 964 with a little TAO for gas, for the last step.
  • The authority document and the storage declaration below.

In the commands, <ws_url> is a Subtensor websocket such as wss://lite.chain.opentensor.ai:443, and <rpc_url> is a chain 964 JSON-RPC such as https://lite.chain.opentensor.ai.

The authority document and durable storage

On mainnet, provider fleet register, publish, bind, status and revoke refuse to run without the reviewed fleet runtime authority document. Download it and check its hash:

Shell
curl -fsSL -o fleet-runtime-authority.json https://raw.githubusercontent.com/urfoundation/sn/main/mainnet/fleet-runtime-authority/runtime-491.json
shasum -a 256 fleet-runtime-authority.json

The second command must print 0d16e120c0b3575e1daf6c221374f12d3fc6de85f03b12693e3f1a42243b0df3. If it doesn't, stop and write to support. A new chain runtime needs a new document. The fleet authority and recovery contract says what it covers.

register, publish, bind and revoke also need a declaration of the durable storage that keeps their recovery records. Prepare it with provider alone, on the one Linux or macOS machine that will run them: provider fleet storage request, then plan and apply, as Preparing storage for mainnet writes describes. apply prints declaration.path and declaration.sha256: they're the values of --durable-volumes and --durable-volumes-sha256, and the hash already starts with sha256:. Use the same URNETWORK_STATE_DIR (~/.urnetwork unless you set it) for these steps and every later fleet write, and never restore that directory from a backup.

Keep both in your shell for the commands below. These arrays work in bash and zsh:

Shell
AUTHORITY=(--mainnet-runtime-authority="$PWD/fleet-runtime-authority.json" --mainnet-runtime-authority-sha256=0d16e120c0b3575e1daf6c221374f12d3fc6de85f03b12693e3f1a42243b0df3)
DURABLE=(--durable-volumes=<declaration_path> --durable-volumes-sha256=<declaration_sha256>)

1. Register a hotkey on the subnet

Make the hotkey if you don't have one:

Shell
btcli wallet new-hotkey

Check the cost, then register. btcli asks for the wallet and hotkey, and shows the burn before it spends anything.

Shell
btcli subnets burn-cost 25
btcli subnets register --netuid 25

btcli versions name their wallet flags differently, so the command names none.

provider fleet register is the other way to register, and it's a dry run unless given --apply. It needs a raw seed file for your coldkey, so use btcli.

2. Write the fleet manifest

On a provider device, with the coordinator and netuid from GET /sn/head (the Top 200 page fills them in), your hotkey's address and this device's client id:

Shell
provider fleet init --chain_id=964 --coordinator=<0xcoordinator> --netuid=25 --hotkey=<hotkey ss58> --client_seed_file=$HOME/.urnetwork/.provider.key --client_id=<client_id> | head -n 1 > fleet-manifest.json

Add each other device with --member=<client_id>:<client_key>. To print a manifest and its commitment again:

Shell
provider fleet manifest --manifest=fleet-manifest.json

3. Publish the manifest from the hotkey

Shell
provider fleet publish --manifest=fleet-manifest.json --substrate=<ws_url> --hotkey_seed_file=<path> "${AUTHORITY[@]}" "${DURABLE[@]}"

--hotkey_seed_file is the hotkey's raw 32-byte seed, in a file only you can read, and it stays on this machine. btcli keeps the hotkey as JSON, so write the raw seed from it once, without printing it:

Shell
python3 -c 'import json,os,sys; d=json.load(open(sys.argv[1])); fd=os.open(sys.argv[2], os.O_WRONLY|os.O_CREAT|os.O_EXCL, 0o600); os.write(fd, bytes.fromhex(d["secretSeed"][2:])); os.close(fd)' "$HOME/.bittensor/wallets/<wallet>/hotkeys/<hotkey>" hotkey.seed

This reads your hotkey's file, never your coldkey's, and sends nothing anywhere. Use the path hotkey.seed as --hotkey_seed_file.

The commitment oracle then mirrors your commitment to chain 964 by itself, once it's final. Bindings revert with StaleCommitment() until it has.

4. Sign each device's binding

On each device, or where the hotkey seed is kept, with the validity window in epochs. The first epoch must be later than the current one, and a binding spans at most 12:

Shell
provider fleet sign --manifest=fleet-manifest.json --client_id=<client_id> --client_seed_file=$HOME/.urnetwork/.provider.key --hotkey_seed_file=<path> --valid_from_epoch=<first epoch> --valid_to_epoch=<last epoch>

It prints the binding digest, the hotkey's signature, and the payload to paste on the Top 200 page. On a phone, use the app instead: Earnings › Top 200 › Sign fleet binding.

5. The hotkey signature

The payload from step 4 already carries it when you pass --hotkey_seed_file. If the hotkey seed is on another machine, run provider fleet sign there with the device's --client_id and --hotkey_seed_file, and paste the 0x signature it prints on the Top 200 page.

btcli can't make this signature. The hotkey signs the 32 bytes of the binding digest. btcli wallet sign --use-hotkey --message signs the text you give it, so a digest typed as hex is different bytes, and the signature won't verify.

6. Submit

Paste each payload on the Top 200 page, at ur.io/app/account/top200. It answers with the calldata for that device. Send that from your own EVM wallet on chain 964. URnetwork never sends the transaction for you.

provider fleet bind signs and submits in one step instead. It takes --relayer_key_file, an EVM key that pays the gas, and --dry-run. Try the dry run first.

Shell
provider fleet bind --manifest=fleet-manifest.json --client_id=<client_id> --client_seed_file=$HOME/.urnetwork/.provider.key --hotkey_seed_file=<path> --valid_from_epoch=<first epoch> --valid_to_epoch=<last epoch> --rpc=<rpc_url> --relayer_key_file=<path> --dry-run "${AUTHORITY[@]}" "${DURABLE[@]}"

Check and undo

Shell
provider fleet status --manifest=fleet-manifest.json --client_id=<client_id> --substrate=<ws_url> --rpc=<rpc_url> "${AUTHORITY[@]}"
provider fleet revoke --manifest=fleet-manifest.json --client_id=<client_id> --client_seed_file=$HOME/.urnetwork/.provider.key --effective_epoch=<epoch> --rpc=<rpc_url> --relayer_key_file=<path> --dry-run "${AUTHORITY[@]}" "${DURABLE[@]}"

If your UID is replaced

Your devices' bindings stop counting once the hotkey has no UID, and the devices go back to earning in their operator's pool from the next epoch boundary. To claim again:

  1. Register the hotkey again (step 1). That's a new burn and a new UID.
  2. Revoke each device's old binding from the next epoch, with provider fleet revoke.
  3. Write a new manifest with a higher --generation (step 2), publish it (step 3), and sign and submit each device's binding from that epoch (steps 4 to 6).