1Q1EiThBuoo…yQw1Sdid8 — P2PKH (Pay to Public Key Hash) — Bitcoin address inspector
Paste any Bitcoin address: this page validates it, names its exact type, rebuilds the script it stands for, works out which other addresses share its key — and then reads its balance and transaction history from public explorers.
Result
Validation
Everything in this section is computed from the string itself, with no network access.
Structure
What the string literally contains, byte by byte.
SHA256(SHA256(payload)).Sibling addresses — the same key, other scripts
P2PKH and P2WPKH both commit to hash160(pubkey), so each determines the other — and both determine the P2SH-P2WPKH form. These six addresses are all controlled by the same private key.
On-chain data — fetched by this server from public explorers
This part is a third-party claim, not a computed fact. The explorer that answered is named in every row below.
https://mempool.space/api · queried 2026-10-09 23:37:39 UTCLive balance — queried by your browser, right now
This block is filled in by JavaScript running in your browser, contacting public explorers directly. Nothing here comes from this server, which is why it can succeed even when the server has no internet — and why the balance may differ from the one above if a block arrived in between.
What this page does — and where each answer comes from
There are two fundamentally different kinds of question you can ask about an address, and this page keeps them apart on purpose:
| Question | Answered by | Needs the internet? |
|---|---|---|
| Is this string a valid address? | Pure arithmetic on this server | No |
| Which address type is it, and what script does it stand for? | Pure arithmetic on this server | No |
| What other addresses share its key? | Pure arithmetic on this server | No |
| What is its balance and transaction history? | A public block explorer | Yes |
The first three are facts derived from the string itself and can never be wrong. The fourth is a claim by a third party, and the page says which explorer made it. If there is no network, the first three still work perfectly and the fourth says so.
1. What a Bitcoin address actually is
An address is not a key, not an account, and not a wallet. It is a short, checksummed encoding of a spending condition — technically, a commitment to a script that a future transaction must satisfy. The blockchain never stores addresses at all: it stores outputs locked by a script, and an address is simply a human-friendly way to write down certain scripts.
That distinction explains most of what confuses people:
- Nobody "owns" an address. Whoever can satisfy the script can spend the output.
- An address can receive money without anyone holding its key — for example a burn address.
- A wallet does not "hold" addresses; it holds keys and can regenerate addresses from them.
2. The two encoding families
Bitcoin has exactly two ways of writing an address down, and telling them apart is the first thing this page does:
| Base58Check | Bech32 / Bech32m | |
|---|---|---|
| Looks like | 1…, 3… | bc1q…, bc1p… |
| Alphabet | 58 characters — 0, O, I and l removed | 32 characters qpzry9x8gf2tvdw0s3jn54khce6mua7l |
| Version byte | One byte prefix (0x00, 0x05, …) | Human-readable part (bc) plus a 5-bit witness version |
| Checksum | 4 bytes of SHA256(SHA256(payload)) | A 6-character BCH code over the whole string |
| Detects | Any single-character error with overwhelming probability | Any 4 errors; published guarantees for longer runs |
| Case | Case-sensitive | All-lower or all-upper; mixed case is invalid by design |
| Introduced | Original client, 2009 | BIP173, 2017 (SegWit) |
The Base58 alphabet excludes 0, O, I and l precisely
because they are the characters humans confuse when copying from paper. Bech32 goes further: banning mixed
case turns a whole class of transcription error into a hard failure.
3. The address types, and what each one commits to
This is the part that makes some addresses convertible into others and some not. Every address commits to a single 20-byte or 32-byte value, but what that value is depends on the type:
| Type | Prefix | Commits to | scriptPubKey | Size |
|---|---|---|---|---|
| P2PKH | 1… | hash160(pubkey) | OP_DUP OP_HASH160 <20B> OP_EQUALVERIFY OP_CHECKSIG | 25 B |
| P2SH | 3… | hash160(redeemScript) | OP_HASH160 <20B> OP_EQUAL | 23 B |
| P2WPKH | bc1q… (20 B) | hash160(pubkey) | OP_0 <20B> | 22 B |
| P2WSH | bc1q… (32 B) | SHA256(witnessScript) | OP_0 <32B> | 34 B |
| P2TR | bc1p… | x coordinate of the tweaked output key | OP_1 <32B> | 34 B |
A 3… address tells you the hash of a script and nothing else — it might be nested SegWit,
a multisig, or a timelock. A bc1q… address with a 32-byte program tells you a script's hash.
A bc1p… address tells you a point. None of those can be turned into "the other addresses for
the same key", because the key's hash is not in them. Only P2PKH and P2WPKH carry
hash160(pubkey) and can therefore be converted into each other.
4. Sibling addresses: one key, several addresses
Because P2PKH, P2WPKH and P2SH-P2WPKH all commit to the same 20 bytes — the hash of the compressed public key — any one of them determines the other two. This is not a security weakness; it is simply the same commitment written in different scripts.
It matters enormously in practice. The classic disaster is a key whose coins sit at the P2PKH address while the wallet in use only ever looks at the P2WPKH address (or the reverse, or testnet vs mainnet). The wallet reports a zero balance and the owner concludes the funds are gone. The coins are usually still there, and looking at the sibling addresses is how you find them.
| Address | Type | Same key? |
|---|---|---|
1BgGZ9tcN4rm9KBzDn7KprQz87SZ26SAMH | P2PKH mainnet | Yes |
3JvL6Ymt8MVWiCNHC7oWU6nLeHNJKLZGLN | P2SH-P2WPKH mainnet | Yes |
bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kv8f3t4 | P2WPKH mainnet | Yes |
mrCDrCybB6J1vRfbwM5hemdJz73FwDBC8r | P2PKH testnet | Yes |
2NAUYAHhujozruyzpsFRP63mbrdaU5wnEpN | P2SH-P2WPKH testnet | Yes |
tb1qw508d6qejxtdg4y5r3zarvary0c5xw7kxpjzsx | P2WPKH testnet | Yes |
All six rows above are the same private key. Two of them are on testnet, which is a different network entirely — coins cannot be moved between them, but the same key controls both.
Deriving siblings tells you which addresses that key would produce. It does not prove that a particular sibling address was ever used, and it does not tell you who controls the key. Watch how the balances differ across the family — an empty mainnet address next to a funded testnet one is completely normal.
5. What validation does — and does not — mean
This page verifies the checksum, the character set, the length, the version byte or witness version, the program length, the case rule and the padding rule. Passing all of that means one thing only: the string is a well-formed address that no Bitcoin node would reject as malformed.
It does not mean:
- that anyone can spend it — a burn address validates perfectly;
- that it is yours, or that it has ever been used;
- that it is the address you meant. A checksum catches typos with high probability, but it is a detector, not a corrector. If a typo happens to produce another valid checksum, the result is a different, perfectly valid address — and money sent there is gone. Base58Check's 4 bytes give a roughly 1-in-4-billion chance per random corruption; bech32's code has stronger published bounds and additionally rejects the mixed-case mistakes that Base58 can only mis-encode.
6. Reading a balance correctly
There is no "balance" field in Bitcoin. What exists is a set of unspent outputs, each locked to a script. An address's balance is computed by summing the unspent outputs that pay it:
Three consequences follow, and the page shows the ingredients separately so you can check them:
- Total received can be far larger than the current balance. An address that has been swept a hundred times shows a large received figure and a zero balance — that is normal, not a bug.
- Unconfirmed outputs live in the mempool, not in a block. They count toward a balance the moment they are seen, but they can still disappear if the transaction is replaced or dropped.
- Confirmations equal
tip height − block height + 1. Fewer than a handful means a reorganisation could still un-include the transaction. Six is the traditional informal threshold, not a rule.
7. Reading the transaction list
The history this page shows is written from the address's point of view. For each transaction it computes how much the address received, how much it spent, and the net effect:
| Direction | Meaning |
|---|---|
| in | Outputs pay this address; no input spends from it. |
| out | Inputs spend from this address; nothing comes back to it. |
| self / net | Both sides involve this address — a consolidation, a change output, or a self-transfer. |
Other columns deserve a note:
- Fee is paid by whoever's inputs the transaction consumes, so it is only really "yours" on outgoing transactions. It is shown for every row because it is a property of the transaction.
- vBytes is
weight ÷ 4, the unit fees are actually priced in. Witness data is discounted fourfold, which is exactly why SegWit and Taproot inputs are cheaper. - Counterparties are the other addresses in the transaction — recipients when you sent,
senders when you received. A row with none usually means the outputs were data carriers
(
OP_RETURN), which hold no coins and have no address. - Revealed public key. The moment an address spends, its public key is published on chain. Until then, a P2PKH or P2WPKH address is protected by the hash alone. This page reports whether the address has ever spent, because that single fact changes its quantum-resistance profile.
Esplora-compatible explorers return at most the 50 most recent transactions per address in one call. This page asks for fewer than that and states the total transaction count separately, so a busy address shows something like "25 of 172 transactions". Paging through years of history is what a full explorer website is for; the links at the bottom of this page go there.
8. Privacy: who learns that you looked
Validation happens entirely on this server. On-chain lookups do not, and there are two separate paths:
Server-side lookups (the summary and the table)
This server makes the request. Your browser's IP is never exposed to the explorer — but this server, and the explorer, both learn which address you were interested in.
Browser-side lookups (the live balance block)
The JavaScript below runs in your browser and contacts the explorer directly, so your IP is visible to that explorer, but this server never sees the query. Turning the on-chain option off disables the first path entirely.
Either way, an address query is a privacy leak: asking about an address links you to it. Reusing one address for every payment publishes your whole financial history to anyone who looks, and asking a public API about your own addresses tells that API's operator what you hold. If that matters to you, run your own node and query it locally.
9. Special and unspendable addresses
Some addresses are famous enough to be worth recognising, and this page labels them:
| Address | What it is |
|---|---|
1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa | The genesis coinbase output — the first 50 BTC, never spent. |
1BitcoinEaterAddressDontSendf59kuE | A deliberate burn address whose key nobody has. |
1111111111111111111114oLvT2 | The all-zero hash160. Unspendable in practice: spending it needs a public key hashing to twenty zero bytes. |
Burning coins is a real technique — it is how some protocols make a commitment that can never be redeemed. It is also, obviously, irreversible.
10. Quick reference
| Item | Value |
|---|---|
| Mainnet P2PKH / P2SH prefixes | 0x00 → 1… / 0x05 → 3… |
| Testnet P2PKH / P2SH prefixes | 0x6F → m…/n… / 0xC4 → 2… |
| bech32 hrps | bc mainnet, tb testnet, bcrt regtest |
| Witness program sizes | 2–40 bytes; v0 must be exactly 20 (P2WPKH) or 32 (P2WSH) |
| Checksum constant | 1 for v0 (bech32), 0x2bc830a3 for v1+ (bech32m) |
| Address length limit | 90 characters for bech32, ~34–35 for Base58 mainnet |
| Sibling-derivable types | P2PKH and P2WPKH only (they carry hash160(pubkey)) |
| Explorer transaction limit | 50 most recent per address, per request |