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

# Gasless Swaps

> Let users swap without holding SOL for transaction fees

Gasless swaps let users trade without holding SOL for transaction fees. On `/order`, the `gasless: true` response field can be set by three independent paths:

1. **Automatic Jupiter sponsorship:** Jupiter covers gas and token account rent when the taker has low SOL.
2. **JupiterZ market maker:** an RFQ market maker pays signature and priority fees directly.
3. **Integrator payer:** your wallet covers gas via the `payer` parameter.

To identify which path fired on any quote, compare `signatureFeePayer` to the `taker`:

| `signatureFeePayer` value                     | Source                                   |
| --------------------------------------------- | ---------------------------------------- |
| Equal to `taker`                              | Not gasless, taker pays                  |
| `gasTzr94Pmp4Gf8vknQnqxeYxdgwFjbgdJa4msYRpnB` | Automatic Jupiter sponsorship            |
| Equal to your `payer` parameter               | Integrator-sponsored gas                 |
| Any other address                             | JupiterZ market maker (varies per quote) |

## Types of gas costs

Solana transactions can incur four types of gas costs:

1. **Base network transaction fee** (signature fee)
2. **Associated token account (ATA) rent** for new token accounts
3. **Priority fee** (or tips for Jito, etc.)
4. **Other account rent** (some DEXes require additional accounts of the taker, e.g. Pump.fun)

## How to opt out of gasless

The most reliable check is `signatureFeePayer == taker` on every `/order` response. Drop any quote where they differ. This catches all three gasless paths and survives future changes to routing.

You can also reduce gasless quotes upstream by passing `excludeRouters=jupiterz`. This blocks the JupiterZ RFQ path, which is the most common source of gasless quotes. It is not a complete opt-out on its own: if the taker has less than 0.01 SOL on a trade of about \$10 or more, automatic Jupiter sponsorship still fires through Metis with `signatureFeePayer = gasTzr94Pmp4Gf8vknQnqxeYxdgwFjbgdJa4msYRpnB`. The `signatureFeePayer` check catches both cases.

## Automatic gasless (`/order`)

Jupiter automatically covers gas costs when the taker lacks SOL.

**When it applies:**

* Taker has less than 0.01 SOL
* Minimum trade size of \~\$10 (dynamic, varies with current priority fee market)
* A JupiterZ market maker is not winning the quote, and integrator `payer` is not set

**What it covers:** all four gas types (signature fee, priority fee, ATA rent, other account rent).

**How it works:**

* Jupiter calculates the required SOL to cover gas and increases the swap fee. The taker receives less output tokens. The top-level `feeBps` field reflects this increased total fee, while `platformFee.feeBps` only reflects the Jupiter platform fee.
* The sponsor wallet `gasTzr94Pmp4Gf8vknQnqxeYxdgwFjbgdJa4msYRpnB` is added as a secondary signer and is returned as the `signatureFeePayer`, `prioritizationFeePayer`, and `rentFeePayer` in the response.

**Limitations:**

* Does not fire when `payer` is set to a wallet other than the taker (integrator payer takes over instead)
* Does not fire when `referralAccount` and `referralFee` are set

## JupiterZ gasless (`/order`)

When a JupiterZ (RFQ) market maker wins the quote on `/order`, the market maker pays network and priority fees directly. Output token account rent is separate: when referral fees are not set, Jupiter's gas wallet (`gasTzr94Pmp4Gf8vknQnqxeYxdgwFjbgdJa4msYRpnB`) can pay the rent to create the taker's output token account. With referral fees, the taker pays output token account rent.

**When it applies:**

* Taker trades a pair the market makers are willing to quote
* `payer` is not set

**What it covers:** signature fee and priority fee. Output token account rent can be covered by Jupiter's gas wallet when referral fees are not set.

**How it works:**

* The order transaction includes a secondary signer for the market maker
* Jupiter sets the gas payer to the MM signer and on `/execute`, your partially signed transaction is sent to the MM for them to co-sign and execute
* If the taker's output token account is not yet initialised and referral fees are not set, Jupiter's gas wallet (`gasTzr94Pmp4Gf8vknQnqxeYxdgwFjbgdJa4msYRpnB`) can pay the rent to create it
* The `signatureFeePayer` is the MM's address. MM addresses vary per quote, so do not hardcode against a single address. Use the `signatureFeePayer != taker` check instead.

**Limitations:**

* Does not fire when `payer` is set
* With `referralAccount` and `referralFee`, JupiterZ can still quote and execute, but the taker must have enough SOL for any required output token account rent

## Integrator payer

Integrators can cover all gas costs on behalf of their users by passing the `payer` parameter. This works on both `/order` and `/build`.

<Note>
  `payer` only activates when set to a wallet different from `taker`. Setting `payer=taker` has no effect. The request behaves as if no `payer` was provided.
</Note>

### On `/order`

Pass `payer` to cover all gas-related fees. The transaction requires both taker and payer signatures.

<Note>
  This needs to be used together with referral parameters (`referralAccount` and `referralFee`) because it is assumed that you will be taking fees to recoup the costs spent on gas.
</Note>

```typescript theme={null}
const params = new URLSearchParams({
  inputMint: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v", // USDC
  outputMint: "So11111111111111111111111111111111111111112",     // SOL
  amount: "1000000",
  taker: userWallet,
  payer: integratorPayerWallet,
});

const response = await fetch(
  `https://api.jup.ag/swap/v2/order?${params}`,
  { headers: { "x-api-key": API_KEY } }
);
```

The returned transaction needs two signatures (taker + payer) before sending to `/execute`.

**What it covers:** all four gas types.

**How it works:**

* Regardless of how much SOL the taker has, the payer covers all fees
* Temporary wSOL ATA rent is covered by the payer and returned in the same transaction
* Other ATAs are covered by the payer but not returned (they hold tokens post-swap)
* Routes through Metis only

### On `/build`

Pass `payer` to change the fee payer on all returned instructions. The payer address replaces the default `taker` as the fee payer for the transaction.

```typescript theme={null}
const params = new URLSearchParams({
  inputMint: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
  outputMint: "So11111111111111111111111111111111111111112",
  amount: "1000000",
  taker: userWallet,
  payer: integratorPayerWallet,
});

const response = await fetch(
  `https://api.jup.ag/swap/v2/build?${params}`,
  { headers: { "x-api-key": API_KEY } }
);
```

The returned instructions will have fee payer accounts set to the `payer` address. You are responsible for building the transaction, collecting both signatures (taker + payer), and sending via your own RPC.

<Tip>
  1. When using `payer` on `/build`, do note that your gas payer is not only paying for gas, it is paying for transaction fee, priority fee/tip, token accounts, or any other AMM related accounts that might be required.

  2. The token accounts or AMM related accounts can be closed by the user. If you do not find ways to recoup the fees you spent for the user, it may be gameable where they always close their accounts and you have to fund them again.

  Hence, when you are the gas payer, ensure that you account for these and find ways to recoup the cost spent to ensure your gas payer is not drained.
</Tip>

## Related

* [Order & Execute](/swap/order-and-execute) for the default swap flow
* [Build](/swap/build) for full transaction control
* [Routing impact matrix](/swap/order-and-execute#routing-impact-matrix) for how `payer` affects routing
* [Fees](/swap/order-and-execute#fees) for how gasless affects the fee calculation