Create an Account

Introduction

Creating accounts is a fundamental operation when building applications on Polkadot and its parachains. Accounts serve as the basis for identity, asset ownership, and transaction signing. Understanding how to generate and manage accounts programmatically enables you to build wallets, automate operations, and create seamless user experiences.

Polkadot accounts are based on the SR25519 signature scheme by default, though ED25519 and ECDSA are also supported. Each account consists of a public key (address) and a private key (seed/mnemonic). Keep your private keys secure and never share them.

This tutorial will guide you through creating accounts using different programming languages and libraries.

Prerequisites

Before starting, make sure you have:

• Basic understanding of public-key cryptography concepts
• Development environment set up for your chosen language
• Familiarity with the programming language you'll be using

Use JavaScript/TypeScript

JavaScript/TypeScript developers can use the Polkadot.js API to create and manage Polkadot accounts.

1. Create a new project directory and initialize it:

   mkdir account-creator
   cd account-creator
   npm init -y && npm pkg set type=module

2. Install the required packages:

   npm install @polkadot/util-crypto @polkadot/keyring
   npm install --save-dev typescript tsx

3. Create a file named create-account.ts and add the following code to it:

   import { cryptoWaitReady, mnemonicGenerate } from '@polkadot/util-crypto';
   import { Keyring } from '@polkadot/keyring';
   
   async function main() {
     await cryptoWaitReady();
   
     const mnemonic = mnemonicGenerate(12);
     const keyring = new Keyring({ type: 'sr25519', ss58Format: 0 });
     const pair = keyring.addFromMnemonic(mnemonic);
   
     console.log(`Address: ${pair.address}`);
     console.log(`Mnemonic: ${mnemonic}`);
   }
   
   main().catch(console.error);

   Key aspects of the code:

   • Mnemonic generation: Uses mnemonicGenerate() to create a 12-word BIP39 mnemonic phrase for human-readable key backup.
   • Keyring: The Keyring class manages accounts with a specified signature scheme and address format.
   • SS58 format: Setting ss58Format: 0 configures addresses for the Polkadot relay chain.

4. Execute the script using tsx:

   npx tsx create-account.ts

   You should see output similar to:

   npx tsx create-account.ts Address: 15oF4uVJwmo4TdGW7VfQxNLavjCXviqxT9S1MgbjMNHr6Sp5 Mnemonic: cushion dog echo people vendor curve truck begin latin romance rebuild ...

Python

Python developers can use the substrate-interface library to create and manage Polkadot accounts.

1. Create a new project directory and set up a virtual environment:

   mkdir account-creator-python
   cd account-creator-python
   python3 -m venv venv
   source venv/bin/activate  # On Windows: venv\Scripts\activate

2. Install the required package:

   pip install substrate-interface

3. Create a file named create_account.py:

   from substrateinterface import Keypair
   
   mnemonic = Keypair.generate_mnemonic()
   keypair = Keypair.create_from_mnemonic(mnemonic)
   
   print(f"Address: {keypair.ss58_address}")
   print(f"Mnemonic: {mnemonic}")

   Key aspects of the code:

   • Mnemonic generation: The generate_mnemonic() function creates a BIP39-compatible phrase.
   • Keypair creation: Keypair.create_from_mnemonic() derives keys from the mnemonic.

4. Execute the script:

   python create_account.py

   You should see output similar to:

   python create_account.py Address: 15oF4uVJwmo4TdGW7VfQxNLavjCXviqxT9S1MgbjMNHr6Sp5 Mnemonic: cushion dog echo people vendor curve truck begin latin romance rebuild ...

Rust

Rust provides low-level access to Substrate primitives for account creation through the sp-core and sp-keyring crates.

1. Create a new Rust project:

   cargo new account-creator-rust
   cd account-creator-rust

2. Add dependencies to your Cargo.toml:

   [package]
   name = "account-creator-rust"
   version = "0.1.0"
   edition = "2021"
   
   [dependencies]
   sp-core = "28.0"
   sp-runtime = "31.0"

3. Create your account generation code in src/main.rs:

   use sp_core::{crypto::Ss58Codec, Pair};
   
   fn main() {
       let (pair, phrase, _) = sp_core::sr25519::Pair::generate_with_phrase(None);
       let address = pair.public().to_ss58check();
   
       println!("Address: {}", address);
       println!("Mnemonic: {}", phrase);
   }

   Key aspects of the code:

   • Keypair generation: sr25519::Pair::generate_with_phrase() creates a new key pair with mnemonic.
   • Public key extraction: The public() method retrieves the public key from the pair.
   • SS58 encoding: Uses Polkadot's address format for the human-readable address.

4. Build and run the project:

   cargo run

   You should see output similar to:

   cargo run Address: 15oF4uVJwmo4TdGW7VfQxNLavjCXviqxT9S1MgbjMNHr6Sp5 Mnemonic: cushion dog echo people vendor curve truck begin latin romance rebuild ...

View tests

Where to Go Next

• Send Transactions with SDKs

  ---

  Learn how to send signed transactions using your newly created accounts with Polkadot-API and Polkadot.js API libraries.

  → Get Started

• Calculate Transaction Fees

  ---

  Learn how to estimate transaction fees before sending transactions from your accounts.

  → Get Started

• Query Chain Data

  ---

  Explore different methods for querying blockchain data, including account balances and other chain state.

  → Get Started