In Bitcoin proof of work, miners compete to find a specific hash value to create a new block and earn a reward (currently 6.25 BTC per block as of March 2025, though this halves roughly every four years). This hash isn’t just any random number—it’s the result of a cryptographic process using the SHA-256 algorithm applied to a block header. The goal is to find a hash that meets a specific condition: it must be less than or equal to a target value set by the Bitcoin network.
- Block Header: This is the data miners hash. It includes:
- Version (protocol version)
- Previous block’s hash (links to the last block)
- Merkle root (summary of all transactions in the block)
- Timestamp (when the block is being mined)
- Difficulty target (a number called “bits” that sets how hard it is)
- Nonce (a number miners change to guess the hash)
- Hash Output: When you run the block header through SHA-256 twice (double SHA-256), you get a 256-bit (32-byte) number, usually written as a 64-character hexadecimal string (e.g., 0000000000000000001e8d6829a8a21adc5d38d0a473b144b6765798e61f98bd1d).
- Target Condition: The hash must start with a certain number of zeros (e.g., 19 or 20 zeros as of now). The more zeros required, the smaller the target, and the harder it is to find a matching hash.
Why Is It Difficult to Guess? Why GPUs or ASICs?
The difficulty comes from the fact that SHA-256 is a one-way function:
- You can’t predict the output based on the input.
- The only way to find a hash with enough leading zeros is to try billions or trillions of different inputs by tweaking the nonce (and sometimes other fields like the timestamp or extra nonce).
Why It’s Hard:
- Randomness: Each hash attempt produces a completely random 256-bit number. There’s no pattern—just trial and error.
- Tiny Target: The target is a very small number compared to all possible hashes (2^256 possibilities). For example, if the target requires 20 leading zeros, only a tiny fraction of hashes qualify.
- Scale: As of March 2025, Bitcoin’s difficulty is around 110 trillion (110T), meaning miners must generate, on average, 110 trillion hashes to find one that works. The network adjusts this every 2,016 blocks (about two weeks) to keep block times near 10 minutes.
Why GPUs or ASICs?
- Speed: A regular CPU might do thousands of hashes per second (e.g., 12 million hashes/sec on a decent PC). GPUs can do billions, and specialized hardware like ASICs (Application-Specific Integrated Circuits) can do trillions per second.
- Competition: With millions of miners worldwide, you need massive computational power to have a chance of finding the winning hash first.
What Does the Hash Look Like? An Example
Here’s an example of a real Bitcoin block hash (Block 125,552, mined in 2011, when difficulty was lower):
- Hash: 00000000000000001e8d6829a8a21adc5d38d0a473b144b6765798e61f98bd1d
- Leading Zeros: 18 zeros (in modern blocks, it’s more like 19-20 due to higher difficulty).
- Hex Format: Each pair of characters (e.g., 1e, 8d) represents one byte.
This hash was found by tweaking the nonce until the double SHA-256 output was less than the target at that time.
Modern Example (March 2025):
- Difficulty: ~110T
- Target might require 20 zeros, so a valid hash could look like:
- 00000000000000000000bfeb3a021b25757792567762275eb72ad88b7d50d7f7
- The exact number of zeros depends on the difficulty, which adjusts dynamically.
How Do Miners “Guess” It? Do They Try 1, 2, 3, 4, 5?
Miners don’t guess randomly in a human sense—they use a systematic process:
- Start with the Block Header: They assemble the header with transactions, the previous block’s hash, etc.
- Set Nonce to 0: The nonce is a 32-bit field (0 to ~4.3 billion).
- Hash It: Run double SHA-256 on the header.
- Check the Result: If the hash has enough leading zeros (below the target), they win! If not, they increment the nonce (e.g., 0 → 1 → 2 → 3…).
- Repeat: They keep going until the nonce hits 4.3 billion. If no winner, they tweak something else (like the timestamp or extra nonce in the coinbase transaction) and start over.
Not Quite 1, 2, 3, 4, 5:
- It’s not a simple counting game in the sense of checking meaningful numbers. The nonce is just a counter to change the input slightly each time.
- Example sequence:
- Nonce = 0 → Hash = 1a3f… (not enough zeros)
- Nonce = 1 → Hash = 7b9d… (not enough zeros)
- Nonce = 13 → Hash = 00000000000000001e8d… (winner!)
Automation:
- Miners don’t do this manually—ASICs or GPUs crank through billions of nonce values per second automatically.
How Bitcoin Miners Guess a Hash to Earn 1 BTC
In Bitcoin, miners “guess” a special number (a hash) to create a new block and earn a reward (like 6.25 BTC today). Here’s how:
- They take a block header (data about transactions and the last block).
- They add a number called a nonce (starting at 0).
- They hash it using SHA-256 twice to get a 64-character result (e.g., 0000000000000000001e8d…).
- The hash must start with lots of zeros (e.g., 20 zeros) to win—set by the network’s difficulty.
- If it doesn’t work, they try nonce = 1, 2, 3, etc., billions of times until they find a winner.
Why It’s Hard:
- Hashes are random—you can’t predict them, only guess.
- Today’s difficulty (~110 trillion) means trying trillions of guesses to win.
- That’s why miners use fast machines like GPUs or ASICs, not regular computers.
Example Hash:
- 00000000000000000000bfeb… (20 zeros = very hard to find!)
How Is a Hash Unique in Bitcoin?
In Bitcoin, the hash we’re talking about is the block hash—the result of applying SHA-256 twice (double SHA-256) to a block header. Each block hash is unique because it’s tied to specific, one-time data in the block header. Here’s why it only appears once:
- Unique Block Header:
- The block header includes:
- Previous Block Hash: Links to the prior block, which is unique.
- Merkle Root: A hash summarizing all transactions in the block, which changes if even one transaction differs.
- Timestamp: The time the block is mined, which is always moving forward.
- Nonce: A number miners tweak to find a valid hash.
- Since every block builds on the previous one (via the previous block hash), and the transactions and timestamp differ, no two block headers are ever the same.
- The block header includes:
- Chain Structure:
- Bitcoin’s blockchain is a linear chain. Each block references the hash of the block before it. If two blocks had the same hash, it would break the chain’s integrity—nodes would reject duplicates.
- Miners compete globally, and only the first valid block (with a unique hash meeting the difficulty target) gets added. Any later block with the same hash or data is discarded.
- SHA-256 Properties:
- SHA-256 is a cryptographic hash function that produces a 256-bit (32-byte) output. It’s designed to be:
- Deterministic: Same input = same output.
- Collision-Resistant: It’s extremely unlikely for two different inputs to produce the same hash (a “collision”).
- With 2^256 possible outputs (~10^77), the chance of two different block headers producing the same hash by accident is astronomically small—smaller than winning the lottery a million times in a row.
- SHA-256 is a cryptographic hash function that produces a 256-bit (32-byte) output. It’s designed to be:
What’s the Rule Ensuring Uniqueness?
There’s no explicit “rule” saying “hashes must be unique”—it’s a natural outcome of how Bitcoin and SHA-256 work together:
- Bitcoin’s Consensus Rules:
- A block is only valid if its hash is below the difficulty target (e.g., starts with enough zeros).
- The block must reference the previous block’s hash, which is already fixed in the chain.
- If two miners find valid hashes for the same block height, the network picks the first one it sees. The other is orphaned (discarded).
- Time and Competition:
- Blocks are mined roughly every 10 minutes. By the time one block is found, miners move to the next, using the new block’s hash as the “previous hash.” This ensures no two blocks share the same header data.
- SHA-256’s Role:
- SHA-256 isn’t the “rule” for uniqueness—it’s the tool. It guarantees that even tiny changes in the block header (e.g., nonce +1 or a different timestamp) produce a completely different hash. This randomness, combined with unique inputs, ensures no repeats.
Could a Hash Repeat?
Theoretically, yes, but practically, no:
- Collision Chance: With 2^256 possible hashes, a natural collision (two different headers producing the same hash) is so unlikely that it’s considered impossible within the universe’s lifetime.
- Intentional Reuse: If someone tried to reuse an old block hash by copying its header, the network would reject it because:
- The “previous block hash” wouldn’t match the current chain tip.
- Transactions would be outdated (already spent or invalid).
Why Is a Bitcoin Hash Unique and Only Used Once?
In Bitcoin, every block gets a unique hash—a 64-character code from SHA-256. Here’s why it’s one-of-a-kind:
- Unique Ingredients:
- Each block hash comes from a block header with:
- The previous block’s hash (always different).
- A summary of transactions (Merkle root, unique per block).
- A timestamp (changes every second).
- A nonce (tweaked to find the hash).
- No two blocks have the same header, so no two hashes are the same.
- Each block hash comes from a block header with:
- Blockchain Rules:
- Blocks link in a chain—each one builds on the last. A duplicate hash would break the chain and get rejected.
- Miners race to find the first valid hash. Only one wins per block.
- SHA-256 Magic:
- SHA-256 turns the header into a random 256-bit hash (e.g., 0000000000000000001e8d…).
- It’s nearly impossible for two different headers to make the same hash (2^256 possibilities = more than atoms in the universe!).
Example:
- Block 1 Hash: 0000000000000000001e8d…
- Block 2 Hash: 000000000000000000bfeb…
Different every time because the data changes!