Your wallet shows a payment. A node checks it. A miner may put it in a block. Those are different jobs, even when one application handles several of them.
For readers comparing a Bitcoin full node with a wallet, the useful distinction is checking the ledger versus authorizing a spend. This article maps those responsibilities. It is an explanation, not a node-installation guide or a hardware shopping list.
Four jobs that a Bitcoin app can combine
Bitcoin.org defines a full node by its validation of transactions and blocks. Many nodes also relay data to peers. Wallet functions and mining have separate responsibilities.
| Function | What it does | What it does not establish |
|---|---|---|
| Wallet and signer | Prepare payments, track relevant outputs and produce required signatures | That a payment will confirm or that a provider has credited an account |
| Full-node validation | Check transactions, blocks and chain state against the rules the node enforces | Control of anybody else's private keys |
| Relay | Share eligible transactions and blocks with peers | Guaranteed delivery to every node or inclusion by a miner |
| Mining | Search for proof of work for a candidate block | Permission to make other nodes accept an invalid block |
The distinction matters when somebody calls all four activities "running Bitcoin." An application can combine them, but a feature in one column does not supply the others automatically.
What a Bitcoin full node checks
A node evaluates proposed history rather than accepting a balance because a website displays it. For an ordinary spend, relevant checks include whether its referenced outputs are available, whether spending conditions are met and whether the transaction's amounts obey the rules. Blocks have additional checks, including proof of work and permitted creation of new bitcoin.
The transaction guide explains spending conditions and references to earlier outputs. Bitcoin Core's version 31.1 validation implementation separates transaction admission, block checks and connecting a block to the unspent-output state. This is a description of documented mechanisms, not an independent security audit of that code.
An ordinary fully validated chain is selected by cumulative proof of work among valid candidates. A longer-looking row of blocks is not enough. Core's 31.0 blockchain-status reference distinguishes validated block height, headers, chain work and initial-sync status. A screen saying "connected" does not establish that its node has caught up.
There are implementation qualifications. Core can use an assumed-valid historical block to skip certain old signature checks under specified conditions; that setting does not simply force adoption of an arbitrary chain. Avoid treating "full node" as a promise that every historical signature was freshly rechecked in every configuration. Nothing here requires changing those settings.
A wallet can sign without being a full node
The Bitcoin wallet guide separates receiving information, signing and network interaction. A signing device can hold private keys while another program obtains blockchain data and broadcasts the signed transaction. A wallet can instead use a remote service for its view of the chain.
A watch-only wallet tracks relevant scripts or addresses without possessing the keys needed to spend. A displayed balance therefore does not prove that the particular device can sign. Conversely, possession of signing keys does not mean the wallet independently validates every block. Ask both questions: who can authorize the spend, and whose chain information does the interface use?
Our wallet explainer covers custody more broadly. Running a separate node does not recover a lost signing key, change an exchange account into self-custody or make a malicious destination harmless. Key control and validation are separate responsibilities.
Follow one payment through the separate roles
Consider a fictional payment using an ordinary output the sender can spend. There are no real addresses, keys or live funds in this example.
- The wallet selects an earlier output and prepares recipient, change and fee details. The UTXO explainer covers that inventory.
- The signer authorizes those transaction details with the required key material. That signature does not reserve space in a future block.
- A connected node checks the transaction for its mempool and possible relay. Other peers make their own admission decisions.
- Mining software selects transactions for a candidate block and miners search for a qualifying proof of work.
- Receiving nodes validate the proposed block before accepting it into their chain state. An invalid spend does not become valid merely because a miner included it.
The mining guide describes the separate work of constructing candidate blocks and hashing their headers. Merely keeping a validating node online does not earn the block subsidy or transaction fees. A node is not a mining-reward subscription.
Relay policy is different from consensus validity
A node need not admit and forward every transaction that could be valid inside a block. Its relay policy governs unconfirmed transactions, resource use and mempool admission. Consensus checks govern the validity of blocks and their transactions. Those are related but different decisions.
Core's validation implementation makes that separation explicit. Our Bitcoin dust article examines a concrete policy example without inventing a universal minimum payment. A rejection by one node's mempool is not, by itself, proof that every possible block containing the transaction violates consensus.
Nor does successful relay mean that every peer has received the transaction. Inclusion depends on subsequent block selection and validation. For the next stage, the confirmation explainer separates inclusion, later block depth and a receiving service's account credit.
A pruned full node keeps less old block data
Pruning changes retained history, not the node into a wallet or miner. A pruned full node can discard older raw block and undo files after processing them, while retaining the state and metadata it needs to continue validating.
Core's historical pruning introduction explains that design. Its old wallet-compatibility and relay restrictions describe that historical release, not current Core. The 31.1 validation source still contains pruning logic; the 31.0 status reference separately reports whether pruning is active and the earliest retained block height.
An archival, unpruned node retains old block data; a pruned one cannot serve a block it no longer holds from its local files. Historical rescans and data requests consequently need attention to what is available. Keeping less history does not mean keeping fewer of the current consensus rules. It also does not eliminate initial synchronization or make the remaining data a backup of your signing keys.
Questions to ask about your setup
You can identify the responsibilities without installing anything:
- Does the interface use its own validating node, another node you control, or a provider's service?
- Is the node on the intended network and synchronized, rather than merely connected?
- Where does signing happen, and is the interface watch-only?
- Is the displayed transaction unsigned, broadcast, in a mempool or included in the active chain?
- If old history is needed, does the node retain it?
Using your own node can reduce reliance on somebody else's chain view. It does not automatically make your activity anonymous, protect compromised keys or guarantee a payment's timing. This comparison does not prescribe a particular network configuration or security change.
Brokzi's Take
A Bitcoin full node gives you a way to check the ledger under the rules your software enforces. A wallet handles the information and authorization needed to spend. Identify those two responsibilities first; then keep relay, mining and confirmation as separate stages. One app icon can hide several jobs.
Sources
Primary documentation checked October 26, 2026. Bitcoin Core source references are pinned to 31.1; the RPC documentation is explicitly 31.0. Developer guides contain historical examples, used here for the mechanisms rather than current software popularity, storage requirements or mining economics. No node, RPC, wallet, signer, installation or transfer was tested. The illustration is fictional. Education, not financial advice.
- Bitcoin.org: Full nodes: validation and network relay; its setup and hardware advice is outside this article's scope.
- Bitcoin Developer Guide: Transactions: previous outputs, spending conditions and signatures.
- Bitcoin Developer Guide: Wallets: separable wallet, signer and networking functions.
- Bitcoin Developer Guide: Mining: candidate construction and proof-of-work search.
- Bitcoin Core 31.1: Project documentation: node software, history and synchronization.
- Bitcoin Core: Historical 0.11.0 pruning notes: pruning's original design, not current compatibility restrictions.
- Bitcoin Core 31.0: getblockchaininfo: chain state, sync status and pruning fields.
- Bitcoin Core 31.1: Validation source: block/transaction checks, assumed-valid behavior and pruning implementation.
- Bitcoin Core 31.1 release: provenance for the pinned source version, not a recommendation to install or upgrade.
See something wrong? Brokzi logs material changes. Prepare a correction note.




