Learn how to query Solana blockchain data using SQL. This guide covers Flipside Crypto, Dune Analytics, Helius DAS, and Google BigQuery with practical queries for token holders, DEX volume, wallet profitability, and NFT sales.
Disclosure: This article contains affiliate links. If you sign up through them, MadeOnSol may earn a commission at no extra cost to you. This never affects our rankings, ratings, or reviews.
SQL has become the standard way to query Solana blockchain data. Whether you are tracking whale wallets, measuring DEX volume, or analyzing NFT sales trends, writing SQL against indexed Solana data gives you precision that no dashboard can match.
The problem is choosing the right platform. Flipside Crypto, Dune Analytics, Helius, and Google BigQuery all offer SQL access to Solana data, but they differ in schema design, data freshness, pricing, and query speed. This guide walks through each platform with setup instructions and ready-to-use queries so you can start extracting insights immediately.
If you are new to on-chain data analysis, start with our introduction to Solana on-chain data before diving into SQL-specific workflows.
Dashboards are useful for monitoring known metrics, but SQL unlocks questions that no pre-built dashboard anticipates. You can filter by specific programs, time windows, wallet clusters, or token mints — and combine them in ways that surfaces alpha before it becomes common knowledge.
Common use cases for SQL on Solana:
Every platform covered here indexes raw Solana transactions and decodes them into structured tables you can query with standard SQL syntax.
Dune Analytics is the most popular blockchain analytics platform with a massive community of analysts sharing public queries and dashboards. Its Solana support covers decoded program data, token transfers, DEX trades, and NFT events.
Dune's free tier gives you 2,500 monthly executions with a 6-minute timeout per query. The Plus plan ($349/month) unlocks private queries, faster execution, and CSV exports.
Dune organizes Solana data into several key schemas:
Building a product on Solana data?
Skip the Geyser pipeline — embed KOL flow, deployer reputation, and the all-DEX firehose over REST, WebSocket, or webhooks. The Business tier (€400/mo) is the self-serve embed license at 500k calls/day — Enterprise adds white-label & redistribution.
Tools mentioned
Live health scores, average ratings, and direct links on MadeOnSol.
MCP server powered by Solana Agent Kit for on-chain actions
Telegram trading bot for Solana — snipe new tokens, set limit orders, auto-sell, and copy trade with built-in MEV protection
Community-driven SQL analytics platform for querying and visualizing Solana blockchain data
Unity SDK for building Solana games
Browser-based IDE for developing and deploying Solana programs
Build with MadeOnSol API
KOL tracking, deployer intelligence, DEX streaming, and webhooks. Free API key — 200 requests/day.
New customers try Pro free for 5 days — card, cancel anytime.
import { MadeOnSol } from "madeonsol";
// Get a free API key at madeonsol.com/pricing
const client = new MadeOnSol({ apiKey: "msk_your_key" });
const { trades } = await client.kol.feed({ limit: 10 });
const { alerts } = await client.deployer.alerts({ limit: 5 });
const { tools } = await client.tools.search({ q: "trading" });Building a product on Solana data?
MadeOnSol isn't an RPC or another generic token API — it's Solana memecoin intelligence that's painful to build in-house, pulled from dual-region gRPC shred streams: sub-second from the on-chain event to your app.
Signals you'd otherwise build
KOL & smart-money flow from 1,000+ labeled wallets, deployer reputation, coordination clusters, linked-wallet entity resolution, and an all-DEX firehose.
Embed it in your product
The Business tier (€400/mo, self-serve) licenses you to display MadeOnSol data inside your own product — 500k calls/day, 10 WS + 5 firehose connections. Enterprise above adds white-label & redistribution rights and custom endpoints.
Evaluate first, commit later
Test everything on a free ULTRA key — no commitment. If it fits, we scope volume or white-label pricing.
Keep reading
Education
Learn how to analyze Solana on-chain data using tools like Dune, Flipside, Helius, and Birdeye. Master key metrics including TVL, volume, active wallets, and fee revenue to make smarter trading and investment decisions.
Analytics
Solana validators prune old data aggressively, making historical analysis difficult. Learn how to access Solana historical data using BigQuery, Flipside, Dune, Helius DAS API, and archival services — with practical query examples.
Education
How MadeOnSol classifies pump.fun deployers into tiers, tracks bonding rates, and surfaces the 34 elite deployers whose tokens graduate at 71% — versus the 1-2% baseline.
Developer Tools
How to query the alpha leaderboard API, what win_rate, roi, and net_pnl_sol actually mean, how to page through results, and how to build a top-wallets dashboard or bot signal feed in TypeScript.
Developer Tools
Learn how to set up Solana webhooks for real-time blockchain alerts. Compare Helius, QuickNode, Shyft, and Triton webhook providers, with TypeScript code examples for wallet monitoring, NFT sales alerts, and payment confirmation.
Analytics
MadeOnSol's Deployer Hunter tracked 4,344 unique deployers launching 6,225 tokens that bonded to Raydium in March 2026. We break down bond rates by deployer tier, the highest-performing launches, and what the alert data tells us.
Enjoyed this article?
Real-time KOL trades, Pump.fun deployer intel, and 1,200+ ranked Solana tools — free to explore.
Open the KOL Trackersolana.transactions — All Solana transactions with fee, signer, and status datasolana.account_activity — Account balance changes per transactiontokens_solana.transfers — Decoded SPL token transfersdex_solana.trades — Aggregated DEX trades across all major Solana DEXsnft_solana.trades — NFT marketplace sales dataSELECT
date_trunc('day', block_time) AS trade_date,
project AS dex,
COUNT(*) AS trade_count,
SUM(amount_usd) AS volume_usd
FROM dex_solana.trades
WHERE block_time >= NOW() - INTERVAL '30' DAY
GROUP BY 1, 2
ORDER BY 1 DESC, 4 DESC
This query returns daily DEX volume per protocol over the last 30 days. You can filter by specific DEX names like 'jupiter' or 'raydium' to narrow results.
SELECT
to AS wallet,
SUM(CASE WHEN to = wallet THEN amount ELSE 0 END)
- SUM(CASE WHEN "from" = wallet THEN amount ELSE 0 END) AS net_balance
FROM tokens_solana.transfers
WHERE token_mint_address = '{{token_mint}}'
GROUP BY 1
HAVING net_balance > 0
ORDER BY 2 DESC
LIMIT 100
Replace {{token_mint}} with any SPL token mint address. Dune supports parameterized queries, so you can create a reusable dashboard widget for any token.
Flipside takes a different approach by providing curated, pre-modeled data tables that are easier to query than raw transaction data. Their Solana coverage includes decoded program events, labelled wallet addresses, and clean swap tables.
solana schemaThe free tier includes 5,000 query-seconds per month. The Pro plan ($49/month) adds more compute, private queries, and API access for programmatic data pulls.
Flipside's Solana tables are well-organized:
solana.core.fact_transactions — Transaction-level data with fees, signers, and success statussolana.core.fact_transfers — All SOL and SPL token transferssolana.core.fact_events — Decoded program eventssolana.defi.fact_swaps — DEX swap data with clean token symbols and USD valuessolana.nft.fact_nft_sales — NFT marketplace transactionssolana.core.dim_labels — Known wallet labels (exchanges, protocols, whales)WITH buys AS (
SELECT
swapper AS wallet,
swap_to_mint AS token,
SUM(swap_to_amount) AS tokens_bought,
SUM(swap_from_amount * COALESCE(swap_from_decimal_price, 0)) AS cost_usd
FROM solana.defi.fact_swaps
WHERE swapper = '{{wallet_address}}'
AND block_timestamp >= CURRENT_DATE - 30
GROUP BY 1, 2
),
sells AS (
SELECT
swapper AS wallet,
swap_from_mint AS token,
SUM(swap_from_amount) AS tokens_sold,
SUM(swap_to_amount * COALESCE(swap_to_decimal_price, 0)) AS revenue_usd
FROM solana.defi.fact_swaps
WHERE swapper = '{{wallet_address}}'
AND block_timestamp >= CURRENT_DATE - 30
GROUP BY 1, 2
)
SELECT
b.token,
b.tokens_bought,
COALESCE(s.tokens_sold, 0) AS tokens_sold,
b.cost_usd,
COALESCE(s.revenue_usd, 0) AS revenue_usd,
COALESCE(s.revenue_usd, 0) - b.cost_usd AS pnl_usd
FROM buys b
LEFT JOIN sells s ON b.token = s.token
ORDER BY pnl_usd DESC
This query calculates profit and loss per token for a given wallet over the last 30 days. It pairs buy and sell activity to show which tokens were profitable.
Helius is primarily an RPC and API provider, but its Digital Asset Standard (DAS) API and enhanced transaction endpoints let you query Solana data programmatically. While Helius does not offer a traditional SQL editor, you can pipe its structured JSON responses into your own database for SQL analysis.
The free tier provides 100,000 credits/month. For heavy data analysis, the Business plan offers higher limits and priority access.
// Fetch top holders for a token mint using Helius DAS
const response = await fetch(
`https://mainnet.helius-rpc.com/?api-key=${API_KEY}`,
{
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
jsonrpc: "2.0",
id: 1,
method: "getTokenAccounts",
params: {
mint: "TOKEN_MINT_ADDRESS",
limit: 100,
options: { showZeroBalance: false }
}
})
}
);
Once you load this data into a local database, you can run standard SQL queries against it. This approach is best when you need real-time data that analytics platforms might lag behind on.
// Fetch NFT transaction history
const response = await fetch(
`https://api.helius.xyz/v0/addresses/${NFT_MINT}/transactions?api-key=${API_KEY}&type=NFT_SALE`
);
const sales = await response.json();
// Insert into local DB for SQL analysis
Helius is ideal when you need the freshest data possible or when your analysis requires combining on-chain data with off-chain sources in a custom database.
Google BigQuery provides access to Solana blockchain data through the public dataset bigquery-public-data.crypto_solana_mainnet_us. This is a fully managed warehouse with no indexing required and virtually unlimited compute for large-scale analysis.
crypto_solana in the public datasets explorerBigQuery offers 1 TB of free query processing per month. For most Solana analysis tasks, this is more than enough. Billing kicks in at $6.25 per TB scanned after the free tier.
The Solana public dataset includes:
transactions — Full transaction data including instructions and logsblocks — Block-level metadata (slot, timestamp, leader)accounts — Account state snapshotstoken_transfers — Decoded SPL token transfer eventsrewards — Validator and staking rewardsSELECT
t.block_timestamp,
t.signatures[OFFSET(0)] AS tx_signature,
tt.source AS seller,
tt.destination AS buyer,
tt.value / 1e9 AS price_sol
FROM `bigquery-public-data.crypto_solana_mainnet_us.transactions` t,
UNNEST(t.token_transfers) tt
WHERE tt.mint = '{{nft_collection_mint}}'
AND t.block_timestamp >= TIMESTAMP_SUB(CURRENT_TIMESTAMP(), INTERVAL 90 DAY)
AND t.success = TRUE
ORDER BY t.block_timestamp DESC
LIMIT 500
BigQuery shines for historical analysis across large time ranges where other platforms might time out. Scanning a full year of Solana DEX data is routine on BigQuery but can be painful on platforms with execution time limits.
| Feature | Dune Analytics | Flipside Crypto | Helius | Google BigQuery |
|---|---|---|---|---|
| SQL dialect | DuneSQL (Trino) | Snowflake SQL | N/A (API) | GoogleSQL |
| Free tier | 2,500 queries/mo | 5,000 query-sec/mo | 100K credits/mo | 1 TB queries/mo |
| Data freshness | Near real-time | Near real-time | Real-time | 1-6 hour lag |
| Query speed | Moderate | Fast | Instant (API) | Fast for large scans |
| Decoded DEX data | Yes | Yes | Via parsed tx | Limited |
| NFT sales tables | Yes | Yes | Via DAS API | Raw transfers only |
| Wallet labels | Community | Built-in | No | No |
| Visualization | Built-in charts | Built-in charts | No | Looker Studio |
| API access | Paid plans | Pro plan | All plans | All plans |
| Best for | Community dashboards, research | Clean data models, wallets | Real-time data, app backends | Large-scale historical analysis |
Choosing the right platform:
For a broader comparison of analytics tools, see our guide on the best Solana analytics dashboards.
Optimize for cost and speed:
block_time or block_timestamp first. Time-partitioned columns dramatically reduce the amount of data scanned.LIMIT during development. A query that returns 10 million rows wastes compute even if you only look at the first 100.SELECT * on transaction tables. Solana transactions contain nested instruction data that inflates scan size.Handle Solana-specific quirks:
10^decimals to get human-readable values. Most platforms provide a decimal column or pre-divided amount.Combine platforms for the best results:
Use Dune or Flipside for discovery and exploration, then move to Helius or BigQuery for production pipelines that need reliability and freshness. Many analysts use Dune to prototype a query, then replicate it in BigQuery for scheduled reporting.
For deeper guidance on working with historical Solana data, check out our historical data access and analysis guide. If you want production-grade freshness instead of a warehouse query, our guide to building a Solana token analytics dashboard shows how to combine several of these same data sources into one live view, while our breakdown of the dual-region gRPC pipeline behind MadeOnSol's KOL tracker covers what real-time ingestion looks like without SQL at all. Before you write a query, it's often faster to sanity-check a wallet, token, or transaction by hand in a block explorer first — our guide to Solana FM's Translator feature shows how to read holder distributions and parsed transactions without touching a single line of SQL.
Yes, every platform covered in this guide offers a free tier that is sufficient for learning and moderate analysis. Dune provides 2,500 free query executions per month, Flipside offers 5,000 query-seconds, Google BigQuery includes 1 TB of free query processing, and Helius gives 100,000 API credits. You can accomplish serious research without paying anything. Paid tiers become necessary when you need private queries, higher execution limits, or programmatic API access for production applications.
Helius provides the freshest data because it queries the Solana blockchain directly via RPC and API calls, giving you real-time results with no indexing delay. Dune Analytics and Flipside Crypto both operate at near real-time freshness, typically lagging by a few minutes as they index and decode new blocks. Google BigQuery has the longest delay, often ranging from one to six hours depending on the dataset refresh schedule. If your analysis requires data from the most recent blocks, Helius is the best choice. For anything older than an hour, all four platforms provide equivalent data.
You can use them for the analytical component of a trading strategy, but none of these platforms are designed for real-time trade execution. Dune and Flipside are best suited for backtesting strategies, identifying patterns, and generating watchlists. Helius can feed real-time data into a trading bot via its API and webhooks. BigQuery works well for batch analysis that runs on a schedule. The typical workflow is to use SQL analysis to identify opportunities, then execute trades through a separate system connected to Jupiter or Raydium. See our on-chain data analysis guide for more on turning data into actionable insights.
Basic SQL knowledge is enough to extract significant value from Solana data. If you can write SELECT, WHERE, GROUP BY, and JOIN statements, you can answer most common questions about token holders, trading volumes, and wallet activity. Dune and Flipside both have large libraries of community queries you can fork and modify without writing anything from scratch. More advanced techniques like window functions, CTEs, and subqueries become useful for complex analyses like wallet profitability tracking or time-series comparisons, but you can learn these incrementally as your questions get more sophisticated.