Solana Sniper Bot GitHub: 7 Best Open-Source Bots (2025)

In the 2024–2025 meme-coin supercycle, a new token launched on Solana's Pump.fun or Raydium almost every minute. Some of those tokens turned $50 into $50,000 inside a day. Most went to zero in under an hour.

The problem? Human hands are too slow.

By the time you see a token on Twitter, copy the contract address, open your wallet, and confirm the transaction, the "smart money" — automated bots — has already purchased the entire initial float and is selling into your buy order. This is where a Solana crypto sniper bot on GitHub enters the picture.

A sniper bot is an algorithmic trading script that monitors Solana's mempool and DEX pools in real time, then fires a buy transaction the moment liquidity is added. When executed correctly, it places you in the top 0.1% of buyers for any token launch.

But here is the uncomfortable truth: the open-source ecosystem for these bots is a minefield. Every week, thousands of traders search GitHub for "Solana sniper bot" and stumble into repositories with malicious code. They run the bot with their main wallet, and within minutes every SOL is swept into an anonymous address.

This guide is designed to be the definitive resource on the subject. It covers:

• How sniper bots work at a technical level.
• The 7 most legitimate open-source sniper bot categories on GitHub.
• A framework for auditing any bot's code before you touch it.
• A complete deployment walkthrough.
• Strategies that actually move the needle on profitability.

A Solana crypto sniper bot is a programmatic trading client that connects to the Solana blockchain and executes purchases of tokens at the earliest possible moment after they become tradable. The term "sniper" originates from the strategy of "sniping" the first block of a token's trading life.

H3: The Core Mechanics

At its simplest, a sniper bot performs four actions in a continuous loop:

1. Monitor: Listen to the Solana blockchain for new liquidity pool (LP) creations or new mint events via WebSocket subscriptions to RPC nodes.
2. Evaluate: Score token metadata — liquidity amount, mint authority, freeze authority, top holder concentration, known rug-pull signatures.
3. Execute: Submit a swap transaction through a DEX aggregator (like Jupiter) or a direct pool (like Raydium's initialize + swap instructions).
4. Sell: Optionally, a Sell/Take-Profit module monitors price action and closes positions.

H3: Why Solana, Specifically?

Solana's architecture makes it uniquely suited for sniping:

Solana's 400ms block slots and sub-second finality mean that snipers can enter and exit positions in a span that would be impossible on legacy chains. Add the low transaction fee environment (fractions of a penny), and you get an ecosystem where bots can execute dozens of attempts without destroying their profit margin.

There is a simple reason most Solana sniper bots live on GitHub: trust through transparency. In a space rife with exit scams, code you can audit is the only real protection.

H3: The Open-Source Advantage

• Auditability: Every line is public — if a repo has 500 stars and active PRs, the community has already reviewed the core logic.
• No upfront cost: Most trading bot SaaS platforms charge 0.5–2% of trade volume or 100–500 SOL/month for premium sniping services. Open-source repos are usually free.
• Customizability: You can modify entry fees, slippage curves, or even the scoring model via your own ML algorithms.

H3: The Open-Source Danger

The same transparency that makes GitHub attractive also makes it a hunting ground for malicious actors. A 2024 analysis of GitHub's "solana sniper" topic found that the vast majority of new repositories tagged with this keyword contained suspicious patterns: encoded private keys, hidden curl callbacks to external servers, and function names obfuscated via Base64.

We will address how to identify these traps later — but first, let's understand how these bots actually operate under the hood.

If you are going to run a sniper bot, you need to understand what happens between the moment a developer creates a token and the moment your bot receives it.

H3: The Lifecycle of a New Token on Solana

Solana tokens traded on Raydium and Pump.fun typically go through this sequence:

1. Create Token: A dev uses the Metaplex protocol to create a mint.
2. Initialize Pool: The dev adds SOL + token supply to a liquidity pool on Raydium (or launches directly on Pump.fun).
3. Add Liquidity: The Solana program emits a log event containing the new pool's public key.
4. Open Book Market: The pool becomes tradable, but only if an OpenBook/Tradao market ID is linked.
5. Tradable: The token appears on DEX interfaces.

A sniper bot must capture step 3 and execute a buy before the token reaches step 5 on any public interface. That means the bot's latency is the single most important factor.

H3: The Three Infrastructure Layers

Layer 1: RPC Nodes

The bot requires an unthrottled, low-latency connection to Solana. Public RPC endpoints are useless for sniping — they rate-limit and lag behind the chain. Professional snipers use:

• Helius Nodes in regions adjacent to major validators.
• Triton One node infrastructure.
• Self-hosted Solana validators with transaction forwarding enabled.

Latency reduction is measured in milliseconds. A bot connected to a node in the AWS us-east-1 region will consistently lose to one connected to a node in the same data center as the validator proposing the next block.

Layer 2: Jito Bundles (MEV Infrastructure)

Jito is Solana's MEV (Maximal Extractable Value) infrastructure. It allows traders to submit "bundles" — an ordered set of transactions — directly to validators via an auction mechanism. This bypasses the public mempool entirely.

For sniping, a Jito bundle works like this:

• Transaction 1: Buy the token immediately after initialize.
• Transaction 2: Sell at a predetermined profit target.

Because the bundle is processed atomically, you guarantee your entry AND your exit in the same block. This eliminates the "steamroll" risk where a whale dumps on you before your sell lands.

Layer 3: DEX Aggregation Programs

Most open-source sniper bots execute swaps via Jupiter's API or directly via Raydium SDK. The key difference:

Before the list: a necessary disclaimer. The GitHub "sniper bot" ecosystem changes weekly. Many repositories are renamed, deleted, or replaced with copycat forks. Do not trust a repo just because it is listed here — verify it live. Instead, use this list as a taxonomy of what good open-source sniping looks like.

H3: 1. Raydium Sniper Bots (Direct Pool Sniping)

The most common category — TypeScript/Node.js scripts that listen to Raydium's InitializeMarket events and execute a sendTransaction to swap into the new pool.

Typical features: custom slippage, gas fee priority, max buy amount, auto-sell percentage, and basic Honeypot-token detection.

Reminder: Popular forks (e.g., "solana-sniper-bot" with thousands of stars) are frequently forked from a vulnerable base. Search for the most recent commit date — if it has not been updated in 12+ months, the Solana RPC API changes will likely break it.

H3: 2. Pump.fun Sniper Bots (Bonding Curve Sniping)

Pump.fun created a new mechanics challenge: tokens trade on a bonding curve before they graduate to Raydium. Bots in this niche monitor Pump.fun's program logs for newly created mints and buy the token in the first few tokens on the curve.

One advantage: Pump.fun token creation is deterministic — bots can predict the exact token mint address before the transaction lands.

H3: 3. Jupiter API-Based Sniper Bots (Router Sniping)

These bots call Jupiter's /quote and /swap endpoints. They're slower than direct pool sniping but benefit from Jupiter taking into account all liquidity. If a launch has simultaneous liquidity on Raydium and Orca, a Jupiter-based bot executes the best-yield route.

H3: 4. Jito Bundle Sniper Scripts (Pro-Level)

Not stand-alone bots, but integration layers that wrap all of the above with Jito's jito-ts SDK. These scripts construct an atomic "buy + sell" bundle and submit it via Jito's block engine. Require Node.js fluency.

H3: 5. MEV Detection & Sandwich Bots

Technically distinct from token sniping, MEV snipers target large pending transactions. For the purpose of this guide, we include them because many GitHub repositories combine both strategies. Caution: MEV sniping on Solana is capital-intensive and high-risk; most newcomers lose more in failed transactions than they gain in profitable sandwiches.

H3: 6. Telegram-Triggered Sniper Wrappers

Many popular repos are not standalone bots but bridges between a Telegram token-alert channel and a Solana swap service. The advantage is that you get a human-curated signal; the disadvantage is that the latency of receiving a Telegram message (1–3 seconds) already means you are late to the launch.

H3: 7. Rust-Based Tipping & Bundle Auction Tools (Advanced)

The very top end of open-source SNIPING on GitHub consists of Rust crates that interact directly with Solana's runtime and Jito's block engine for maximum control over transaction headers. Only advanced Rust developers should attempt this route.

H3: Comparison Table of Main Bot Categories

*Latency estimates include RPC propagation and confirmation. Actual performance varies with network congestion and geography.

This is the single most important section in this guide. Running an unaudited bot is the crypto equivalent of installing a keylogger to "see how cybersecurity works."

H3: The 3-File Security Audit Framework

You do not need to read every file in a GitHub repo. Attackers almost always hide malicious logic in three places. Audit these three things — that is sufficient to eliminate the most common threats.

1. The config.json / .env File

Look at where the script reads your private key. Legitimate bots read a private key from an environment variable or a local .gitignore-protected file. Red flags any hard-coded private key, a privateKey field that can be accessed remotely, or config options like telegramToken that contain a webhook URL. An attacker can exfiltrate your key through a Telegram message.

2. The Main Script (index.js, main.py, bot.ts)

• Search for curl or axios calls to domains that are not official Solana endpoints. If a bot sends your wallet address or signature to an unknown URL, that's a reverse-connection backdoor.
• Search for eval() — a classic obfuscation technique used to hide malicious code at runtime.
• Search for Base64 strings longer than 20 characters. Decode them. If you see a Solana private key literal, the repo is a trap.

3. The package.json / requirements.txt Dependency List

Attackers often publish a legitimate-looking bot and hide the backdoor in a NPM package dependency. Use npm audit or pip-audit to check for known vulnerabilities. But more importantly: check if the dependency is a typosquat. A package named solana-web3-js (with dashes) instead of @solana/web3.js (with slash) is a scam.

H3: The 24-Hour Rule

Once you audit the code, do not run it with real funds. Create a fresh Solana wallet, deposit 0.1 SOL, and run the bot on a live but worthless token. Observe:

• Does the wallet balance leave the wallet after a failed transaction?
• Does the script emit unexpected log output?
• Does it attempt outbound network connections you can detect via a packet sniffer like Wireshark?

If the test-bot survives 24 hours without losing its allowance, you can consider deploying with limited capital.

Let's walk through the standard deployment process for a TypeScript-based Raydium sniper bot on a Linux VPS. This assumes you have basic command-line fluency.

H3: Prerequisites

• A VPS with 2GB RAM, 2 cores, and 50GB SSD. (AWS Lightsail, Hetzner, or DigitalOcean.)
• Node.js v18+ and npm installed.
• A funded Solana wallet (at least 1 SOL for fees and initial buys).
• An RPC provider with WebSocket support. (Helius or Triton; free tiers are acceptable for testing only.)

H3: Step 1 — Choose an RPC Provider

Open-source bots typically read an RPC_URL from a config file. Set up your Helius endpoint at heluis.io or your preferred provider. For sniping, buy the developer tier at a minimum; public endpoints will throttle you at exactly the wrong moment.

H3: Step 2 — Clone the Repository

git clone https://github.com/<user>/<repo>.git
cd <repo>

Immediately after cloning, disconnect the repo from the remote: git remote remove origin. This reduces the risk of a compromised repo pushing an update directly to your local machine.

H3: Step 3 — Review the Files

Run the audit every time, before installing dependencies:

grep -r "private" --include="*.js" --include="*.ts" .
grep -r "curl" --include="*.js" --include="*.ts" .
grep -r "eval(" --include="*.js" .

H3: Step 4 — Install Dependencies

npm install

If npm install triggers any pre-install scripts that attempt network connections, terminate the process. Malicious packages often embed payloads in the preinstall lifecycle hook.

H3: Step 5 — Configure the Wallet

Create a new Solana keypair specifically for sniping:

solana-keygen new --outfile ~/sniper-wallet.json

NEVER use this keypair as your main wallet. Fund it with the amount you are willing to lose entirely.

H3: Step 6 — Set Parameters

Edit the config file:

{
  "rpcUrl": "https://your-private-node.com",
  "wsUrl": "wss://your-private-node.com",
  "walletFile": "~/sniper-wallet.json",
  "maxSlippage": 20,
  "maxBuyAmount": 0.5,
  "priorityFee": 0.001,
  "autoSell": true,
  "sellAtProfit": 50,
  "stopLoss": 30
}

H3: Step 7 — Test on Devnet

Most bots can be switched to Solana Devnet by changing the RPC URL. Run a test against a devnet token to validate transaction building. Your bot will receive a syntax error within minutes if the code is broken.

H3: Step 8 — Launch on Mainnet with Minimum Capital

Start with 0.1–0.5 SOL. Watch the logs to see:

• The latency between LP detection and your transaction landing.
• Whether transactions succeed or fail and at what rate.
• Whether the “sell” logic gets triggered properly.

H3: Step 9 — Monitor and Iterate

Sniping is iteration. Adjust priority fees up if your transactions are consistently landing too late. Adjust buy amount down if slippage kills returns. Track performance in a spreadsheet or with a simple logging dashboard.

H3: Step 10 — Add Jito Bundles

Once the base bot works, integrate jito-ts to submit bundles. This is the difference between entering at pool creation block or 5 blocks later — which, in meme-coin terms, is the difference between ride and exit liquidity.

A sniper bot without a filtering strategy is a money-burning machine. The following strategies separate the top 1% from the rest.

H3: Honeypot and Rug Detection Filters

A large percentage of new Solana tokens are designed to steal from bot traders. Their smart contracts:

• Disable sell: The transfer function reverts for everyone except the owner.
• Burn liquidity: The LP tokens are sent out of the pool, enabling the dev to drain the pool.
• Mint more tokens: The mint authority is retained for further dilution.
• Freeze authority: The owner can freeze your account entirely.

Good open-source bots implement basic checks against these features. Run a token through a third-party honeypot checker in addition to the bot's built-in check. If the checker flags the token, skip the launch. No FOMO.

H3: Top-Holder Concentration Thresholds

Tokens with one wallet controlling over ~20% of the total supply are a cartel waiting to dump. Configure your bot to automatically skip any token where the top holder holds more than 5–10% of liquidity.

H3: Liquidity Pool Amount Filters

Launching with tiny liquidity (e.g., less than one SOL) opens the door for an instant-buy whale to own 70% of the pool in the first block. Only snipe tokens with a minimum viable liquidity amount. The threshold depends on the launchpad, but a rule of thumb:

• Raydium: Skip pools with less than ~3 SOL of liquidity.
• Pump.fun: Skip mints whose dev has accumulated more than 3% of supply before launch.

H3: Slippage Management

A sniper buy must tolerate high slippage — some launches move 100% in the first seconds. The tradeoff is slippage vs. chance of fill:

• 5–15% slippage: Common for stable launches.
• 20–30% slippage: Necessary for extreme meme-coin launches.
• Anything above 40% prevents pool maintenance and will see your buy reverted.

H3: Auto-Sell and Stop-Loss Triggers

Locking in profit is what matters. Configure the bot's sell logic:

• Take profit at 50–100% for your first few snipes.
• Trailing stop at 10% for moon-shot positions.
• Time-based exit — if the token has not reached 2x in 10 minutes, exit before the initial dumping frenzy begins.

H3: Case Study A — The Jito Edge (Success)

Setup: A trader in a private Discord shared a GitHub fork of a jito-ts-based bundle sniper. The bot was configured with a priority fee of 0.001 SOL per transaction.

Action: The trader deployed the bot with 2 SOL (about $380 at the time) on a fresh wallet. Over 10 days, it snipped 47 token launches, with a 22% hit rate on "high-liquidity" pools.

Outcome: His 47 buys produced 6 profitable trades. The best single trade returned a 14x on a token that pumped for an hour. After fees and gas, his total return was 3.2x on the starting capital. He attributed most of the edge to Jito bundles, which guaranteed his entry and exit in the same block on fast-moving losers.

H3: Case Study B — The Backdoored Repo (Loss)

Setup: A novice trader found a "Solana sniper bot" on GitHub with 800 stars and a clean README. It promised a 90% win rate. He cloned it, funded a wallet with 5 SOL, and ran the bot locally.

Outcome: Within 4 hours, his wallet was drained. The bot contained a preinstall NPM dependency that sent a Base64-encoded private key to a Telegram bot. He lost the full 5 SOL. An audit afterward showed the repo's stars were purchased; the original code was a fork of a legitimate bot with the backdoor injected.

H3: Case Study C — The Slippage Disaster (Loss)

Setup: A moderately experienced trader used a Raydium sniper with 10% slippage to snipe a heavily hyped token with 5 SOL.

Outcome: The token launched at 1,200 TPS, and the trader's transaction landed five blocks late. By then, the price had pumped 300%. The 10% slippage was exceeded; the transaction failed repeatedly, consuming priority fees every time. He burned ~0.3 SOL in fees and never got a fill. The lesson: For hyped launches, if your bot cannot reliably land in block 0–1, you should not be sniping that token.

H3: Financial Risk

Sniping is a negative-expectancy game for most participants. The market is adversarial: professional MEV teams, insiders, and devs set traps for bots. If you approach sniping as a lottery ticket (low wallet amount, high frequency), you can learn without being wiped out. If you treat it as an income strategy, you will almost certainly lose everything.

H3: Security Risk

The risk is not only in GitHub backdoors. Running a bot requires storing a private key on a VPS. If that VPS is compromised, your wallet is gone. Always:

• Use a dedicated sniper wallet.
• Avoid storing keys on shared servers.
• Use 2FA on the VPS provider.
• Rotate wallets periodically.

H3: Legal and Regulatory Risk

Automated trading is legal in most jurisdictions, but it exists in a gray area. In the US, the SEC has signaled that many tokens are securities. Automated sniping of security tokens could expose you to unregistered trading activity. Jurisdictions like the UK and EU are tightening crypto tax reporting requirements. This guide is educational, not legal or financial advice. Consult with a licensed professional in your jurisdiction.

H3: Ethical Considerations (MEV and Sandwiches)

MEV sniping — extracting value by sandwiching other users' transactions — is considered by many in the community to be parasitic. It imposes costs on ordinary traders. Running a bot that only buys new tokens at launch is more socially acceptable than stealing front-run value from retail users. Choose your niche accordingly.

If you want to know if your bot is performing well, measure against these benchmarks:

Use these metrics as guardrails.