How to Build a Jito MEV Bundle Bot with CoinMarketCap API

Introduction

On Solana, execution is fast. Competition is faster.

Jito enables bundle-based submission so you can compete for block inclusion with atomic, ordered transactions.

The hard part is deciding when a bundle is worth sending.

CoinMarketCap API helps you discover opportunities, validate liquidity, and filter risk before you commit a bundle.

• CoinMarketCap API powers the signal layer (off-chain)
• Jito handles bundle submission and auction-based execution (on-chain)

Why Combine CoinMarketCap and Jito?

Jito optimizes execution. CoinMarketCap improves decision quality.

CoinMarketCap API Provides

• DEX-native pricing (on-chain sources)
• liquidity and volume
• pool-level reserves
• transaction activity
• anomaly and risk signals

Jito Provides

• bundle submission (up to 5 transactions)
• atomic execution within a slot
• auction-based inclusion via tips
• execution ordering guarantees

System Architecture

CoinMarketCap API (Signal Layer)

├─ Discovery (new / trending / movers)

├─ Price and Volume

├─ Liquidity Validation

├─ Activity Analysis

└─ Risk Filters

↓

Opportunity Engine

↓

Jito Bundle Builder

↓

Jito Block Engine

↓

On-chain Execution (Solana)

Step 1 Discover Solana Opportunities

Use DEX discovery endpoints (POST with JSON body):

• /v1/dex/new/list
• /v1/dex/meme/list
• /v1/dex/tokens/trending/list
• /v1/dex/gainer-loser/list

⚠️ API Plan Requirement

Most discovery endpoints under /v1/dex/* use POST and may require a paid plan (Startup or higher). Always validate your plan access before building automated discovery pipelines.

HTTP 403 Forbidden

Error 1006: Plan Not Authorized

Attempting to call these endpoints with a Free (Basic) plan will result in the error above.

Solana Filter (POST endpoints)

Use platformIds to target Solana.

Step 2 Identify Active Pairs

Find active pairs with liquidity and volume.

Endpoint:

/v4/dex/spot-pairs/latest

Required parameters:

params = {

"network_slug": "solana",

"base_asset_contract_address": "<token_address>",

"dex_slug": "raydium"  # optional filter

}

Key fields:

• price
• liquidity
• volume_24h
• dex_slug

Note:

This endpoint does not return spreads directly. You must group by token and compare price across different dex_slug values.

Step 3 Validate Liquidity and Reserves

Not every spread is executable.

Endpoint:

/v4/dex/pairs/quotes/latest

Example:

params = {

"contract_address": pool_address,

"aux": "pool_base_asset,pool_quote_asset,buy_tax,sell_tax"

}

Key fields:

• pool_base_asset
• pool_quote_asset
• liquidity

These represent the real reserves used to estimate slippage.

Taxes (buy_tax, sell_tax) are included when available.

Step 4 Detect Activity and Flow

Use transaction data to detect real movement.

Endpoint:

/v1/dex/tokens/transactions

Example filters:

params = {

"platform": "solana",

"minVolume": 10000

}

Metrics:

• num_transactions_24h
• large swaps (via minVolume)

Use this as a flow signal before sending a bundle.

Note:

This endpoint is best used for flow inspection (large swaps and activity spikes). Aggregated 24h transaction counts should be sourced from pair-level endpoints when available.

Step 5 Filter Risk and Anomalies

Avoid unstable or manipulated pools.

Liquidity Events

/v1/dex/liquidity-change/list

Avoid pools with sudden liquidity removal.

Contract Risk

/v1/dex/security/detail

⚠️ Endpoint parameters and coverage may vary depending on network and token type. Always validate against the latest CoinMarketCap documentation before production use.

Detect:

• honeypots
• transfer restrictions
• hidden taxes

Step 6 Decide If the Opportunity Is Bundle-Worthy

Not every spread should trigger a bundle.

Evaluate:

• price difference across DEXs
• slippage from pool reserves
• expected execution size
• transaction fees
• competition risk

Important:

CoinMarketCap data updates roughly every 60 seconds.

Jito bundles compete within sub-second slots.

Use CoinMarketCap as a signal filter, not a timing trigger.

Not every opportunity identified by CoinMarketCap is MEV-executable via Jito. Bundle inclusion depends on competition, tip size, and intra-slot price changes.

Step 7 Build the Bundle

A Jito bundle contains up to 5 transactions.

Typical structure:

• Swap on DEX A
• Swap on DEX B
• Profit capture

Constraints:

• all transactions execute sequentially
• all must succeed or none execute
• must fit in the same slot

Step 8 Add Tip and Submit to Jito

Bundles must include a tip to be considered.

Process:

• Select a tip account
• Attach lamports tip
• Submit bundle

Notes:

• minimum tip exists but is often not competitive
• higher-value opportunities require higher tips
• bundle returns a bundle_id

This does not guarantee inclusion.

Step 9 Track Bundle Status

After submission, monitor execution.

Track:

• landed vs failed bundles
• execution price vs expected
• latency and slot timing

Retry logic may be required for failed attempts.

Step 10 Backtest and Refine

Use historical data to refine thresholds.

Endpoint:

/v4/dex/pairs/ohlcv/historical

Parameters:

• contract_address
• network_slug
• interval (1m, 5m, 15m)
• time_start
• time_end

⚠️ Validate pair availability and parameter constraints. Some requests may return errors due to data availability or strict requirements. Implement retry logic and fallback to alternative historical endpoints when needed.

Rate Limit Strategy

CoinMarketCap API is REST-only.

Best practices:

• poll every 30–60 seconds
• batch requests
• cache responses
• use exponential backoff

Do not poll aggressively. Data refreshes on a 60s cadence.

Common Mistakes

Treating CMC as Execution Timing Feed

CoinMarketCap identifies opportunities. It does not provide execution timing.

Ignoring Competition

Other bundles compete for the same opportunity.

Underestimating Tip Requirements

Low tips reduce inclusion probability.

Skipping Liquidity Validation

Shallow pools destroy expected profit.

Not Grouping Pairs Correctly

Spreads must be computed across DEXs for the same asset.

Final Thoughts

A strong Jito MEV bot is selective, not reactive.

CoinMarketCap API helps you filter the market and identify high-quality opportunities.

Jito gives you the execution layer to compete for block inclusion.

Together, they enable a structured approach to MEV on Solana.

Next Steps

• improve opportunity ranking models
• simulate bundle profitability
• tune tip strategies
• monitor bundle success rates

Better filtering leads to better bundles!