Build Swaps on Pump.fun, Raydium & More

Build Solana swaps on Pump.fun, Pumpswap, Raydium, Meteora, Sanctum and more with direct protocol routing, fallback coverage and protocol-level control.

If you are building a Solana swap product, protocol coverage is not just a nice feature. It changes what your app can actually execute, what token lifecycles you can support and how much routing logic you can keep under your own control. Vybe’s Supported Protocols guide is useful for exactly that reason: it maps out the venues the router can hit directly, the protocol identifiers you can force and the fallback path when no direct route is available.

The docs list direct integrations for Raydium AMM V4, Raydium CPMM, Raydium CLMM, Raydium LaunchLab, Meteora DLMM, Meteora DBC, Meteora DAMM2, Pumpfun, Pumpswap and Sanctum. They also explain that direct routing can fall back to Titan and Jupiter when no direct route exists.

Try the live demo: https://solana-swap-api.vybenetwork.com

Why supported protocols matter

Different protocols are good at different things. The Supported Protocols page explains that concentrated liquidity venues like Raydium CLMM are suited to major pairs and tighter spreads, bonding-curve venues like Pumpfun, Raydium LaunchLab and Meteora DBC are tied to launch-phase tokens, Pumpswap handles post-migration Pumpfun tokens and Sanctum specializes in liquid staking token swaps.

That means protocol support directly affects whether your product can handle:

• launch-phase memecoin trading
• post-migration token trading
• large liquid pairs
• dynamic liquidity pools
• LST-to-LST swaps

This is why a Solana swap API is not just about returning a transaction. It is also about venue coverage and execution policy.

Why direct integrations matter

Vybe’s docs are explicit about the advantages of direct DEX calls. When the router hits a protocol directly instead of going through an aggregator, the docs say you get fewer instructions, smaller transaction size, no intermediary accounts, cleaner fee handling and faster confirmation. The trade-off is that direct integrations cover fewer pairs than aggregators, which is why fallback exists.

That is also consistent with the broader Swap Overview, which frames Vybe’s direct router as the efficient first path before falling back when necessary.

In practice, direct integration matters when you care about:

• better transaction efficiency
• lower instruction overhead
• fewer temp or intermediary accounts
• cleaner route debugging
• more predictable venue behavior

Protocol families and what they are good for

The Supported Protocols guide is strong because it does not just list names. It gives enough context to understand the role of each venue family.

Raydium AMM V4 and Raydium CPMM cover more traditional AMM behavior, while Raydium CLMM is the concentrated-liquidity path for major pairs and tighter spreads. Raydium LaunchLab is for bonding-curve token launches.

Meteora DLMM is positioned for adaptive liquidity, Meteora DBC for dynamic bonding-curve launches and Meteora DAMM2 for general-purpose swaps.

Pumpfun and Pumpswap are split by token lifecycle: Pumpfun before graduation, Pumpswap after migration. Sanctum is built for LST-to-LST paths such as mSOL, jitoSOL and bSOL swaps.

This is why protocol support is really a map of what kinds of swaps your product can support at each stage of a token’s lifecycle.

Force a specific protocol when you need venue control

One of the best parts of the docs is that Vybe does not force everything through black-box routing. The Supported Protocols page explains that you can override automatic routing with the protocol parameter and optionally narrow further with a pool address. Use protocol alone to let Vybe find the best pool on that venue, or use protocol plus pool when you want exact routing control.

The docs specifically call out several use cases for forced routing: testing specific pools, avoiding certain DEXs, comparing execution by venue, targeting known liquidity and debugging route issues.

That makes forced protocol selection useful for:

• trading UIs with venue preference
• bots that want deterministic behavior
• treasury tools that need exact pool targeting
• debugging and benchmarking different venues

And because the actual execution still runs through the Build Swap endpoint, this control is part of the real product flow, not just an internal debug feature.

Where this fits in the swap flow

Protocol support is only one layer of the broader execution path. The standard pattern is still:

1. fetch a quote
2. inspect the route
3. build the transaction
4. sign client-side
5. submit onchain

Vybe’s Swap Overview, Fetch Quotes & Routes, Build Transaction, quote endpoint reference and swap build endpoint reference all fit together here. So if this article is meant to be actionable, it should naturally link readers into:

• Supported Protocols
• Swap Overview
• Fetch Quotes & Routes
• Build Transaction
• Fetch Quote API Reference
• Build Swap API Reference

Router behaviour matters just as much as protocol coverage

Vybe’s docs describe three router modes: Vybe, Titan and Jupiter. The Supported Protocols page explains fallback in order: direct Vybe first, then Titan, then Jupiter, unless you explicitly disable fallback with vybeOnly: true.

That distinction matters because protocol coverage and router behavior solve different problems:

• supported protocols — define where you can route directly
• router mode — defines your coverage-versus-efficiency policy
• fallback behavior — defines what happens when direct routing fails

For a serious swap product, those are product decisions, not just infra details.

Why this matters for product and engineering teams

For product teams, protocol support is about coverage. It determines whether your app can support launch tokens, memecoin lifecycle transitions, liquid majors, LST swaps and dynamic AMM paths without breaking UX.

For engineering teams, protocol support is about execution policy. It determines whether you let the router choose automatically, force a venue, lock a pool, benchmark a route, or disable fallback entirely. The Supported Protocols guide makes it clear that protocol, pool, router choice and fallback mode can all be part of the flow design.

That is why builders search for terms like:

• build swaps for Pump.fun
• Raydium swap API
• Meteora swap API
• Sanctum swap integration
• Solana swap API supported protocols
• force protocol routing on Solana

Final takeaway

If you are building on Solana, supported protocols are not a background detail. They determine which swaps your product can execute directly, how much venue control you have and when you need aggregator fallback.

That is why the Supported Protocols page matters. It is not just a compatibility list. It is a practical guide to what your swap stack can do across Pumpfun, Pumpswap, Raydium, Meteora, Sanctum and router fallback behavior.

Further reading

Guides

• https://docs.vybenetwork.com/docs/swap-overview
• https://docs.vybenetwork.com/docs/get-quote
• https://docs.vybenetwork.com/docs/build-transaction
• https://docs.vybenetwork.com/docs/slippage-fees
• https://docs.vybenetwork.com/docs/supported-protocols
• https://docs.vybenetwork.com/docs/gasless-mode
• https://docs.vybenetwork.com/docs/privy-integration

API reference

• https://docs.vybenetwork.com/reference/get_swap_quote_proxy
• https://docs.vybenetwork.com/reference/do_swap_proxy