> ## Documentation Index
> Fetch the complete documentation index at: https://docs.quantumapi.io/llms.txt
> Use this file to discover all available pages before exploring further.

# Quickstart — Run a node

> Bring up a Quantum Chain full node and a local development network in minutes.

This quickstart gets you to a running `geth` instance with the JSON-RPC API exposed locally. By the end you'll be able to query the chain, create an account, and connect a wallet.

## Step 1. Build the binary

If you haven't already, follow [Installation](/quantum-chain/installation) to produce `build/bin/geth`.

## Step 2. Connect to mainnet

```bash theme={null}
./build/bin/geth \
  --networkid 20803 \
  --datadir ~/.quantum-chain \
  --syncmode snap \
  --http \
  --http.addr 127.0.0.1 \
  --http.port 8545 \
  --http.api eth,net,web3,debug \
  --ws \
  --ws.addr 127.0.0.1 \
  --ws.port 8546 \
  --ws.api eth,net,web3
```

The first sync downloads the chain. Snap sync usually completes in a few hours on a fast machine.

Verify it works:

```bash theme={null}
curl -s -X POST http://127.0.0.1:8545 \
  -H "Content-Type: application/json" \
  --data '{"jsonrpc":"2.0","method":"eth_chainId","id":1,"params":[]}'
# → {"jsonrpc":"2.0","id":1,"result":"0x5143"}    # 0x5143 = 20803
```

## Step 3 (alternative). Run a local devnet

For development you don't need to sync mainnet. Run a single-node Clique network with pre-funded accounts.

### Create a genesis file

Save the following as `devnet.json`:

```json theme={null}
{
  "config": {
    "chainId": 20803,
    "homesteadBlock": 0,
    "eip150Block": 0,
    "eip155Block": 0,
    "eip158Block": 0,
    "byzantiumBlock": 0,
    "constantinopleBlock": 0,
    "petersburgBlock": 0,
    "istanbulBlock": 0,
    "berlinBlock": 0,
    "londonBlock": 0,
    "quantumVerificationBlock": 0,
    "clique": { "period": 5, "epoch": 30000 }
  },
  "difficulty": "1",
  "gasLimit": "30000000",
  "extraData": "0x0000000000000000000000000000000000000000000000000000000000000000<SEALER_ADDRESS_NO_0X>0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
  "alloc": {}
}
```

Replace `<SEALER_ADDRESS_NO_0X>` with a 40-character hex address of the validator you'll create in step 4.

### Initialize the data directory

```bash theme={null}
./build/bin/geth --datadir ./devnet init devnet.json
```

### Start the devnet

```bash theme={null}
./build/bin/geth \
  --datadir ./devnet \
  --networkid 20803 \
  --mine \
  --miner.etherbase 0x<SEALER_ADDRESS> \
  --unlock 0x<SEALER_ADDRESS> \
  --password ./password.txt \
  --allow-insecure-unlock \
  --http --http.api eth,net,web3,debug,personal \
  --http.corsdomain "*"
```

Blocks seal every 5 seconds. The `eth_blockNumber` JSON-RPC call should advance.

## Step 4. Create an account

Use the post-quantum `keygenerator`:

```bash theme={null}
./build/bin/keygenerator --passphrase "strong-pass"
```

The output includes:

* A 12-word **mnemonic** for recovery.
* A **post-quantum public key** (large hex blob).
* The derived **address** (20 bytes, hex).
* A **keystore file** in your working directory.

Copy the keystore file into `./devnet/keystore/` so geth can unlock it. See [Accounts and keys](/quantum-chain/accounts-and-keys) for details.

## Step 5. Send a transaction

If you funded the address in `alloc` (or it's the validator collecting block rewards), you can send a transaction.

The simplest path is to use a wallet that supports external signing. Direct `personal_sendTransaction` is supported on devnets, but for production you should use [Clef](/quantum-chain/signing-transactions) or [Qustody](/qustody/security-model).

```bash theme={null}
curl -s -X POST http://127.0.0.1:8545 \
  -H "Content-Type: application/json" \
  --data '{
    "jsonrpc":"2.0",
    "method":"eth_getBalance",
    "params":["0x<YOUR_ADDRESS>","latest"],
    "id":1
  }'
```

## Where to go next

<CardGroup cols={2}>
  <Card title="Configuration" icon="sliders" href="/quantum-chain/configuration">
    Genesis fields, geth flags, and tuning.
  </Card>

  <Card title="Accounts and keys" icon="key" href="/quantum-chain/accounts-and-keys">
    How post-quantum keypairs and addresses work.
  </Card>

  <Card title="Networks" icon="globe" href="/quantum-chain/networks">
    Mainnet, testnets, and running a validator.
  </Card>

  <Card title="Integrate with Qustody" icon="link" href="/guides/integrate-qustody-with-quantum-chain">
    Use the custody platform for institutional workflows.
  </Card>
</CardGroup>