Bitcoin transactions can look simple from the outside.
You send Bitcoin to an address, the network verifies the transaction, miners include it in a block, and the recipient eventually receives their funds.
But what happens when more than one person, wallet, or device needs to participate in creating and signing the same transaction?
This is where PSBT, or Partially Signed Bitcoin Transaction, becomes useful.
A PSBT is a standardized format for sharing a Bitcoin transaction that is not fully signed yet, along with additional information needed by wallets and signing devices to verify and complete it.
Instead of passing around a raw transaction and hoping every wallet has enough information to understand it, PSBT provides a structured way for different participants to work on the same transaction.
This makes PSBT especially useful with hardware wallets, multisig wallets, offline signing, and CoinJoin transactions. Bitcoin Core has supported PSBT functionality since version 0.17.
In this guide, we’ll explain what PSBT means, why it was created, how it works, what information it contains, and why it has become an important part of modern Bitcoin wallet infrastructure.
What Does PSBT Stand For?
PSBT stands for:
Partially Signed Bitcoin Transaction
Each word tells you something important.
Partially
The transaction isn’t necessarily ready to broadcast.
One or more required signatures may still be missing.
Signed
A participant can add a valid signature for the inputs they control.
However, the transaction can remain incomplete until all required signatures are present.
Bitcoin Transaction
The PSBT ultimately represents a Bitcoin transaction that can eventually be finalized and broadcast to the network.
So a simple definition is:
A PSBT is a standardized package containing an unsigned or partially signed Bitcoin transaction plus information needed to complete and verify it.
The standard was formally specified in BIP 174, titled “Partially Signed Bitcoin Transaction Format.” It was created to make transaction-signing workflows interoperable between different Bitcoin applications.
Why Was PSBT Created?
Before PSBT, different Bitcoin wallet implementations could use their own formats for exchanging partially signed transactions.
That created a compatibility problem.
Imagine you have:
- Wallet A
- Hardware Wallet B
- Multisig software C
All three need to cooperate on one Bitcoin transaction.
If each application uses a different format, transferring the transaction between them becomes difficult.
PSBT provides a common language.
Instead of creating a proprietary file format for every wallet, applications can use the standardized PSBT format.
This makes it easier to move a transaction from one piece of software to another.
BIP 174 specifically describes the goal as creating a standard and extensible format that allows clients to pass the same transaction between multiple signers and combine their signatures.
PSBT Is Not a New Type of Bitcoin Transaction
This is one of the most important things to understand.
A PSBT isn’t a special transaction that gets broadcast to the Bitcoin network.
It is better described as an interchange format.
Think of it as a container used while preparing a Bitcoin transaction.
For example:
Create transaction
↓
Convert to PSBT
↓
Add transaction information
↓
Sign
↓
Add more signatures if necessary
↓
Finalize
↓
Extract normal Bitcoin transaction
↓
Broadcast
The final result is an ordinary Bitcoin transaction.
The PSBT is the package used during the preparation and signing process.
Bitcoin Core’s documentation describes PSBT as an interchange format for transactions that are not fully signed yet, together with metadata that helps participants work toward signing them.
Why Can’t We Just Sign a Normal Bitcoin Transaction?
Sometimes you can.
If you’re using a simple wallet where one device controls all the necessary private keys, the wallet can often create and sign the transaction internally without exposing the intermediate process to you.
PSBT becomes particularly useful when the transaction needs to move between different devices or participants.
For example, imagine you have Bitcoin stored on a hardware wallet.
Your computer might be responsible for:
- Selecting UTXOs
- Creating transaction outputs
- Calculating fees
- Preparing the transaction
But your hardware wallet holds the private keys.
You don’t want those private keys copied to the computer.
Instead, the computer can prepare a PSBT and send it to the hardware wallet.
The hardware wallet can inspect the transaction and sign it without revealing its private keys.
This is one of the major security advantages of PSBT.
PSBT and Hardware Wallets
Hardware wallets are one of the most common places where beginners encounter PSBT.
A hardware wallet is designed to keep private keys isolated from the general-purpose computer or phone used to interact with Bitcoin.
Suppose you want to send 0.01 BTC.
Your computer creates the transaction.
But the private key remains inside the hardware wallet.
The transaction information can be passed to the hardware wallet using a PSBT.
The hardware wallet can then verify important information before signing.
For example, it can determine:
- Which UTXOs are being spent
- How much Bitcoin is being spent
- Where the Bitcoin is being sent
- What fee is being paid
- Which keys are required
If everything looks correct, the hardware wallet creates the required signature.
The private key itself does not need to leave the signing device.
BIP 174 was designed partly to support offline signers such as air-gapped and hardware wallets.
A Simple Hardware Wallet Example
Imagine Sarah owns Bitcoin using a hardware wallet.
She wants to send:
0.02 BTC → Bob
Her laptop prepares the transaction.
However, the laptop does not have Sarah’s private key.
Instead, the laptop creates a PSBT containing the transaction and relevant information.
Sarah transfers the PSBT to her hardware wallet.
The hardware wallet reads the transaction.
It shows Sarah something like:
Send: 0.02000000 BTC
Recipient: Bob’s Bitcoin address
Fee: 0.00005000 BTC
Sarah checks the information.
If everything is correct, she approves the transaction.
The hardware wallet adds Sarah’s signature.
The signed PSBT can then return to the computer.
The computer finalizes the transaction and broadcasts it.
The important point is that the private key never needed to leave the hardware wallet.
PSBT and Multisig Wallets
PSBT becomes even more useful with multisig.
A multisig wallet can require multiple signatures before Bitcoin can be spent.
For example, a 2-of-3 multisig wallet could require any two of three authorized keys.
Suppose the three signers are:
- Alice
- Bob
- Charlie
Alice wants to spend Bitcoin from the shared wallet.
She creates a transaction and turns it into a PSBT.
Alice signs it.
The PSBT now contains one required signature.
She sends the PSBT to Bob.
Bob reviews the transaction and adds his signature.
Now the transaction has two signatures.
Because the wallet requires only two of the three signatures, the transaction can be finalized.
It can then be extracted as a normal Bitcoin transaction and broadcast.
Bitcoin Core’s own multisig tutorial uses PSBTs for this workflow because multiple cosigners need to participate in creating and signing the transaction.
If you haven’t read our guide on What Is a Bitcoin Multisig Wallet?, it’s a useful companion to this article.
Why PSBT Is Useful for Multisig
Without a standardized format, each signer would need to exchange transaction information in a way their software understands.
PSBT makes that process much easier.
The transaction can move between different participants while accumulating signatures and other information.
For example:
PSBT
↓
Alice signs
↓
PSBT + Alice’s signature
↓
Bob signs
↓
PSBT + Alice + Bob
↓
Finalize
↓
Bitcoin transaction
This is one of the main reasons PSBT is so important for collaborative Bitcoin custody.
PSBT and CoinJoin
PSBT is also useful in CoinJoin transactions.
CoinJoin allows multiple participants to collaborate on a single Bitcoin transaction.
The transaction may contain inputs belonging to different users.
Each participant needs to sign their own inputs without giving their private keys to the coordinator or other participants.
PSBT provides a standardized way to exchange the transaction and relevant signing information.
Bitcoin Core’s PSBT documentation explicitly lists CoinJoin alongside hardware wallets and multisig as examples of workflows where PSBT can be useful.
This is another reason PSBT is more than simply a hardware-wallet feature.
It is a general tool for coordinating Bitcoin transaction signing.
What Information Does a PSBT Contain?
A PSBT contains more than just the transaction itself.
It can contain additional metadata needed by participants to understand and sign the transaction correctly.
Depending on the transaction and PSBT version, information can include:
- The unsigned transaction
- Previous transaction outputs
- UTXO information
- Public keys
- Derivation paths
- Redeem scripts
- Witness scripts
- Partial signatures
- Sighash information
- Other protocol-defined metadata
BIP 174 defines PSBT as a collection of key-value maps containing global, per-input, and per-output information.
This additional information is what makes PSBT useful.
A signer doesn’t simply receive a mysterious transaction and blindly sign it.
The PSBT can provide the context necessary to inspect and validate what is being signed.
Why Does a Signer Need UTXO Information?
To understand this, remember how Bitcoin transactions work.
A Bitcoin transaction spends previous outputs.
Those outputs contain specific amounts of Bitcoin and spending conditions.
A signer needs enough information to determine what is actually being spent.
For example, suppose a transaction spends:
UTXO A = 0.05 BTC
and sends:
0.04 BTC to a recipient
The remaining amount may become change, while another portion pays the transaction fee.
A signing device needs to understand the amounts involved so it can help the user verify the transaction.
PSBT allows relevant UTXO information to travel along with the transaction.
This is particularly valuable for offline signing devices.
PSBT Helps Hardware Wallets Verify What They’re Signing
Imagine a computer is compromised.
It could potentially attempt to create a transaction that looks different from what the user intended.
If the hardware wallet blindly signed whatever it received, the security benefit of keeping the private key isolated would be greatly reduced.
A properly implemented PSBT workflow gives the signing device information it can use to inspect the transaction.
The device can check things such as:
What inputs are being spent?
How much value do they contain?
Where is the Bitcoin going?
What fee is being paid?
Which keys are involved?
This creates an important security boundary.
The computer can prepare the transaction.
The hardware wallet controls the private key and approves the signature.
BIP 174 specifically notes that signers can calculate addresses, values, and transaction fees and present this information to users for confirmation.
PSBT Does Not Reveal Your Private Key
A PSBT can contain public information and signatures, but it isn’t supposed to contain your private key.
This is crucial.
The entire purpose of a hardware-wallet signing workflow is to allow the signing device to use its private key without exposing it to the computer.
The private key stays with the signer.
The signer adds a signature to the PSBT.
The signature proves authorization without revealing the secret key itself.
This is based on public-key cryptography, which is one of the foundations of Bitcoin.
If you’re unfamiliar with the difference between these keys, our guide to Bitcoin Private Keys vs Public Keys explains the concept in beginner-friendly terms.
What Does “Partially Signed” Actually Mean?
The word “partially” can be confusing.
It doesn’t necessarily mean that every PSBT has exactly one signature.
A PSBT can have:
Zero signatures
One signature
Several signatures
depending on the workflow.
For a simple wallet, a PSBT may begin unsigned and receive one signature.
For a multisig wallet, it might collect several signatures before becoming complete.
The important point is that the transaction isn’t fully finalized yet.
A PSBT Can Move Between Multiple Devices
One of the biggest advantages of the format is portability.
A PSBT can be transferred between different devices and applications.
For example:
Laptop
↓
PSBT
↓
Hardware wallet
↓
Signed PSBT
↓
Laptop
↓
Broadcast
In a multisig setup, the process might instead look like:
Coordinator
↓
PSBT
↓
Signer A
↓
Signer B
↓
Signer C
↓
Finalized transaction
The exact workflow depends on the wallet and application.
But the underlying concept remains the same.
How Is a PSBT Represented?
A PSBT can be represented in different ways.
BIP 174 specifies a binary format and also allows PSBTs to be represented as Base64 strings.
This is why you may sometimes see a PSBT that looks like a long string of letters, numbers, and symbols rather than a familiar Bitcoin transaction.
For example, a wallet might display or export a PSBT as a Base64-encoded string.
You don’t need to understand the encoding to use PSBT.
The wallet software normally handles the conversion automatically.
What Is the .psbt File?
A PSBT can also be saved as a file.
The standard specifies the .psbt extension for binary PSBT files.
For example:
transaction.psbt
A user can transfer that file between compatible applications.
This can be particularly useful for offline signing.
You could create the transaction on an internet-connected computer, move the PSBT to an offline signing device, sign it, and then move the signed PSBT back to another computer for finalization and broadcasting.
Is a PSBT the Same as a Signed Bitcoin Transaction?
No.
This distinction is essential.
A PSBT is an intermediate representation used while preparing and signing a transaction.
A fully signed Bitcoin transaction is ready to be broadcast, assuming it satisfies the network’s validation rules.
Think of it like preparing a legal document.
A PSBT is similar to a document that has been prepared and is waiting for all required signatures.
The final signed transaction is the completed document.
Once all required signatures are present, the PSBT can be finalized and the resulting Bitcoin transaction can be extracted.
Bitcoin Core provides finalizepsbt to finalize a PSBT and, when all inputs are finalized, extract a fully signed transaction suitable for broadcasting.
The Basic PSBT Lifecycle
At a high level, a PSBT can move through several stages:
1. Create
A transaction is created and placed into PSBT format.
2. Update
Relevant UTXO, script, key, and other metadata is added.
3. Sign
One or more authorized signers add signatures.
4. Combine
Information from different versions of the same PSBT can be merged when necessary.
5. Finalize
The partial signatures and script information are converted into the final input spending data.
6. Extract
The completed Bitcoin transaction is produced.
7. Broadcast
The normal Bitcoin transaction is sent to the network.
Bitcoin Core’s PSBT documentation describes these roles as Creator, Updater, Signer, Combiner, Finalizer, and Extractor.
These roles can be performed by different devices or applications, or several roles can be handled by the same piece of software.
The Six Main Roles in a PSBT Workflow
BIP 174 describes several specialized roles that can participate in the PSBT process:
- Creator
- Updater
- Signer
- Combiner
- Input Finalizer
- Transaction Extractor
These aren’t necessarily six different people or six different programs.
One wallet application can perform several roles itself.
For example, Bitcoin Core’s walletprocesspsbt can update a PSBT, sign it, and finalize inputs where possible.
The roles are separated conceptually because each one performs a different task.
1. The Creator
The Creator starts the process.
Its job is to create the basic unsigned Bitcoin transaction and place it inside a PSBT.
A transaction contains inputs and outputs.
The inputs identify previous Bitcoin outputs that will be spent.
The outputs specify where the Bitcoin should go and how much should be sent.
For example, imagine Alice wants to send:
0.05 BTC → Bob
The Creator prepares the basic transaction.
It might contain:
Input: Alice’s UTXO containing 0.06 BTC
Output: Bob receives 0.05 BTC
Output: Alice receives 0.0098 BTC as change
Fee: 0.0002 BTC
At this stage, the transaction doesn’t necessarily contain the signatures needed to authorize spending the input.
The Creator places this unsigned transaction into the PSBT structure.
BIP 174 specifies that the Creator must create the unsigned transaction and place it into the PSBT, while initially leaving the input and output fields empty.
2. The Updater
The Creator may not know everything required by a signer.
That’s where the Updater comes in.
The Updater adds information it knows about the transaction.
This can include information such as:
- Previous transaction outputs
- UTXO information
- Redeem scripts
- Witness scripts
- Public keys
- BIP32 derivation paths
- Other relevant metadata
Why is this necessary?
Because a signing device needs enough information to understand what it is being asked to sign.
Imagine a hardware wallet receives only a transaction’s input and output references.
It may not have all the information necessary to independently verify the spending conditions.
The PSBT can carry additional information alongside the transaction.
BIP 174 specifically defines the Updater’s role as adding information available to it, including UTXO data, scripts, and key derivation information when known.
Why UTXO Information Matters
Remember that Bitcoin doesn’t store balances in the same way a traditional bank account does.
Bitcoin uses Unspent Transaction Outputs, or UTXOs.
When you spend Bitcoin, you’re actually spending one or more previous outputs.
For example:
Previous UTXO = 0.06 BTC
You want to send:
0.05 BTC
The transaction might allocate:
0.05 BTC → Recipient
0.0098 BTC → Change
0.0002 BTC → Fee
A signer needs to understand the previous output being spent.
This is particularly important for hardware wallets because the device may be deliberately isolated from the computer creating the transaction.
PSBT allows the relevant UTXO information to travel with the transaction.
BIP 174 was specifically designed so offline signers can receive the information needed to sign without having direct access to the UTXO set.
3. The Signer
The Signer is responsible for producing signatures.
This is where private keys become important.
A signer has access to the private key or keys required to authorize one or more inputs.
However, the private key itself doesn’t get added to the PSBT.
Instead, the signer uses the private key internally to create a cryptographic signature.
The signature is then added to the PSBT.
This is a fundamental security principle.
Private key stays with the signer.
Signature travels with the PSBT.
That distinction is what makes PSBT particularly useful for hardware wallets and offline signing.
Hardware Wallet Example
Let’s return to Alice.
Alice’s laptop creates the transaction.
But Alice’s private key is stored inside her hardware wallet.
The laptop creates a PSBT and transfers it to the hardware wallet.
The hardware wallet checks the transaction.
It can display information such as:
Amount: 0.05 BTC
Recipient: Bob
Fee: 0.0002 BTC
Alice reviews the information on the trusted device.
If everything is correct, she approves it.
The hardware wallet uses its private key to produce the signature.
The private key doesn’t need to be transmitted back to the laptop.
The signed PSBT returns to the computer.
This creates a useful security boundary between transaction preparation and key management.
What If a PSBT Needs Multiple Signatures?
This is where PSBT becomes especially powerful.
Imagine a 2-of-3 multisig wallet.
Three people control the wallet:
- Alice
- Bob
- Charlie
But the wallet requires only two signatures.
Alice creates the transaction.
The resulting PSBT can be sent to Alice, Bob, and Charlie’s signing devices.
Alice signs.
Now the PSBT contains Alice’s signature.
Bob reviews the same transaction and signs.
Now the PSBT contains two signatures.
The required threshold has been reached.
The transaction can move toward finalization.
Charlie doesn’t need to sign.
This is one of the practical reasons PSBT works so well with multisig systems.
4. The Combiner
What happens if Alice and Bob each sign their own copy of the PSBT?
You have:
PSBT A = transaction + Alice’s signature
and
PSBT B = transaction + Bob’s signature
You need to combine the information.
That’s the job of the Combiner.
The Combiner merges information from different PSBTs representing the same underlying unsigned transaction.
The result becomes:
Combined PSBT = transaction + Alice’s signature + Bob’s signature
BIP 174 specifies that a Combiner merges the key-value information from compatible PSBTs while removing duplicate entries as required by the format.
Bitcoin Core provides the combinepsbt command for this purpose.
Why Can’t You Just Join Any Two PSBTs?
This is an important distinction.
Combining PSBTs is not the same thing as joining PSBTs.
Suppose Alice and Bob each signed the same transaction.
Their PSBTs represent the same underlying transaction.
You can combine them.
But imagine you have two completely different transactions.
One spends Alice’s UTXO.
The other spends Bob’s UTXO.
Those aren’t simply two signatures for the same transaction.
They represent different transactions.
You can’t treat them as though they’re two copies of the same PSBT.
Bitcoin Core therefore distinguishes combinepsbt from joinpsbts.
combinepsbt merges information from different PSBTs representing the same transaction.
joinpsbts serves a different purpose: it joins the inputs and outputs of different PSBTs into one PSBT, which can be useful in workflows such as CoinJoin.
Parallel vs Sequential Signing
There are two broad ways multiple signers can work with a PSBT.
Sequential Signing
The PSBT moves from one signer to another.
For example:
Creator
↓
Alice signs
↓
Bob signs
↓
Charlie signs
↓
Finalize
Each signer receives the updated PSBT from the previous participant.
This is straightforward but can become inconvenient when many people are involved.
Parallel Signing
Instead, the same original PSBT can be sent separately to multiple signers.
For example:
Original PSBT
↙️ ↓ ↘️
Alice Bob Charlie
Each participant signs their own copy.
The separate versions can then be combined.
For a 2-of-3 multisig wallet, Alice and Bob’s signatures can be combined into one PSBT.
This approach can be more convenient because the signers don’t necessarily need to wait for one another.
Bitcoin Core’s multisig tutorial demonstrates this kind of workflow, where separate signed PSBTs are combined before finalization.
5. The Input Finalizer
Once the required signatures are available, the transaction still needs to be prepared for extraction.
This is where the Input Finalizer comes in.
A Bitcoin transaction input may require particular script or witness information to satisfy its spending conditions.
The Finalizer takes the information gathered during the PSBT process and constructs the final spending data for each input.
For example, depending on the type of Bitcoin output being spent, this could involve constructing:
scriptSig- Witness data
- Required signatures
- Other spending information
BIP 174 specifies that the Finalizer determines whether each input has enough information to pass validation and, if so, constructs the finalized scriptSig and/or witness data.
Why Finalization Is Different From Signing
Signing and finalization aren’t exactly the same thing.
Signing creates the cryptographic signatures.
Finalization puts the available signatures and other required information into the correct structure for the actual Bitcoin transaction.
This distinction becomes easier to understand with multisig.
Suppose a 2-of-3 transaction has:
Alice’s signature
Bob’s signature
The signatures exist.
But the PSBT still needs to be transformed into the final input structure required by the specific spending script.
That’s what finalization handles.
6. The Transaction Extractor
The final role is the Transaction Extractor.
Once all inputs are finalized, the Extractor can turn the PSBT into a normal Bitcoin transaction.
This is the point where the PSBT workflow effectively ends.
Conceptually:
PSBT
↓
All required signatures
↓
Finalized inputs
↓
Extract transaction
↓
Fully signed Bitcoin transaction
The resulting transaction can then be broadcast to the Bitcoin network.
Bitcoin Core’s finalizepsbt RPC can finalize a PSBT and, when all inputs are complete, extract the fully signed transaction. That transaction can then be broadcast with sendrawtransaction.
The Complete PSBT Workflow
Now we can put all the pieces together.
A typical workflow looks like this:
1. Creator
Creates the unsigned transaction.
↓
2. Updater
Adds UTXO, script, key, and other relevant information.
↓
3. Signer
Adds one or more cryptographic signatures.
↓
4. Combiner
Combines signatures and metadata from compatible PSBT copies when necessary.
↓
5. Finalizer
Constructs the finalized spending data for each completed input.
↓
6. Extractor
Produces the final network-serialized Bitcoin transaction.
↓
7. Broadcast
The completed transaction is sent to the Bitcoin network.
This sequence is the conceptual model defined by BIP 174 and implemented in different ways by Bitcoin software.
A Complete Example: Sending Bitcoin With a Hardware Wallet
Let’s put this into a realistic scenario.
Suppose Ahmed has:
0.15 BTC
stored on a hardware wallet.
He wants to send:
0.05 BTC
to a friend.
Step 1: Transaction Creation
Ahmed’s computer selects an appropriate UTXO.
The wallet creates the transaction.
Step 2: PSBT Creation
The transaction is placed into a PSBT.
Relevant information is added.
Step 3: Transfer to Hardware Wallet
The PSBT is transferred to Ahmed’s hardware wallet.
This might happen through a USB connection, QR codes, an SD card, or another supported method depending on the wallet.
Step 4: Verification
The hardware wallet examines the transaction.
Ahmed checks the destination and amount on the trusted device.
Step 5: Signing
Ahmed approves the transaction.
The hardware wallet uses the private key to create the signature.
Step 6: Return
The signed PSBT goes back to the computer.
Step 7: Finalization
The wallet finalizes the transaction.
Step 8: Extraction
The completed transaction is extracted from the PSBT.
Step 9: Broadcast
The computer broadcasts the transaction to the Bitcoin network.
At no point did the computer need to receive Ahmed’s private key.
That’s the core security benefit of this workflow.
What If the User Rejects the Transaction?
Suppose Ahmed looks at the hardware wallet and notices:
Recipient: Wrong Address
He rejects the transaction.
Nothing has been successfully authorized by his private key.
The PSBT can simply be discarded.
This illustrates an important security principle:
Creating a transaction isn’t the same as authorizing it.
A computer can prepare a transaction.
The signer decides whether to authorize it.
This separation is particularly useful when the signing device is designed to be trusted more than the computer preparing the transaction.
What If One Multisig Signer Refuses?
Consider the 2-of-3 example again.
Alice signs.
Bob refuses.
Charlie is unavailable.
The transaction has only one signature.
It cannot be finalized as a valid 2-of-3 spend.
The PSBT can remain incomplete.
Nothing forces Bob or Charlie to sign.
This is an important property of multisig.
The required threshold determines when the transaction can become spendable.
If enough authorized participants don’t approve it, the transaction doesn’t become a valid spend.
What If You Accidentally Send the Wrong PSBT?
A PSBT isn’t inherently dangerous simply because it is a file or encoded string.
The danger comes from what transaction it represents and what a signer authorizes.
This is why users should never blindly sign PSBTs received from unknown sources.
A malicious or compromised computer could potentially construct a transaction that sends Bitcoin somewhere the user doesn’t expect.
The hardware wallet or other signing device should therefore display enough information for the user to verify the transaction before approving it.
This is one reason reputable hardware-wallet workflows emphasize checking transaction details on the trusted signing device rather than relying entirely on the potentially compromised host computer.
Does a PSBT Need Internet Access?
No.
One of PSBT’s most useful properties is that the signing device can operate offline.
The transaction can be created on an internet-connected machine.
The PSBT can then be transferred to an offline signer.
The signer creates the signature.
The signed PSBT can be transferred back to an online machine.
The online machine broadcasts the resulting transaction.
Conceptually:
Online computer
↓
PSBT
↓
Offline signer
↓
Signed PSBT
↓
Online computer
↓
Bitcoin network
BIP 174 specifically designed the format to support offline signers such as air-gapped and hardware wallets.
PSBT and Air-Gapped Signing
An air-gapped device is intentionally separated from networks such as the internet.
Instead of connecting directly to the internet, it can exchange transaction information through methods such as:
- QR codes
- SD cards
- USB transfer
- Other removable or controlled media
The exact method depends on the wallet.
PSBT is useful here because the transaction doesn’t need to travel through an online private-key environment.
The device can receive the transaction information, sign it locally, and return the signed result.
This allows users to build a stronger separation between:
Transaction preparation
and
Private-key signing
What Happens If a PSBT Is Missing Information?
A PSBT doesn’t always have everything it needs at the beginning.
That’s normal.
The whole point of the format is that information can be added over time.
For example, a PSBT might initially have:
Transaction
but lack:
UTXO information
A later Updater can add it.
Then a signer can add:
Signature
Another signer can add:
Second signature
Finally, the transaction can be finalized.
Bitcoin Core provides analyzepsbt specifically to inspect a PSBT and report its current state, including missing information and what the next step may be.
Can Two People Sign the Same PSBT at the Same Time?
Yes, depending on the workflow.
They can each receive a copy of the same underlying PSBT.
Each signer adds their own information or signature.
The results can then be combined.
This is particularly useful for multisig.
For example:
Original PSBT
↙️ ↘️
Alice signs Bob signs
↘️ ↙️
Combine
↓
Finalize
↓
Broadcast
Bitcoin Core’s multisig documentation demonstrates separate signer outputs being combined before finalization.
Does PSBT Make Bitcoin Transactions Safer?
PSBT can improve the transaction-signing workflow, but it isn’t a magic security system.
Its benefits come from separating responsibilities.
For example:
A computer can prepare a transaction.
A hardware wallet can hold the private key.
A user can verify the transaction on the hardware wallet.
A multisig participant can independently review and sign.
This can reduce the amount of trust placed in any single device.
However, users still need to verify what they’re signing.
If someone approves a malicious transaction, PSBT itself won’t magically reverse it.
The Most Important Security Rule
Never assume:
“PSBT = safe.”
Instead, think:
“PSBT gives me a safer way to move and sign transaction information.”
The actual security still depends on:
- Wallet software
- Signing-device implementation
- Private-key protection
- User verification
- Correct transaction construction
- Secure communication between devices
A PSBT can carry a transaction.
It doesn’t decide whether you should sign that transaction.
You do.
What Information Does a PSBT Contain?
A PSBT can contain several categories of information.
At a high level, you can think of it as having three main sections:
- Global information
- Input information
- Output information
The global section describes the transaction itself.
The input sections contain information about the Bitcoin being spent.
The output sections contain information about where the Bitcoin is going and other details relevant to those outputs.
Depending on the transaction and wallet software, the PSBT can also contain information such as:
- Previous transaction outputs
- Public keys
- Derivation paths
- Redeem scripts
- Witness scripts
- Partial signatures
- Sighash information
- Finalized script data
- Wallet-specific metadata
Not every PSBT contains every possible field.
The information included depends on what the particular workflow requires.
Global, Input, and Output Maps
BIP 174 organizes PSBT information using key-value maps.
This might sound complicated, but the basic idea is simple.
Imagine a folder containing several smaller folders.
The global map contains information about the transaction as a whole.
Each input map contains information about a particular transaction input.
Each output map contains information about a particular transaction output.
For example, a transaction with three inputs and two outputs could conceptually look like:
Global information
→ Transaction data
Input 1
→ UTXO information
→ Public key information
→ Signature information
Input 2
→ UTXO information
→ Public key information
→ Signature information
Input 3
→ UTXO information
→ Public key information
→ Signature information
Output 1
→ Output-related information
Output 2
→ Output-related information
This structure allows different participants to add information without modifying the basic purpose of the PSBT format.
What Is a .psbt File?
A PSBT can be stored as a binary file.
The commonly used file extension is:
.psbt
For example:
transaction.psbt
A wallet application may export this file to an SD card, USB device, computer, or another supported transfer method.
The receiving wallet can then import the PSBT and continue the signing process.
This is particularly useful for offline and hardware-wallet workflows.
However, a PSBT doesn’t have to be transferred as a physical file.
Wallets can exchange PSBT data through different methods, depending on what they support.
What Is PSBT Base64?
You may also encounter PSBTs represented as Base64 text.
Instead of seeing a binary file, you might see a long string similar to:
cHNidP8BA...
The exact string depends on the transaction.
Base64 provides a convenient text representation of binary data.
This makes it possible to copy or transmit a PSBT through systems that handle text rather than binary files.
For example, a wallet might allow you to:
Export PSBT → Base64
Then another wallet can:
Import PSBT → Base64
The underlying PSBT information remains the same.
Base64 does not mean the transaction has been encrypted.
That’s an important distinction.
Is a PSBT Encrypted?
No.
PSBT is a transaction interchange format, not an encryption system.
The information contained in a PSBT may be readable by software that understands the format.
Therefore, you shouldn’t assume that sending a PSBT through an insecure channel automatically protects its contents.
Most importantly, private keys are not supposed to be included in a PSBT.
A PSBT can contain public information and signatures, but the private keys used to produce those signatures remain with the signer.
Can Someone Steal Bitcoin From a PSBT?
Simply possessing a PSBT generally does not give someone your private key.
A PSBT isn’t equivalent to a wallet seed phrase or private key.
However, that doesn’t mean you should blindly trust every PSBT.
A PSBT can represent a transaction that sends your Bitcoin somewhere.
If you sign a malicious transaction, your signature can authorize that transaction.
For example, imagine you think you’re signing:
0.01 BTC → Your friend
But the transaction actually contains:
0.01 BTC → Attacker’s address
If your signing device doesn’t clearly communicate the destination and you approve the transaction, the PSBT format itself won’t protect you from your mistake.
Therefore:
Always verify what you’re signing.
This is one of the most important PSBT security rules.
PSBT Security Best Practices
Using PSBT correctly can create a strong transaction-signing workflow, but users still need to follow basic security practices.
1. Verify the Destination
Before signing, confirm that the Bitcoin is going to the intended address.
Don’t rely only on what a potentially compromised computer tells you.
When possible, verify transaction details directly on your trusted signing device.
2. Check the Amount
Make sure the amount is correct.
For example:
Expected: 0.05 BTC
If your device displays:
0.5 BTC
stop immediately.
A decimal mistake can be extremely expensive in Bitcoin.
3. Check the Fee
Transaction fees are another important detail.
A transaction may contain a valid recipient and still charge a fee that is much higher than expected.
Review the fee before signing.
4. Keep Private Keys Offline When Appropriate
PSBTs are especially useful when private keys remain on dedicated signing devices.
For larger Bitcoin holdings, users may choose hardware wallets or more advanced setups that reduce exposure of private keys to internet-connected computers.
5. Don’t Sign Unknown PSBTs
Someone sending you a PSBT doesn’t automatically mean you should sign it.
If you don’t understand why a PSBT was created or where it came from, investigate it before approving anything.
This is especially important in multisig and collaborative environments.
PSBT vs. Raw Bitcoin Transaction
A common beginner question is:
“What’s the difference between a PSBT and a Bitcoin transaction?”
The simplest answer is:
A PSBT is a workflow format.
A raw Bitcoin transaction is the final transaction format that the Bitcoin network validates.
A PSBT can contain an unsigned transaction plus additional information required by signers.
Once all necessary inputs are properly finalized, the transaction can be extracted into its final serialized form.
Conceptually:
PSBT
↓
Contains transaction + signing information
↓
Sign
↓
Finalize
↓
Extract
↓
Raw Bitcoin transaction
↓
Broadcast
The PSBT itself isn’t something that needs to be broadcast to Bitcoin’s peer-to-peer network.
The completed Bitcoin transaction is what gets broadcast.
PSBT vs. Private Key
These are completely different things.
A private key is secret cryptographic information used to authorize spending.
A PSBT is a package used to coordinate transaction creation and signing.
Think of it this way:
Private key = authorization capability
PSBT = transaction workflow package
The PSBT can travel between devices.
The private key should remain protected.
That separation is one of the main reasons PSBT is useful.
PSBT vs. Seed Phrase
A seed phrase is even more different.
A wallet’s seed phrase can potentially regenerate the wallet’s private keys.
Losing a seed phrase can therefore mean losing access to the Bitcoin controlled by that wallet.
A PSBT doesn’t perform this function.
You can generally share a PSBT with another participant without giving them the ability to regenerate your private keys.
Nevertheless, you should still treat transaction data carefully because it can reveal information about your transaction and wallet activity.
PSBT and Multisig
PSBT becomes particularly powerful when several people need to cooperate.
Consider a 2-of-3 multisig wallet.
There are three authorized signers:
Alice
Bob
Charlie
But the wallet requires two signatures.
Alice creates the transaction.
The PSBT is distributed to the signers.
Alice signs.
Bob signs.
The two signed versions can be combined.
The transaction now has enough signatures to satisfy the 2-of-3 requirement.
It can then be finalized and extracted.
This means the transaction process doesn’t require everyone to hand over private keys to a central computer.
Each signer can maintain control over their own signing key.
PSBT and Hardware Wallets
Hardware wallets are another major use case.
The computer can handle transaction construction while the hardware wallet handles signing.
That separation can reduce the amount of sensitive key material exposed to the computer.
A simplified workflow looks like this:
Computer
Create transaction
↓
PSBT
↓
Hardware wallet
Review + sign
↓
Signed PSBT
↓
Computer
Finalize + broadcast
The hardware wallet never needs to reveal its private key to the computer.
Instead, it produces the cryptographic signature required by the transaction.
PSBT and CoinJoin
PSBTs can also be useful in collaborative transactions such as CoinJoin.
In a collaborative transaction, multiple participants contribute inputs and outputs.
Different participants may need to sign their own inputs without giving their private keys to the coordinator.
PSBT provides a standardized way of moving the transaction and signing information between participants.
This makes it possible to coordinate complex transactions while keeping signing authority distributed.
Common PSBT Mistakes Beginners Make
Even though PSBT itself is relatively straightforward once understood, several mistakes are common.
Mistake 1: Thinking PSBT Is a Cryptocurrency
It isn’t.
PSBT is a Bitcoin transaction format.
You don’t buy, sell, or hold PSBT as an asset.
Mistake 2: Thinking PSBT Contains Private Keys
It shouldn’t.
The purpose of PSBT is partly to allow transaction information to move between devices without moving private keys.
Mistake 3: Assuming “Partially Signed” Means “Half Signed”
Not necessarily.
A PSBT can contain zero signatures.
It can contain one signature.
It can contain several signatures.
“Partially signed” describes the state of the transaction within the signing workflow, not necessarily a percentage.
Mistake 4: Signing Without Checking the Transaction
This is one of the most dangerous mistakes.
A PSBT can represent a transaction that sends Bitcoin to an address you don’t expect.
Always review the transaction before signing.
Mistake 5: Confusing Base64 With Encryption
Base64 is an encoding.
It doesn’t make a PSBT secret.
Don’t treat a Base64 PSBT like encrypted information.
Mistake 6: Assuming Every Wallet Uses PSBT in Exactly the Same Way
Different wallets can provide different interfaces and workflows.
Some may automatically handle much of the PSBT process.
Others may expose more technical controls.
The underlying PSBT standard provides the format, while wallet software determines how users interact with it.
Why Was PSBT Created?
Before standardized PSBT workflows became common, different Bitcoin applications had more difficulty exchanging partially completed transactions and the information needed to sign them.
PSBT provides a common format.
This helps different pieces of Bitcoin software communicate during transaction construction and signing.
That’s particularly valuable in an ecosystem where users may combine:
- Desktop wallets
- Hardware wallets
- Multisig coordinators
- Offline computers
- Mobile wallets
- Bitcoin nodes
- Specialized signing devices
Instead of every application inventing its own transaction-sharing system, PSBT provides a standardized structure.
Is PSBT Only for Advanced Bitcoin Users?
No.
The underlying format is technical, but beginners may already use PSBT without realizing it.
For example, a hardware wallet application may create or process PSBTs automatically.
You might simply click:
Send → Review → Sign
while the software handles the PSBT process behind the scenes.
You don’t need to understand every field inside a PSBT to use Bitcoin safely.
However, understanding the basic concept helps explain what your wallet is actually doing.
The Big Picture
After going through the entire process, the most important idea is simple:
A PSBT allows a Bitcoin transaction to move between different participants and devices before it becomes a final broadcastable transaction.
One device can create the transaction.
Another can add information.
A hardware wallet can sign it.
Several multisig participants can add their signatures.
Those signatures can be combined.
The transaction can then be finalized and extracted.
Finally, the completed transaction can be broadcast to the Bitcoin network.
Throughout the process, the private keys can remain with their respective owners.
That’s why PSBT has become such an important part of modern Bitcoin wallet infrastructure.
Frequently Asked Questions About PSBT
What does PSBT stand for?
PSBT stands for Partially Signed Bitcoin Transaction.
It is a standardized format for exchanging Bitcoin transactions that aren’t necessarily fully signed yet, along with information needed by participants in the signing process.
Does a PSBT contain Bitcoin?
No.
Bitcoin isn’t stored inside a PSBT file.
The PSBT contains transaction information.
The actual Bitcoin remains represented by UTXOs recorded on the Bitcoin blockchain.
Does a PSBT contain my private key?
A properly constructed PSBT does not need to contain your private key.
The signer uses the private key to create a signature, while the signature can be included in the PSBT.
Can I broadcast a PSBT?
Not directly.
A PSBT must first be completed and converted into a final Bitcoin transaction.
The resulting transaction can then be broadcast.
Can I delete a PSBT after broadcasting?
Once you have successfully extracted and broadcast the transaction, the PSBT may no longer be necessary for that transaction’s broadcast workflow.
However, whether you should keep it depends on your record-keeping needs.
For multisig or accounting purposes, retaining transaction-related information may sometimes be useful.
Can a PSBT be signed more than once?
Yes.
A PSBT can contain multiple signatures when the transaction requires or supports multiple signing participants.
This is especially important for multisig wallets.
Is PSBT the same as multisig?
No.
PSBT is a transaction interchange format.
Multisig is a Bitcoin spending condition requiring multiple authorized signatures.
PSBT is useful for multisig because it provides a convenient way to coordinate those signatures.
Is PSBT safer than a normal Bitcoin transaction?
PSBT and a final Bitcoin transaction serve different purposes.
PSBT can make certain signing workflows safer by separating transaction preparation from private-key signing.
However, safety still depends on the wallet software, signing device, transaction verification, and the user’s actions.
Final Takeaway
If you remember only five things about PSBT, remember these:
1. PSBT stands for Partially Signed Bitcoin Transaction.
2. It is a format for moving Bitcoin transaction information between devices and participants.
3. Private keys do not need to travel with the PSBT.
4. PSBT is especially useful for hardware wallets, multisig, and offline signing.
5. A PSBT eventually needs to be finalized and extracted into a normal Bitcoin transaction before it can be broadcast.
The technology may sound complicated at first, but its purpose is actually straightforward:
Prepare the transaction → share the transaction → verify it → sign it → finalize it → broadcast it.
PSBT provides the standardized bridge that connects those steps.
And as Bitcoin wallets become more sophisticated, understanding that bridge becomes increasingly useful for anyone who wants to understand how modern Bitcoin transactions are created and secured.
