Private Key Tools

1Exgegt9z4M…JXfmndQtu — 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.

Privacy notice. Address validation is done entirely on this server and sends nothing anywhere. On-chain lookups do not: the summary and transaction table below are fetched by this server from public block explorers, which means both this server and that explorer learn which address you asked about. Set the on-chain option to “No” to keep the query completely local.
Any standard form works: 1…, 3…, bc1q…, bc1p…, plus the testnet m…/n…/2…/tb1… variants. Case does not matter for Base58, and bech32 addresses may be all-lower or all-upper — but not mixed.
Turns the server-side explorer lookups on or off. Validation, type detection and sibling derivation always work either way.
1–50.

Result

computed server-side on this host

Validation

Everything in this section is computed from the string itself, with no network access.

✓Verdict
VALID — a well-formed P2PKH (Pay to Public Key Hash)
Encoding family
Base58Check
Character length
34 characters
Chain
Bitcoin
Network
Mainnet
P2PKHAddress type
P2PKH (Pay to Public Key Hash)

Structure

What the string literally contains, byte by byte.

Checksum characters
dQtu
The last 4 Base58 characters. They encode the first 4 bytes of SHA256(SHA256(payload)).
Version byte
0x00 (0)
One byte that selects both the chain and the script type. It is covered by the checksum, so changing it invalidates the whole address.
Payload (version + hash)
0099219c6e98240b224797ebf5fe798e1df11387f1
hash160 / commitment
99219c6e98240b224797ebf5fe798e1df11387f1
What these 20 bytes are depends on the type: hash160(pubkey).
scriptPubKey
76a91499219c6e98240b224797ebf5fe798e1df11387f188ac
The actual output script this address stands for — 25 bytes. This, not the address, is what the blockchain stores.
Readable script
OP_DUP OP_HASH160 <99219c6e98240b224797ebf5fe798e1df11387f1> OP_EQUALVERIFY OP_CHECKSIG

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.

MP2PKH · mainnet · this address
MP2SH-P2WPKH · mainnet
TP2SH-P2WPKH · testnet

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.

Ever used?
NO — no transactions seen by this explorer
₿Confirmed balance
0.00000000 BTC
Sum of unspent outputs in blocks. Bitcoin has no balance field — this is computed.
Unconfirmed balance
0.00000000 BTC
Net effect of transactions still in the mempool. It can vanish if a transaction is replaced or evicted.
Total received
0.00000000 BTC
Total spent
0.00000000 BTC
Transactions
0 confirmed, 0 pending
Unspent outputs (UTXOs)
0
How many separate coins this address holds. Every one of them becomes an input the next time the address spends, which is why a fragmented address costs more to spend.
Balance check
0.00000000 = 0.00000000 − 0.00000000
Explorer: https://mempool.space/api · queried 2026-10-09 23:36:59 UTC
This explorer has never seen a transaction for this address, so there is no history to show. Note that "no history" is a statement about what this one explorer knows — an address that has only ever received an unconfirmed transaction will look empty here too.

Live 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.

Querying block explorers…
P2PKH · mainnet · this address
…
P2SH-P2WPKH · mainnet
…
P2PKH · testnet
…
P2SH-P2WPKH · testnet
…
Total across these addresses—
How it works

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:

QuestionAnswered byNeeds the internet?
Is this string a valid address?Pure arithmetic on this serverNo
Which address type is it, and what script does it stand for?Pure arithmetic on this serverNo
What other addresses share its key?Pure arithmetic on this serverNo
What is its balance and transaction history?A public block explorerYes

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:

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:

Base58CheckBech32 / Bech32m
Looks like1…, 3…bc1q…, bc1p…
Alphabet58 characters — 0, O, I and l removed32 characters qpzry9x8gf2tvdw0s3jn54khce6mua7l
Version byteOne byte prefix (0x00, 0x05, …)Human-readable part (bc) plus a 5-bit witness version
Checksum4 bytes of SHA256(SHA256(payload))A 6-character BCH code over the whole string
DetectsAny single-character error with overwhelming probabilityAny 4 errors; published guarantees for longer runs
CaseCase-sensitiveAll-lower or all-upper; mixed case is invalid by design
IntroducedOriginal client, 2009BIP173, 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:

TypePrefixCommits toscriptPubKeySize
P2PKH1…hash160(pubkey)OP_DUP OP_HASH160 <20B> OP_EQUALVERIFY OP_CHECKSIG25 B
P2SH3…hash160(redeemScript)OP_HASH160 <20B> OP_EQUAL23 B
P2WPKHbc1q… (20 B)hash160(pubkey)OP_0 <20B>22 B
P2WSHbc1q… (32 B)SHA256(witnessScript)OP_0 <32B>34 B
P2TRbc1p…x coordinate of the tweaked output keyOP_1 <32B>34 B
Why this page sometimes refuses to go further

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.

AddressTypeSame key?
1BgGZ9tcN4rm9KBzDn7KprQz87SZ26SAMHP2PKH mainnetYes
3JvL6Ymt8MVWiCNHC7oWU6nLeHNJKLZGLNP2SH-P2WPKH mainnetYes
bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kv8f3t4P2WPKH mainnetYes
mrCDrCybB6J1vRfbwM5hemdJz73FwDBC8rP2PKH testnetYes
2NAUYAHhujozruyzpsFRP63mbrdaU5wnEpNP2SH-P2WPKH testnetYes
tb1qw508d6qejxtdg4y5r3zarvary0c5xw7kxpjzsxP2WPKH testnetYes

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.

Siblings are a strong hint, not a proof

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:

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:

balance = Σ(unspent outputs paying this address) = total received − total spent

Three consequences follow, and the page shows the ingredients separately so you can check them:

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:

DirectionMeaning
inOutputs pay this address; no input spends from it.
outInputs spend from this address; nothing comes back to it.
self / netBoth sides involve this address — a consolidation, a change output, or a self-transfer.

Other columns deserve a note:

Why the list may be shorter than the transaction count

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:

AddressWhat it is
1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNaThe genesis coinbase output — the first 50 BTC, never spent.
1BitcoinEaterAddressDontSendf59kuEA deliberate burn address whose key nobody has.
1111111111111111111114oLvT2The 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

ItemValue
Mainnet P2PKH / P2SH prefixes0x00 → 1… / 0x05 → 3…
Testnet P2PKH / P2SH prefixes0x6F → m…/n… / 0xC4 → 2…
bech32 hrpsbc mainnet, tb testnet, bcrt regtest
Witness program sizes2–40 bytes; v0 must be exactly 20 (P2WPKH) or 32 (P2WSH)
Checksum constant1 for v0 (bech32), 0x2bc830a3 for v1+ (bech32m)
Address length limit90 characters for bech32, ~34–35 for Base58 mainnet
Sibling-derivable typesP2PKH and P2WPKH only (they carry hash160(pubkey))
Explorer transaction limit50 most recent per address, per request