ScreenerBot

Professional Automated Trading for Solana DeFi

The first native local trading system for Solana DeFi.
Real-time token discovery • Multi-DEX support • Full self-custody • 24/7 automated trading

Why ScreenerBot?

Most trading tools rely on delayed APIs and shared infrastructure. ScreenerBot runs locally on your hardware, calculating prices directly from blockchain data and executing trades through your own wallet—eliminating platform lag and custody risk.

Feature	ScreenerBot	Cloud Bots
Execution Speed	Sub-millisecond strategy evaluation	API latency dependent
Price Data	Direct from on-chain pools (<50ms)	Delayed API feeds
Private Keys	Never leave your machine	Stored on remote servers
Customization	Fully configurable strategies	Limited presets
Uptime Control	You control availability	Platform dependent

Core Features

🔍 Token Discovery & Analysis

Multi-Source Discovery — Continuous monitoring of DexScreener, GeckoTerminal, and Raydium pools
Security Analysis — Automated Rugcheck scoring, mint/freeze authority detection, holder distribution analysis
Intelligent Filtering — Advanced multi-criteria filtering (liquidity, volume, market cap, age, and more)

📊 Real-Time Price Monitoring

11 Native DEX Decoders — Raydium (CLMM, CPMM, Legacy), Orca Whirlpool, Meteora (DAMM, DBC, DLMM), Pumpfun, and more
Direct Pool Pricing — Calculate spot prices from pool reserves in real-time
OHLCV Data — Multi-timeframe candlestick data for technical analysis

⚡ Automated Trading

Strategy-Based Execution — Configurable entry/exit conditions with technical indicators
DCA Support — Dollar-cost averaging with multiple entry points
Trailing Stop-Loss — Dynamic stop-loss that follows price movements
ROI Targets — Partial exits at configurable profit levels
Time Overrides — Force exits after configurable hold periods

🛡️ Safety & Security

Full Self-Custody — Private keys encrypted locally, never transmitted
Pre-Trade Safety Checks — Automatic security verification before every trade
Loss Limit Protection — Configurable period-based loss limits with auto-pause
Emergency Stop — One-click halt of all trading activity
Token Blacklisting — Automatic blocking of risky or underperforming tokens

🔀 Smart Routing

Jupiter V6 Integration — Best-route selection through Jupiter aggregator
GMGN Routing — Alternative routing for optimal execution
Automatic Selection — Bot selects best route based on price impact

📱 Dashboard & Monitoring

Web Dashboard — Professional local interface for monitoring and configuration
Real-Time P&L — Live profit/loss tracking for all positions
Transaction History — Complete trade log with detailed analytics
Telegram Notifications — Instant alerts for trades, positions, and system events

Quick Install (VPS/Linux Server)

Run ScreenerBot 24/7 on a Linux VPS with a single command:

curl -fsSL https://screenerbot.io/install.sh | bash

Alternative installation:

bash <(curl -fsSL https://raw.githubusercontent.com/screenerbotio/docs/main/screenerbot.sh)

What the Installer Does

Step	Description
🔍 Detection	Auto-detects architecture (x64/arm64)
📦 Download	Fetches latest headless package
📁 Install	Installs to `/opt/screenerbot`
⚙️ Service	Creates systemd service with auto-start
🔗 Command	Adds `screenerbot` command globally

Management Menu

After installation, run screenerbot anytime to access the interactive menu:

┌───────────────────────────────────────────────┐
│            ScreenerBot Manager                │
├───────────────────────────────────────────────┤
│   1. Install ScreenerBot                      │
│   2. Update ScreenerBot                       │
│   3. Uninstall ScreenerBot                    │
│   4. Backup Data                              │
│   5. Restore Data                             │
│   6. Manage Service                           │
│   7. System Monitor                           │
│   8. Dashboard Security                       │
│   9. Status & Info                            │
│  10. System Check                             │
│  11. Setup Update Notifications               │
│  12. Update Management Script                 │
│  13. Help & Tips                              │
└───────────────────────────────────────────────┘

Key Features:

System Monitor — Live CPU, RAM, disk, and bot status monitoring
Dashboard Security — Set password protection for the web dashboard
Backup & Restore — Full data backup with automatic versioning

VPS Requirements

Resource	Minimum	Recommended
OS	Ubuntu 20.04+ / Debian 11+	Ubuntu 22.04 LTS
CPU	2 vCPUs	4+ vCPUs
RAM	4 GB	8 GB
Storage	20 GB SSD	40 GB SSD
Network	Stable connection	Unmetered bandwidth

Recommended Providers: DigitalOcean, Vultr, Linode, Hetzner, AWS EC2

Desktop Installation

Download pre-built applications from screenerbot.io/download:

macOS

Architecture	Package
Apple Silicon (M1/M2/M3)	`.dmg` installer
Intel	`.dmg` installer

Download the appropriate .dmg file
Open and drag ScreenerBot to Applications
Right-click → Open (first time only, to bypass Gatekeeper)

Windows

Architecture	Package
x64 (most PCs)	`.exe` installer
ARM64	`.exe` installer

Download the .exe installer
Run installer and follow prompts
Launch from Start Menu or Desktop shortcut

Linux Desktop

Format	Distributions
`.deb`	Ubuntu, Debian, Linux Mint
`.rpm`	Fedora, RHEL, CentOS, openSUSE
`.AppImage`	Universal (any distribution)

# Debian/Ubuntu
sudo dpkg -i screenerbot_*.deb

# Fedora/RHEL
sudo rpm -i screenerbot_*.rpm

# AppImage
chmod +x ScreenerBot*.AppImage
./ScreenerBot*.AppImage

Data Directory Structure

ScreenerBot stores all data locally in your system's application data folder:

Locations by Platform

Platform	Data Directory
macOS	`~/Library/Application Support/ScreenerBot/`
Windows	`%LOCALAPPDATA%\ScreenerBot\`
Linux	`~/.local/share/ScreenerBot/`

Directory Contents

ScreenerBot/
├── data/
│   ├── config.toml          # Main configuration file
│   ├── tokens.db            # Token database
│   ├── positions.db         # Position history
│   ├── transactions.db      # Transaction records
│   ├── ohlcvs.db            # Price history
│   ├── events.db            # System events log
│   └── wallet.db            # Wallet snapshots
└── logs/
    └── screenerbot_*.log    # Daily rotating logs

Note: All databases are SQLite format. The config.toml stores encrypted wallet data—never share this file.

Configuration

Dashboard Configuration (Recommended)

The web dashboard provides a safe, validated interface for all settings:

Open the dashboard at http://localhost:8080 (or your configured port)
Navigate to Config in the sidebar
Modify settings with instant validation
Changes apply immediately (hot-reload)

Initial Setup Requirements

Before trading, you must configure:

Setting	Description
Wallet	Your Solana wallet private key (encrypted locally)
RPC Endpoint	Solana RPC URL (Helius, QuickNode, Triton, or public)

Key Configuration Sections

Section	Purpose
Trader	Entry/exit rules, position limits, safety settings
Positions	DCA settings, partial exits, loss detection
Filtering	Token criteria (liquidity, volume, market cap, etc.)
Swaps	Router preferences, slippage, priority fees
RPC	Endpoint URLs, rate limits, failover settings
Telegram	Bot token, chat ID, notification preferences

Dashboard Access

After starting ScreenerBot, access the dashboard:

Environment	URL
Local/Desktop	`http://localhost:8080`
VPS (via SSH tunnel)	`ssh -L 8080:localhost:8080 user@your-vps-ip` then `http://localhost:8080`

Dashboard Pages

Page	Description
Home	System overview, quick stats, recent activity
Billboard	Live filtered tokens ready for trading
Positions	Open and closed position management
Tokens	Token database with security and market data
Trader	Trading controls, monitors, safety settings
Filtering	Configure token filtering criteria
Config	All system settings
System	Service status, logs, diagnostics

Trading Workflow

┌─────────────┐    ┌──────────────┐    ┌────────────┐    ┌─────────────┐
│  Discovery  │───▶│   Security   │───▶│  Filtering │───▶│   Trading   │
│             │    │   Analysis   │    │            │    │   Engine    │
└─────────────┘    └──────────────┘    └────────────┘    └─────────────┘
      │                   │                  │                  │
      ▼                   ▼                  ▼                  ▼
  DexScreener        Rugcheck           Liquidity          Entry/Exit
  GeckoTerminal      Mint Auth          Volume             Strategies
  Raydium Pools      Freeze Auth        Market Cap         Position Mgmt

Discovery — Continuously monitor sources for new tokens
Security — Verify each token passes security checks
Filtering — Apply your configured criteria
Trading — Execute strategies on qualified tokens

Supported DEXs

ScreenerBot features native on-chain decoders for price discovery:

DEX	Pool Types
Raydium	CLMM, CPMM, Legacy AMM
Orca	Whirlpool (Concentrated Liquidity)
Meteora	DAMM, DBC, DLMM
Pumpfun	AMM, Legacy
Fluxbeam	Standard AMM
Moonit	Standard AMM

All trade execution routes through Jupiter V6 or GMGN aggregators for optimal pricing.

Links & Resources

Resource	Link
🌐 Website	screenerbot.io
📚 Documentation	screenerbot.io/docs
⬇️ Download	screenerbot.io/download
� Telegram Channel	t.me/screenerbotio
💬 Telegram Group	t.me/screenerbotio_talk
🆘 Telegram Support	t.me/screenerbotio_support
𝕏 X (Twitter)	x.com/screenerbotio

Documentation Sections

Introduction — What is ScreenerBot?
Installation Guide — Platform-specific setup
Initial Setup — Wallet & RPC configuration
VPS Guide — 24/7 server setup
Dashboard Guide — Using the web interface
Trading Controls — Entry/exit configuration
Trailing Stop — Dynamic stop-loss
DCA Guide — Dollar-cost averaging
Telegram Setup — Notification configuration
Troubleshooting — Common issues & solutions

Support

Need help? We're here for you:

Telegram Support: @screenerbotio_support — Direct support
Telegram Group: t.me/screenerbotio_talk — Community help
Documentation: screenerbot.io/docs — Comprehensive guides

Project Status

ScreenerBot is open source under active development.

Source code: github.com/screenerbotio/ScreenerBot

This docs repository contains:

✅ Public documentation and resources
✅ VPS installation script (screenerbot.sh)
✅ Logo and brand assets

The full trading engine source code is available at screenerbotio/ScreenerBot.

Support Development

If ScreenerBot has been useful to you, consider supporting development with a SOL donation:

SOL Address: D6g8i5HkpesqiYF6YVCL93QD3py5gYwYU9ZrcRfBSayN

Built for the Solana DeFi community 🚀

Website • Documentation • Download • Channel • Group • X

Name		Name	Last commit message	Last commit date
Latest commit History 6 Commits
assets		assets
screenshots		screenshots
.gitignore		.gitignore
README.md		README.md
screenerbot.sh		screenerbot.sh

screenerbotio/docs

Folders and files

Latest commit

History

Repository files navigation