> ## Documentation Index
> Fetch the complete documentation index at: https://developers.jup.ag/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Execute Order (Ultra)

> Submit a signed Ultra Swap transaction for execution and receive the swap result.

> [!WARNING]
>
> **Ultra Swap API** is no longer actively maintained and has been superseded by [Swap V2](https://developers.jup.ag/docs/swap.md).

After signing the transaction from `/order`, submit it to `POST /ultra/v1/execute` with the `signedTransaction` and `requestId`. Jupiter broadcasts the transaction via its proprietary engine and returns the swap status.

## Sign Transaction

Using the Solana `web3.js@1` library, you can sign the transaction as follows:

For wallet setup details, see [Environment Setup](https://developers.jup.ag/docs/get-started/environment-setup.md).

> [accordion] Set up dependencies and wallet for signing
>
> **Set up dependencies for signing**
>
> ```bash theme={null}
> npm install @solana/web3.js@1
> ```
>
> **Set up Development Wallet**
>
> > [!NOTE]
> >
> > You can paste in your private key for testing but this is not recommended for production.
> >
> > * Either use your private key in the project directly, you can do it via a `.env` file.
> > * Or set up your private key in the [Solana CLI](https://solana.com/docs/intro/installation#create-wallet).
>
> ```javascript Store private key in .env theme={null}
> // In your .env file
> PRIVATE_KEY=""
>
> // In your index.js (or any file that needs the private key)
> import { Keypair } from '@solana/web3.js';
> import dotenv from 'dotenv';
> require('dotenv').config();
>
> const wallet = Keypair.fromSecretKey(bs58.decode(process.env.PRIVATE_KEY || '')));
> ```
>
> ```javascript Store private key in Solana CLI theme={null}
> import { Keypair } from '@solana/web3.js';
> import fs from 'fs';
>
> const privateKeyArray = JSON.parse(fs.readFileSync('/Path/to/.config/solana/id.json', 'utf8').trim());
> const wallet = Keypair.fromSecretKey(new Uint8Array(privateKeyArray));
> ```

Deserialize, sign, and re-serialize the transaction:

```js Sign Transaction theme={null}
import { VersionedTransaction } from '@solana/web3.js';

// ... Get Order's response

// Extract the transaction from the order response
const transactionBase64 = orderResponse.transaction

// Deserialize, sign and serialize the transaction
const transaction = VersionedTransaction.deserialize(Buffer.from(transactionBase64, 'base64'));
transaction.sign([wallet]);
const signedTransaction = Buffer.from(transaction.serialize()).toString('base64');
```

## Execute Order

By making a post request to the `/execute` endpoint, Jupiter executes the swap transaction on behalf of you/your users through our own proprietary transaction sending infrastructure. This already includes handling of slippage, priority fees, transaction landing and more.

To make a post request to execute a swap order, you need to pass in the required parameters,:

* `signedTransaction`: The signed and serialized base64 encodedtransaction [like above](#sign-transaction)
* `requestId`: The order response's request ID [from Get Order](https://developers.jup.ag/docs/ultra/get-order)

Submit the signed transaction to the execute endpoint:

```js Execute Order theme={null}
const executeResponse = await (
    await fetch('https://api.jup.ag/ultra/v1/execute', {
        method: 'POST',
        headers: {
            'Content-Type': 'application/json',
            'x-api-key': 'your-api-key',
        },
        body: JSON.stringify({
            signedTransaction: signedTransaction,
            requestId: orderResponse.requestId,
        }),
    })
).json();
```

## Transaction Status Polling

After our transaction sending service has submitted your swap, we will actively poll for your transaction status as part of the `/execute` endpoint. You will receive a response with the status of the swap.

> [!TIP]
>
> * You can submit with the same `signedTransaction` and `requestId` for **up to 2 minutes regardless of state**, to poll for the transaction status.
> * The transaction will not double execute since it has the same signature.
> * If connection got dropped, you can try again with the same `signedTransaction` and `requestId` to poll for the status of the swap.
> * If there is no status, the order likely expired (did not get processed onchain and failed), but reach out to us if cases like this happen.

Check the execute response status:

```js Transaction Status Polling theme={null}
if (executeResponse.status === "Success") {
    console.log('Swap successful:', JSON.stringify(executeResponse, null, 2));
    console.log(`https://solscan.io/tx/${executeResponse.signature}`);
} else {
    console.error('Swap failed:', JSON.stringify(executeResponse, null, 2));
    console.log(`https://solscan.io/tx/${executeResponse.signature}`);
}
```


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.