Jupiter swap transaction status, confirmation, and retry conditions
Jupiter swap status checks establish whether a submitted exchange succeeded before you authorize a replacement transaction. Find the original transaction signature, inspect its confirmation level and execution error, and reconcile the recorded output. A timeout, stalled notification, or missing search result leaves the outcome unresolved. After establishing failure or expiry without execution, review the fresh quote and minimum output before authorizing a replacement.
The transaction signature connects the exchange attempt to its network record. Keep that identifier separate from the order identifier and quoted output amount. Each answers a different question about the attempt, especially after a connection drops.
In short: A missing response leaves the swap unresolved until you establish success, failure, or expiry without execution. Expiry requires a validity check alongside reconciliation of the original submission.
Quotes and the execution record
Managed execution obtains a quote and assembled transaction through Jupiter's order flow; custom building returns a quote and swap instructions. The managed path supplies an execution response, while a custom integration must arrange submission and confirmation monitoring. Both paths need an identifiable transaction before a network lookup can resolve the outcome. A fresh quote describes another available exchange; it supplies no evidence about the previous submission.
Does a transaction signature mean the swap succeeded?
No, a transaction signature identifies the signed attempt; success requires an execution result interpreted alongside its confirmation status.
A successful Solana sendTransaction response does not guarantee the network has processed or confirmed the transaction. The node acknowledges receipt without waiting for confirmation. An application can therefore possess a signature while the exchange remains unresolved. Losing the connection during this interval does not establish that submission failed.
The
confirmationStatus
field describes how firmly the network has established the containing block.
processed
reflects a node's processed view, which can roll back.
confirmed
means a supermajority of stake has voted on the block.
finalized
represents the strongest confirmation state. Progress between these levels can be normal; an application waiting for finalization may continue showing an incomplete status after confirmation.
Read the execution error separately. Within an actual status record,
err: null
indicates no transaction execution error. A non-null error indicates failure even when the record says
confirmed
or
finalized. A missing status record carries neither conclusion.
Status checks for an unresolved submission
Different lookup options answer different parts of the same question. An execution response reports the managed attempt, signature queries track network status, and full transaction records expose execution details. A managed response reporting an unknown-outcome error leaves execution unresolved; it does not establish an onchain failure. Choose a lookup based on the information already available.
| Lookup option | Information returned | Required input or condition |
|---|---|---|
| Jupiter managed execution response | Success or failure, error details, and execution amounts when available | The response belonging to the original managed order |
| Recent signature status | Confirmation status and execution error if cached | The exact transaction signature |
| Signature status with history search | Status beyond the recent cache when available | The signature and a node with relevant history |
| Confirmed transaction lookup | Transaction details at confirmed commitment | The signature, confirmation, and compatible version support |
| Finalized transaction lookup | Transaction details at finalized commitment | The signature, a record satisfying finalized commitment, and compatible version support |
| Address signature history | Confirmed signatures involving the supplied account address | An account address referenced by the transaction |
| A lookup must return a matching record before its fields can establish an outcome. | ||
Without history search enabled, getSignatureStatuses searches only the recent signature status cache.
Its
searchTransactionHistory
option extends the search to available history. A null result therefore needs interpretation within the node's search coverage. Repeating a limited lookup cannot establish that an older transaction never executed.
Address history helps recover a missing signature, but its entries require inspection. The newest entry may belong to another action involving the same account. Match its transaction details to the exchange attempt before treating it as the swap record.
Why can a completed swap look missing?
A completed swap can look missing when the lookup uses an incompatible transaction reader, the wrong network, or a confirmation requirement the record has not reached.
Transaction lookup responses
Unsupported transaction version
A client reading a versioned transaction must support its format and declare the appropriate
maxSupportedTransactionVersion. For a version 0 transaction, that setting is
0. An unsupported-version error concerns the reader's request, not the swap's execution. Correcting that request preserves the original signature and avoids authorizing another exchange merely to obtain a readable result.
A valid response containing null
A
getTransaction
response containing
null
means the node did not return a transaction at the requested commitment. This differs from an unsupported-version error. A confirmed record may remain unavailable to a request requiring finalization until that stronger condition holds. The lookup still needs the correct network and access to the record.
Output visibility
A portfolio display does not identify the output as precisely as transaction metadata. Token balance entries distinguish the mint, account, owner, and amount precision. Compare the intended destination and output mint with the recorded changes. Later transfers can also make the current balance differ from the balance immediately after the swap. A display mismatch calls for inspection of those details before another transaction.
When can you submit a fresh swap?
A fresh swap becomes appropriate after the original attempt has a settled failure or has expired without execution, once the cause permits another attempt.
A transaction using an ordinary recent blockhash cannot execute after that blockhash expires.
For this transaction type, compare the network's confirmed block height with the original
lastValidBlockHeight. A height beyond that boundary establishes expiry. It does not establish whether execution happened earlier, so the original signature still needs reconciliation. Durable nonce transactions use different validity rules.
A timeout measures how long the application waited. It does not prove the transaction crossed its validity boundary. If status queries fail or lack the relevant history, keep the attempt unresolved. A replacement could otherwise execute alongside an original transaction whose result the application missed.
For a confirmed execution failure, inspect the reported cause before changing the request. Solana reverts the transaction's instruction changes when an instruction fails, although a network fee can remain. A slippage failure concerns the exchange's output constraint; it does not justify treating every unresolved submission as a slippage problem. Review any replacement quote and minimum output before signing.
Close the attempt with its recorded outcome
Successful closure requires a matching transaction with no execution error at the confirmation level your application requires. Reconcile its input and output with the intended exchange. Jupiter's managed response includes execution amounts; transaction metadata provides account-level detail when the display or reported balance needs further explanation.
Keep the original signature attached to that outcome. A confirmed success awaiting finalization needs continued monitoring if finalization is required. A recorded failure needs a cause-specific correction. If the original transaction remains unaccounted for, the condition for authorizing a replacement has not been established.
Jupiter swap: common questions
Does closing the browser cancel a pending Jupiter swap?
Closing the browser does not cancel a transaction already submitted to the network. The transaction can continue toward execution while the interface is unavailable. Returning to the application may require another status lookup, but closing the tab supplies no evidence of failure or cancellation. Its original signature remains the identifier for checking the outcome.
Can someone move my tokens using the transaction signature I share?
A transaction signature used for lookup does not give someone your private signing key. It does expose the associated public transaction, including participating accounts and recorded activity. Share only the identifier needed to investigate the attempt. A status lookup does not require your recovery phrase, private key, or authorization of a new transaction.
Why does the confirmations field show null for a finalized swap?
A null confirmations count can accompany a finalized transaction and does not by itself indicate failure. Interpret the count alongside confirmationStatus and err in the returned record. This differs from a null result for the entire signature lookup, where the node has returned no status record to interpret.
What does a preflight error tell me about a swap attempt?
A preflight error reports a problem detected before that submission proceeds through the node's normal forwarding path. Preflight includes signature checks and transaction simulation. It differs from an execution error recorded onchain. If the same signed transaction was submitted elsewhere or earlier, the preflight failure does not establish the outcome of those other submissions.
Do different transaction signatures prove I swapped twice?
Different signatures identify different signed transactions, but they do not prove both exchanges succeeded. Each transaction needs its own execution result and confirmation status. Separate successful records showing the intended exchange would establish separate executions. A failed record, an unresolved submission, or another account operation must not count as a second completed swap.
ยท last updated