Reading Solana On‑Chain Data for Real Trading Decisions

Why On‑Chain Data Matters for Solana Traders

On Solana, almost everything that affects a token’s price is visible on‑chain: swaps, liquidity changes, large wallet moves, and even how much priority fee traders are paying to get in first. Because Solana is high‑throughput and low‑fee, you get a dense stream of signals that you can’t see just from a candlestick chart.

This guide focuses on how to read Solana on‑chain data in a way that directly supports trading decisions, using real tools and the actual mechanics of the chain.

We’ll cover:

• The minimum Solana concepts you need (accounts, SPL tokens, fees)
• How to read token and wallet data on explorers
• How to interpret swap and liquidity activity
• How to use DEX analytics (Birdeye, DexScreener, etc.)
• When you need specialized APIs like Helius for deeper or faster data

All examples are grounded in how Solana actually works today.

---

Core Solana Concepts Traders Must Understand

You don’t need to be a protocol engineer, but you do need a mental model of how Solana stores and charges for things.

1. Account model and SPL tokens

Solana uses an account‑based model where every piece of state (wallets, token balances, programs, liquidity pools) is an account with data. (solana.com)

Key points for traders:

• Wallet address vs token accounts
• Your wallet (Phantom, Backpack, etc.) shows one address, but each SPL token you hold lives in a separate token account owned by that wallet. (solana.com)

• On explorers, you’ll often see:

  • One system account (your main SOL account)
  • Multiple SPL token accounts (USDC, meme coins, LP positions, etc.).

• Programs

• DEXes, token programs, and lending protocols are all on‑chain programs (smart contracts).
• Each has a program ID (a public key). For example, Jupiter’s main aggregator program ID appears in Solscan’s Data Intelligence labeling. (solscan.io)
• When you inspect a transaction, which program IDs are called tells you what actually happened (swap, mint, transfer, add liquidity, etc.).

2. Solana fees and why they matter for trading

Solana transaction cost = base fee + optional priority fee. (github.com)

• Base fee
• Currently 5,000 lamports per signature (0.000005 SOL), set at the protocol level. (github.com)

• 50% of this base fee is burned, 50% goes to the block‑producing validator. (solana.com)

• Priority fee

• Optional, used to bid for faster inclusion when writing to congested accounts (e.g., hot DEX pools).
• For legacy/v0 transactions:
  priority_fee = ceil(compute_unit_price × compute_unit_limit / 1,000,000), where compute_unit_price is in micro‑lamports per compute unit. (solana.com)
• 100% of the priority fee goes to the validator. (solana.com)

For traders, rising average priority fees around a token or DEX pool are a congestion/competition signal: bots and aggressive traders are paying more to get their swaps in first.

---

Step 1: Reading Token‑Level On‑Chain Data

Your first layer of on‑chain reading is at the token mint level: supply, holders, and transaction patterns.

A. Using Solscan, SolanaFM, SolanaScan

Explorers like Solscan, SolanaFM, and SolanaScan index and label Solana accounts and programs so you don’t have to decode raw RPC data. (info.solscan.io)

For a token mint address, you can typically see:

• Basic token info
• Total supply and decimals (from the SPL token program state).

• Mint authority / freeze authority (if still active, that’s a risk flag).

• Holder distribution

• Top holders and their percentage of supply.

• Concentration in a few wallets = higher risk of large dumps.

• Program interactions

• Which DEX programs the token interacts with (Raydium, Meteora, PumpSwap, Orca, etc.).
• On Solscan’s Data Intelligence dashboard, you can see counts of swaps by DEX program and funding relationships between accounts. (info.solscan.io)

Trading use case:

• Before entering a new token, check:
• Is the mint authority revoked?
• Are top 5 holders overly concentrated?
• Which DEX pools exist and where the real volume is (Raydium vs Meteora vs others)?

B. DEX analytics: Birdeye, DexScreener, GeckoTerminal

These tools sit on top of raw on‑chain data and present pair‑level trading metrics for Solana tokens. A Reddit thread from 2023 explicitly highlights Birdeye, DexScreener, and Solscan as go‑to analytics for Solana. (reddit.com)

For each token pair (e.g., TOKEN/SOL or TOKEN/USDC), you typically get:

• Price and fully diluted valuation (FDV)
• 24h volume and liquidity
• Trade count and buy/sell ratio
• Wallet distribution among traders

What to read as a trader:

• Volume vs liquidity
• High volume relative to liquidity = more slippage and more impact per trade.

• Low volume with decent liquidity often means the pool is idle; big moves may be more easily faded.

• Trade count vs unique wallets

• Many trades but few wallets = bot‑dominated or wash‑like activity.
• Growing unique wallets over time = more organic participation.

---

Step 2: Reading Wallet‑Level On‑Chain Data

Wallet behavior often leads price. Watching what specific wallets do can give you better signals than just price action.

A. Identifying smart vs risky wallets

On explorers and analytics tools you can:

• View full transaction history of a wallet (transfers, swaps, LP actions).
• See which DEXes and protocols it uses.
• Inspect PnL patterns over time (some tools approximate this from trade history).

Helius and similar data providers expose APIs that aggregate and decode this history, making it easier to build custom tracking dashboards. Their Enhanced Transactions and Parsed Events/Streams products return fully decoded instructions for thousands of Solana programs. (helius.dev)

Practical patterns to look for:

• Wallets that consistently buy early in new pools and exit before volume dies.
• Wallets that provide and remove liquidity around key moves.
• Wallets that pay high priority fees on specific tokens (they care enough to compete).

B. Reading funding relationships

Solscan’s Data Intelligence dashboard explicitly includes a “Funded By” section, which traces first funding relationships between accounts using indexed transaction data. (info.solscan.io)

This helps you:

• See whether a token deployer wallet is linked to known teams, exchanges, or other labeled entities.
• Spot clusters of wallets that are funded from the same source (possible coordinated actors).

For trading, you can:

• Avoid tokens where deployer and top holders are tightly linked and actively funding each other.
• Prefer ecosystems where deployer wallets are funded from reputable, long‑lived addresses.

---

Step 3: Reading Swap and Liquidity Activity

Most of your actionable trading data on Solana comes from DEX swaps and liquidity changes.

A. How swaps actually appear on‑chain

On raw Solana RPC, a transaction is just:

• A list of accounts
• A list of instructions (program IDs + data blobs)

Without decoding, this is hard to read. That’s why tools like Helius’s parsed transaction APIs exist: they decode DEX program instructions into human‑readable events (e.g., Swap, AddLiquidity, RemoveLiquidity) for thousands of programs. (sitelet.easiiodev.ai)

Explorers and analytics sites consume similar decoded data to show you:

• Which token was swapped for which
• Exact amounts in and out
• Which pool/program handled the swap
• Fees paid and sometimes slippage

B. Reading pool‑level activity

On Solana, major DEXes like Raydium, Meteora, Orca, and Jupiter‑routed pools dominate spot trading volume. (pumpview.fun)

For a given pool, you want to see:

• Net flow
• Are more tokens flowing into the pool (net buying) or out (net selling) over a timeframe?

• Some analytics dashboards approximate this as net buy/sell volume.

• Liquidity changes

• Large add liquidity events near lows can be smart money positioning.

• Large remove liquidity events near highs can precede sharp reversals.

• DEX program mix

• If a token trades mostly on one DEX program, it may be more vulnerable to local issues (e.g., a specific AMM bug or UI outage).
• Solscan’s classification of “swap/DEX programs” by count of swaps helps you see where real activity is. (info.solscan.io)

C. Priority fees as a sentiment signal

Because Solana uses local fee markets, priority fees spike on congested accounts, like hot DEX pools. A technical overview of Solana fees notes that users set a compute unit limit and price, and total priority fee is the product (in micro‑lamports) converted to lamports. (solana.com)

For trading, this means:

• If you see rising average priority fees for swaps in a specific pool:
• Competition for execution ordering is increasing.
• Bots and high‑frequency traders are likely active.

• Slippage and short‑term volatility are usually higher.

• If priority fees stay near zero even during price moves:

• The move may be less contested; you’re less likely to be front‑run.
• It might also indicate lower overall interest.

Some explorers and analytics tools expose fee distributions per transaction; others require you to read raw transaction data or use APIs like Helius to inspect compute budget instructions.

---

Step 4: Going Deeper with APIs and Historical Data

If you’re building your own dashboards or systematic strategies, you’ll eventually need direct access to parsed on‑chain data.

A. Helius and similar Solana data APIs

Helius provides:

• Enhanced Transactions / DAS APIs that return decoded Solana transactions with program‑specific fields. (helius.dev)
• Parsed Events and Parsed Streams that stream human‑readable events for 3,600+ Solana programs over WebSockets. (sitelet.easiiodev.ai)
• Recently, a Preprocessed Transactions service aimed at high‑frequency traders, delivering decoded transactions before they reach processed commitment. (reddit.com)

Community discussions highlight that:

• Helius’s combined transaction history endpoints reduce round‑trips vs raw RPC. (reddit.com)
• Solana Foundation also publishes historical data in Google BigQuery, and there are public datasets on platforms like Kaggle and Hugging Face for large‑scale backtesting. (reddit.com)

Trading applications:

• Backtest strategies based on:
• Wallet behavior (copy‑trading or counter‑trading specific addresses).
• Priority fee patterns before big moves.

• Net flow into/out of pools across DEXes.

• Build alerts when:

• A tracked wallet interacts with a new token mint.
• Liquidity in a watched pool crosses a threshold.
• Priority fees on a given pool spike above your baseline.

B. Research on on‑chain rug pulls and fraud

Academic work like SolRugDetector shows that it’s possible to detect rug pulls on Solana purely from on‑chain transaction and state data (e.g., patterns in liquidity removal, ownership changes, and transfer graphs). (arxiv.org)

For traders, this reinforces that:

• You can systematically screen for risk using:
• Ownership and authority fields from the token mint.
• Liquidity add/remove patterns.
• Concentration and coordination of top holders.

You don’t need their full model to benefit; just knowing that these signals are detectable on‑chain should push you to check them before trading.

---

Practical On‑Chain Checklist Before You Trade

Here’s a concise, data‑driven checklist you can apply using the tools above.

1. Token sanity check (explorer + DEX analytics)
2. Look up the mint address on Solscan/SolanaFM/SolanaScan. (info.solscan.io)
3. Verify:
   • Mint authority revoked or not.
   • Freeze authority status.
   • Holder concentration (top 10 holders).

4. On Birdeye/DexScreener:

   • Liquidity size and 24h volume.
   • Number of trades and unique wallets.

5. DEX and pool behavior

6. Identify which DEX programs the token uses (Raydium, Meteora, Orca, etc.). (info.solscan.io)

7. Inspect recent swaps:

   • Net buy vs sell volume.
   • Large, repeated trades from the same wallets.

8. Wallet‑level signals

9. On the top trader wallets:
   • Are they active across many tokens or just this one?
   • Do they have a history of exiting before big dumps?

10. Use labeled data (Solscan Data Intelligence, other labeling services) to see if they link to known entities. (info.solscan.io)

11. Fee and congestion context

12. Check whether swaps in this pool are paying notable priority fees compared to normal Solana base fees. (solana.com)

13. Spiking priority fees + heavy bot‑like activity usually means:

    • Higher short‑term volatility.
    • More risk of slippage and bad fills for manual traders.

14. Historical context (optional but powerful)

15. If you’re serious, pull historical data via Helius or BigQuery: (helius.dev)
    • Backtest how similar patterns (liquidity changes, fee spikes, wallet activity) played out on other tokens.
    • Use that to calibrate your risk and position sizing.

---

Conclusion: Turn Raw On‑Chain Firehose Into Trading Edge

Solana’s design — high throughput, low base fees, and explicit priority fees — produces a rich on‑chain data stream. You can see who traded what, where, when, and how aggressively almost in real time.

To turn that into an edge:

• Use explorers (Solscan, SolanaFM, SolanaScan) to understand token structure, holders, and program relationships. (info.solscan.io)
• Use DEX analytics (Birdeye, DexScreener, GeckoTerminal) to read volume, liquidity, and trader distribution. (reddit.com)
• Watch wallet‑level behavior and priority fee patterns to gauge competition and sentiment. (solana.com)
• When you need more, tap APIs and datasets (Helius, Solana BigQuery, public datasets) to backtest and automate your own signals. (helius.dev)

The key is to always tie what you see on‑chain back to concrete trading decisions: whether to enter, size up, hedge, or stay out entirely. With the right tools and a disciplined checklist, Solana’s on‑chain data becomes more than noise — it becomes a measurable, testable source of trading edge.