Metis Binary alternative, hosted for you
The Metis Binary is the self-hosted version of Jupiter’s swap routing engine, and it needs a Binary Key and your own servers. NoLimitNodes runs a hosted alternative on our own RPC and Yellowstone gRPC that serves the Metis API’s four endpoints, /quote, /swap, /swap-instructions and /program-id-to-label, so you just call a URL.
- Serves the Metis API: /quote, /swap, /swap-instructions and /program-id-to-label
- No Binary Key, no staked JUP and no binary to keep running
- Included in Max and Enterprise, or an add-on for Pro and Ultra
Get it with your plan
Max, swap API included
Also includes HyperShreds and HyperStreams. Bought separately, the three are $750/mo.
- 1Quote. A request reaches the gateway with your key.
- 2Route. The engine splits the swap across venues for the best output.
- 3Transaction. The legs merge into one unsigned transaction for you to sign.
What the Metis Binary is, and what we host instead
One routing engine sits behind most swap integrations on Solana. These are the parts you call.
Jupiter built its swap routing engine and published it as a self-hosted binary, the Swap API V6. From version 7 that engine ships as the Metis Binary from the independent Metis project, and anything written against its HTTP API calls the same four endpoints.
A swap integration asks for a quote, builds a transaction from it, then signs and sends it. The API never sees your private key: it takes a public key and returns an unsigned transaction.
What we host is our own engine, built to the same Metis-compatible HTTP API. It is not the Metis Binary itself, so it does not use a Binary Key.
- GET /quote
Quote
Pick the token pair and amount. You get the best route, the amounts after fees, the price impact and the route plan.
- POST /swap
Build
Send the quote and your public key. You get an unsigned, base64-encoded transaction. Use /swap-instructions instead if you want to compose the transaction yourself.
- you sign
Send
Sign locally and submit through RPC, a Jito bundle or UltraSend. The API never submits for you and never holds a key.
Build a Metis API request, see the call
Change the pair, the amount or any routing option. The URL, the code and the example response follow, so you can see exactly what you would send.
GET https://swap.mainnet.solana.nolimitnodes.com/quote?inputMint=So11111111111111111111111111111111111111112&outputMint=EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v&amount=100000000&slippageBps=50
# 1. Quote
curl -s -H "Authorization: Bearer $NLN_API_KEY" \
"https://swap.mainnet.solana.nolimitnodes.com/quote?inputMint=So11111111111111111111111111111111111111112&outputMint=EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v&amount=100000000&slippageBps=50" > quote.json
# 2. Build the unsigned transaction
curl -s -X POST "https://swap.mainnet.solana.nolimitnodes.com/swap" \
-H "Authorization: Bearer $NLN_API_KEY" -H "Content-Type: application/json" \
-d "$(jq '{userPublicKey:"<YOUR_PUBLIC_KEY>",quoteResponse:.,dynamicComputeUnitLimit:true}' quote.json)"{
"inputMint": "So11111111111111111111111111111111111111112",
"inAmount": "100000000",
"outputMint": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
"outAmount": "…",
"otherAmountThreshold": "…",
"swapMode": "ExactIn",
"slippageBps": 50,
"platformFee": null,
"priceImpactPct": "…",
"routePlan": [
{
"swapInfo": {
"ammKey": "…",
"label": "…",
"inputMint": "So11111111111111111111111111111111111111112",
"outputMint": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
},
"percent": 100
}
],
"contextSlot": "…",
"timeTaken": "…"
}The four Metis API endpoints
The API follows the published Metis request and response shapes, so the parameters you already use keep their names and meanings.
- GET/quote
A route and amounts for a token pair: output amount after fees, price impact, slippage threshold and the route plan.
slippageBps defaults to 50. maxAccounts defaults to 64 and is the lever to pull when a transaction is too large.
Key parameters
- inputMint
- outputMint
- amount
- slippageBps
- swapMode
- dexes
- excludeDexes
- onlyDirectRoutes
- maxAccounts
- platformFeeBps
- forJitoBundle
- asLegacyTransaction
- POST/swap
An unsigned, base64-encoded swap transaction, with the block height it stays valid until.
The request body is the quote plus your public key. Nothing is executed and nothing is signed.
Key parameters
- userPublicKey
- quoteResponse
- wrapAndUnwrapSol
- prioritizationFeeLamports
- dynamicComputeUnitLimit
- feeAccount
- asLegacyTransaction
- destinationTokenAccount
- payer
- POST/swap-instructions
The instructions instead of a transaction: compute budget, setup, swap, cleanup and the address lookup tables to load.
Use it to add your own instructions, a custom payer or a tip, then compile the message yourself.
Key parameters
- userPublicKey
- quoteResponse
- …same body as /swap
- GET/program-id-to-label
A map from program ID to DEX label.
Use the labels in dexes and excludeDexes, and to tell which program a failed transaction touched.
Parameters
None.
What /swap-instructions hands you
The same swap /swap would build, as parts, in the order the documented example composes them. Add your own instructions, load the address lookup tables, compile the message and keep the signed transaction under 1,232 bytes. If it is too big, quote again with a lower maxAccounts.
- 1Compute budgetcomputeBudgetInstructions
- 2SetupsetupInstructions
- 3SwapswapInstruction
- 4CleanupcleanupInstruction
- 5Other, e.g. a Jito tipotherInstructions
Run the Metis Binary yourself, or call ours
Both give you the same four endpoints. The difference is who runs the engine, who feeds it and what it takes to get access.
| Topic | Run the Metis Binary yourself | NoLimitNodes swap API |
|---|---|---|
| What you run | The binary, a Solana RPC and a Yellowstone gRPC feed. Poll mode works without gRPC but is heavy on nodes. | Nothing. You call a URL. |
| What you need to get access | A Binary Key: at least 10,000 JUP staked, and one key for each binary instance. | Your NoLimitNodes API key. |
| Where route data comes from | The RPC and gRPC you provision. | Our own RPC and Yellowstone gRPC. |
| Upgrades | You download new binary versions and restart. | We run and update it. |
| What you pay | Servers, RPC and gRPC, plus the JUP you keep staked. | Included in Max and Enterprise, or $250/mo on Pro and Ultra. |
| Control | Full. You choose the machine, the flags and the config. | Managed. We operate it, and you tune requests with the same parameters. |
Metis Binary access details are taken from its public documentation at the time of writing and can change.
How it is wired
Your app talks to our gateway. The engine behind it reads pool and account state from our own nodes, so route data comes from infrastructure we run.
- 1
Your app
Calls /quote and /swap with your NoLimitNodes key.
- 2
NoLimitNodes gateway
Authenticates the key and enforces your plan.
- 3
Swap engine
Routes, quotes and builds the transaction.
- 4
RPC and Yellowstone gRPC
Pool and account state from our own nodes.
You sign and send separately, through RPC, a Jito bundle or UltraSend. The API takes a public key and never sees a private key.
Venues it routes through
Call /program-id-to-label for the live map. Need a venue that is not listed? Ask sales.
- Orca WhirlpoolConcentrated-liquidity pools
- Raydium CPMMConstant-product pools
Included with Max and Enterprise
Take the plan that includes it, or add it to the one you have.
On Pro and Ultra the add-on is $250/mo.
Pro$49/mo
+$250/moAdd it to Pro, or move up to Max and get it included.
Ultra$199/mo
+$250/moAdd it to Ultra, or move to Max and get it included.
Max$300/mo
IncludedAlso includes HyperShreds and HyperStreams, and higher limits than Ultra.
Enterprise$500/mo
IncludedA dedicated cluster, a named support engineer and a committed SLA.
Start in three steps
- 1
Choose how you get it
Take Max or Enterprise and it is included automatically, or add it to Pro or Ultra for $250/mo.
- 2
It turns on with your plan
The swap API is enabled on your account, and you call it with your NoLimitNodes API key.
- 3
Call it
Quote, build, sign locally and send. Point an existing Metis-style client at the new base URL.
Moving from a Metis or Jupiter swap API client
Four things change. Everything else in your integration stays as it is.
- Base URL
- Change it to your NoLimitNodes endpoint.
- Auth
- Add your NoLimitNodes API key. No Binary Key.
- Requests
- Keep the same query parameters and request bodies.
- Venues
- Check the venues you route through against the coverage list.
removed: const base = "http://127.0.0.1:8080" // your Metis Binaryadded: const base = "https://swap.mainnet.solana.nolimitnodes.com"added: const headers = { Authorization: `Bearer ${process.env.NLN_API_KEY}` }removed: const quote = await fetch(`${base}/quote?${params}`).then(r => r.json())added: const quote = await fetch(`${base}/quote?${params}`, { headers }).then(r => r.json())// request parameters, bodies and responses stay the same
Metis Binary alternative: questions
Not here? Email [email protected] or talk to sales.
What is the Metis Binary?
The Metis Binary is the self-hosted swap routing engine behind Jupiter’s swap API. It began as the Swap API V6 and has shipped from the independent Metis project since version 7. You run it on your own server with your own RPC, and it serves four HTTP endpoints: GET /quote, POST /swap, POST /swap-instructions and GET /program-id-to-label. Access needs a Binary Key.
Is there a hosted alternative to the Metis Binary?
Yes. NoLimitNodes hosts its own engine, built to the same Metis-compatible HTTP API, on our own RPC and Yellowstone gRPC. It is not the Metis Binary itself and it does not use a Binary Key. You authenticate with your NoLimitNodes API key and call a URL instead of running a binary.
Do I need a Binary Key or staked JUP?
No. Running the Metis Binary needs a Binary Key tied to at least 10,000 staked JUP, with one key for each instance. Our API does not use Metis keys. You authenticate with your NoLimitNodes API key.
Can I point my existing Metis or Jupiter swap API client at it?
If your client calls /quote, /swap, /swap-instructions or /program-id-to-label, change the base URL and send your NoLimitNodes key. Keep your query parameters and request bodies. Check the venues you route through against the coverage list first, because a quote can only use venues the engine supports.
Which DEXs does it route through?
The coverage list on this page shows the venues the engine routes through today. Call /program-id-to-label for the live map of program IDs to labels. If you need a venue that is not listed, ask sales and we will say whether it is planned.
How much does it cost?
It is included in Max ($300/mo) and Enterprise ($500/mo). On Pro and Ultra it is an add-on for $250/mo, or $2,500/yr with two months free.
Do you see my private keys?
No. The API takes your public key and returns an unsigned transaction. You sign it locally and send it yourself, through RPC, a Jito bundle or UltraSend.
How do I send the transaction?
Decode swapTransaction from base64, sign it, and submit the bytes. You can use RPC, a Jito bundle or UltraSend, which forwards your signed transaction unchanged for 0.0002 SOL per accepted submission. Check confirmation separately: a returned signature does not prove the swap succeeded.
How fast are quotes?
It depends on the pair, the route depth and maxAccounts. Every quote response carries timeTaken and contextSlot, so you can measure it on your own traffic. The engine reads pool state from our own RPC and Yellowstone gRPC.
What if my transaction is too large?
Solana caps a serialized transaction at 1,232 bytes. Quote again with a lower maxAccounts and rebuild, or use /swap-instructions and compose the message yourself with address lookup tables. A lower maxAccounts can change the route.
Included with Max. $250/mo on Pro and Ultra.
Take the plan that includes it, or add it to the one you have.
Questions first? Email [email protected] or talk to sales.