# Changelog
Source: https://docs.solanatracker.io/changelog
Product updates and announcements across our platform
Changelog
## Data API
* **Improved price change percentages** — More accurate percent change calculations.
* **Improved chart wicks** — Chart API shows more accurate wicks via a new aggregation technique.
* **Fixed chart volume in some cases** — Ensures volume uses all pools when not filtering by pool.
* **Added Humidifi, Tessera, and Solfi V1/V2 support.**
## Datastream
* **Fixed price change percentages on stats room** — Corrected percent change calculations in the stats room.
* **Improved pool selection** — Better pool selection on token and price rooms.
* **Transaction monitor updates** — Added Raptor to the transaction monitor
* **Added Humidifi, Tessera, and Solfi V1/V2 support.**
* **Stability improvements** — Fixed and improved stability of transaction and price updates.
## Data API
* **Chart currency option** — `/chart/{token}` and `/chart/{token}/{pool}` now support `currency=usd|sol|eur` (default `usd`).
[View documentation →](/data-api/chart/get-ohlcv-data-for-a-token#parameter-currency)
## Data API
* **New bundlers endpoint** — Use `/tokens/{token}/bundlers` to fetch bundler wallet stats for a token.
* **Risk now includes bundlers** — The `risk` object returned on token responses includes bundler analysis.
* **Search improvements** — `/search` now returns `riskScore` and bundler-related fields.
### Risk scores
* **Bundlers** — New count-based + percentage-based scoring from new bundler data.
* **Suspicious volume** — Flags extreme buy/sell imbalance.
## Datastream
* **New room:** `bundlers:{tokenAddress}` — Real-time bundler wallet updates (wallet, current/previous amount & %, and totalBundlerPercentage).
## Top Performers
* **Top performers endpoint** — Added `/top-performers/{timeframe}` to retrieve top performing tokens launched today.
* **Timeframes** — Supports `5m`, `15m`, `30m`, `1h`, `6h`, `12h`, and `24h`.
## Data API
* **First buyers endpoint accuracy** — Improved accuracy for first buyers endpoints to match with other PnL endpoints
* **Pricing and volume fixes** — Fixed pricing and volume calculation bug on some trades
* **Exact token price at trade time** — Added exact token price at time of trade for each token when using the `showMeta` flag on `/trades`
## Datastream - Trade rooms
* **Global Load Balancer** - Added a global load balancer for the Datastream that routes to US or EU based Datastream servers automatically.
* **Enhanced Datastream trade rooms** — Added `price` and `marketCap` to each token in Datastream trade rooms for better accuracy (uses main pool data). The main object `priceUsd` can be considered the exchange rate.
## Image proxy
* **Image proxy filtering** — Enhanced image proxy filtering for invalid SVGs with reduced false positives
* **Faster transaction and price updates** — Reduced latency for real-time data delivery
* **Enhanced tokens overview API** — Pulse/Memescope now features improved filters and dramatically better performance
* **Upgraded Yellowstone gRPC** — New Rust client delivers faster streaming performance
## Data Accuracy & Reliability
Major improvements to data quality and consistency:
* **Program filtering** — Excluded unknown programs that could cause invalid data from arbitrage bots and other sources
* **Pool data updates** — Liquidity changes now trigger pool updates even without swaps
* **Time accuracy improvements** — Edge case handling now uses `blockTime` when gRPC is behind or transaction parsing is delayed by more than a few seconds
## New Features
**Automatic Pool Rotation**
* Main pool rotation now happens automatically for `price:token:{address}` and `token:{primary}` rooms — no client-side changes required
**Aggregated Price Room**
* New **`price:aggregated:{token}`** room provides min, average, median, and max price updates
* Aggregates price data across top 10 valid pools
* Each update includes individual pool prices for full transparency
**Pumpfun Mayhem Mode**
* Added support for Pumpfun Mayhem mode
* Pool data now includes `tokenProgram` and `isMayhemMode` fields
## Infrastructure
**Redis Server Upgrade**
* Deployed new Redis infrastructure
* Eliminates random 500/503 errors during high load periods
* Improved overall platform stability
## Aggregated Price Updates
We've added a new WebSocket room that provides aggregated price data across multiple liquidity pools for any token.
### What's New
**`price:aggregated:{tokenAddress}`**
* **Multi-pool aggregation** — Get median, average, min, and max prices calculated across top liquidity pools
* **Top pools data** — Detailed breakdown of the 10 highest liquidity pools with individual prices
* **Real-time updates** — Live price aggregation as pools update
* **Pool count tracking** — Know exactly how many pools contributed to the aggregated data
* **Automatic pool rotation** - No need to subscribe to new rooms after token migration.
### Why Use Aggregated Pricing?
Single pool prices can be manipulated or show temporary volatility. Aggregated pricing gives you:
* **More accurate market prices** — Median and average across multiple sources
* **Manipulation resistance** — Harder to distort when aggregating across pools
* **Price range visibility** — See min/max spread to identify arbitrage opportunities
* **Liquidity-weighted insights** — Focus on pools that matter most
```json theme={null}
{
"type": "message",
"data": {
"token": "So11111111111111111111111111111111111111112",
"timestamp": 1762964449215,
"price": 153.70666202103925,
"pool": "3nMFwZXwY1s1M5s8vYAHqd4wGs4iSxXE4LRoUMMYqEgF",
"aggregated": {
"median": 153.6850599485249,
"average": 153.6735820182654,
"min": 153.36863801111053,
"max": 153.71662179961638,
"poolCount": 10
},
"topPools": [
{
"poolId": "3ucNos4NbumPLZNWztqGHNFFgkHeRMBQAVemeeomsUxv",
"price": 153.68241854665007,
"liquidity": 17950616.091940343,
"market": "raydium-clmm"
},
...
]
},
"room": "price:aggregated:So11111111111111111111111111111111111111112"
}
```
Perfect for trading interfaces, price oracles, and portfolio tracking applications that need reliable, manipulation-resistant pricing.
[View documentation →](/datastream/websockets/priceaggregated)
## getTokenAccountsByOwners — Batch Balance Lookups
We've added a new Ridge DB-powered RPC method that lets you query token balances for multiple wallets in a single request.
### What's New
**`getTokenAccountsByOwners`**
* **Batch up to 250 wallets** — Query hundreds of addresses in one call instead of making individual requests
* **Multiple accounts support** — Automatically returns all token accounts if a wallet has multiple for the same mint
* **Zero balance handling** — Wallets without a token account return a clean zero balance response
* **Slot tracking** — Each account includes the slot when the balance was last updated
### Use Cases
Perfect for:
* Portfolio tracking across multiple wallets
* Airdrop eligibility verification
* Multi-wallet dashboards
* Token distribution snapshots
```json theme={null}
{
"jsonrpc": "2.0",
"id": 1,
"method": "getTokenAccountsByOwners",
"params": [
["wallet1...", "wallet2...", "wallet3..."],
"EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
]
}
```
This method drastically reduces API calls and latency when you need to check token holdings across many addresses at once.
[View documentation →](/solana-rpc/http/gettokenaccountsbyowners)
## Ridge Stream — Enhanced Holder Data
All holder endpoints and real-time streams have been migrated to **Ridge Stream**, from our new high-performance service RidgeDB
### What's New
**REST Endpoints**
* **`/tokens/{token}/holders`** — Get top 100 holders (use /tokens//holders/pagination for pagination and higher limits )
* **`/tokens/{token}/holders/top`** — Fetch top holders by balance (excluding known wallets like lp)
* **`/holders/multi`** — Multi-token holder count lookups
* **`/holders/chart`** — Historical holder charts with more datapoints (now also includes SOL, USDC, and more)
**Real-Time Streams**
* **Holder count updates** — Live tracking of total holders
* **Wallet balance updates** — Now includes native SOL with improved reliability
* **Top 100 holders** — Real-time rankings of largest holders
* **Snipers and insiders** — Track early buyers and insider activity
You can now also get holder data for **large tokens** like WSOL, USDC, and USD1 that weren't available before. All holder counts and top 100 rankings work for these tokens via both API and real-time streaming.
## New Search Filters
Added new filters to the token search endpoint:
* **`launchpad`** — Filter by launch platform (`pumpfun`, `moonshot`, `letsbonk.fun`, `believe`)
* **`image`** — Search by exact image URL
* **`hasImage`** — Filter tokens that have/don't have images (`true`/`false`)
[View documentation →](/data-api/search/token-search)
## Paginated Token Holders Endpoint
We've launched a new endpoint for fetching all token holders with cursor-based pagination.
### What's New
**`GET /tokens/{tokenAddress}/holders/paginated`**
* **Cursor pagination** — Navigate through all holders efficiently
* **Up to 5,000 per page** — Fetch large batches in a single request
* **Ridge DB powered** — Fast queries even for tokens with millions of holders
* **Complete holder data** — Returns wallet, token account, amount, USD value, total holder count and ownership percentage
### The Improvement
Previously limited to 100 holders, this endpoint now handles tokens with any number of holders while maintaining consistent performance.
```bash theme={null}
GET /tokens/{tokenAddress}/holders/paginated?limit=1000&cursor=nextPageCursor
```
[View documentation →](/data-api/tokens/get-all-token-holders-paginated)
## Ridge DB Performance & Features Update
We've shipped several improvements to our Ridge DB-powered RPC methods to give you even more control and speed.
### What's New
* **Total count support** — `getProgramAccountsV2` and `getTokenAccountsByOwnerV2` now return `totalCount` in responses, making pagination and UI updates easier
* **Faster queries** — New indexes dramatically improve response times for certain account lookups
* **Stability improvements** — Bug fixes and optimizations
These updates build on our Ridge DB launch, delivering better performance and more developer-friendly responses.
## Solana Ridge DB
We've rolled out **two new RPC methods** powered by **Ridge DB** — our high-performance engine designed for lightning-fast account lookups on Solana.
### 🧭 New Methods
#### `getProgramAccountsV2`
Supercharged program account queries with:
* **`changedSince`** — Fetch only accounts updated after a given slot (great for incremental syncs)
* **`excludeZero`** — Automatically skip empty token accounts
* **Cursor pagination** — Retrieve up to 10,000 accounts per request
#### `getTokenAccountsByOwnerV2`
Optimized token account retrieval, featuring the same Ridge DB speed and:
* **`changedSince`** — Get only new or updated token accounts
* **`excludeZero`** — Filter out dust or empty balances
* **Cursor pagination** — Smoothly handle large token sets
### 💡 Why Ridge DB?
Ridge DB isn't your standard RPC backend. It's a purpose-built system for account-heavy workloads that delivers:
* Faster response times
* Slot-based incremental updates
* Cursor pagination for big datasets
In short — faster queries, cleaner data, and a smoother developer experience.
## New Documentation Site
We've launched a brand-new documentation hub that brings all our products and APIs together, complete with guides and hands-on examples.
You can now explore detailed docs for:
* **Yellowstone gRPC** — Real-time Solana data streaming
* **Data API** — REST access to historical and live Solana data
* **Datastream** — WebSocket-based live data feeds
* **Solana RPC** — Enhanced endpoints powered by Ridge DB
* **Swap API** — High-performance token swaps and routing
The new docs include interactive code samples, and best practices to help you build faster and smarter on Solana.
## getTokenAccountsByOwners — Batch Balance Lookups
We've added a new Ridge DB-powered RPC method that lets you query token balances for multiple wallets in a single request.
### What's New
**`getTokenAccountsByOwners`**
* **Batch up to 250 wallets** — Query hundreds of addresses in one call instead of making individual requests
* **Multiple accounts support** — Automatically returns all token accounts if a wallet has multiple for the same mint
* **Zero balance handling** — Wallets without a token account return a clean zero balance response
* **Slot tracking** — Each account includes the slot when the balance was last updated
### Use Cases
Perfect for:
* Portfolio tracking across multiple wallets
* Airdrop eligibility verification
* Multi-wallet dashboards
* Token distribution snapshots
```json theme={null}
{
"jsonrpc": "2.0",
"id": 1,
"method": "getTokenAccountsByOwners",
"params": [
["wallet1...", "wallet2...", "wallet3..."],
"EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
]
}
```
This method drastically reduces API calls and latency when you need to check token holdings across many addresses at once.
[View documentation →](/solana-rpc/http/gettokenaccountsbyowners)
## Ridge DB Performance & Features Update
We've shipped several improvements to our Ridge DB-powered RPC methods to give you even more control and speed.
### What's New
* **Total count support** — `getProgramAccountsV2` and `getTokenAccountsByOwnerV2` now return `totalCount` in responses, making pagination and UI updates easier
* **Faster queries** — New indexes dramatically improve response times for certain account lookups
* **Stability improvements** — Bug fixes and optimizations
These updates build on our Ridge DB launch, delivering better performance and more developer-friendly responses.
## Solana Ridge DB
We've rolled out **two new RPC methods** powered by **Ridge DB**, our high-performance engine designed for lightning-fast account lookups on Solana.
### 🧭 New Methods
#### `getProgramAccountsV2`
Supercharged program account queries with:
* **`changedSince`** — Fetch only accounts updated after a given slot (great for incremental syncs)
* **`excludeZero`** — Automatically skip empty token accounts
* **Cursor pagination** — Retrieve up to 10,000 accounts per request
#### `getTokenAccountsByOwnerV2`
Optimized token account retrieval, featuring the same Ridge DB speed and:
* **`changedSince`** — Get only new or updated token accounts
* **`excludeZero`** — Filter out dust or empty balances
* **Cursor pagination** — Smoothly handle large token sets
### 💡 Why Ridge DB?
Ridge DB isn't your standard RPC backend. It's a purpose-built system for account-heavy workloads that delivers:
* Faster response times
* Slot-based incremental updates
* Cursor pagination for big datasets
In short — faster queries, cleaner data, and a smoother developer experience.
No updates yet. Check back soon!
## Data API
* **Improved price change percentages** — More accurate percent change calculations.
* **Improved chart wicks** — Chart API shows more accurate wicks via a new aggregation technique.
* **Fixed chart volume in some cases** — Ensures volume uses all pools when not filtering by pool.
## Data API
* **Chart currency option** — `/chart/{token}` and `/chart/{token}/{pool}` now support `currency=usd|sol|eur` (default `usd`).
[View documentation →](/data-api/chart/get-ohlcv-data-for-a-token#parameter-currency)
## Data API
* **New bundlers endpoint** — Use `/tokens/{token}/bundlers` to fetch bundler wallet stats for a token.
* **Risk now includes bundlers** — The `risk` object returned on token responses includes bundler analysis.
* **Search improvements** — `/search` now returns `riskScore` and bundler-related fields.
### Risk scores
* **Bundlers** — New count-based + percentage-based scoring from new bundler data.
* **Suspicious volume** — Flags extreme buy/sell imbalance.
## Top Performers
* **Top performers endpoint** — Added `/top-performers/{timeframe}` to retrieve top performing tokens launched today.
* **Timeframes** — Supports `5m`, `15m`, `30m`, `1h`, `6h`, `12h`, and `24h`.
## Data API
* **First buyers endpoint accuracy** — Improved accuracy for first buyers endpoints to match with other PnL endpoints
* **Pricing and volume fixes** — Fixed pricing and volume calculation bug on some trades
* **Exact token price at trade time** — Added exact token price at time of trade for each token when using the `showMeta` flag on `/trades`
## Datastream - Trade rooms
* **Global Load Balancer** - Added a global load balancer for the Datastream that routes to US or EU based Datastream servers automatically.
* **Enhanced Datastream trade rooms** — Added `price` and `marketCap` to each token in Datastream trade rooms for better accuracy (uses main pool data). The main object `priceUsd` can be considered the exchange rate.
## Image proxy
* **Image proxy filtering** — Enhanced image proxy filtering for invalid SVGs with reduced false positives
## Ridge Stream — Enhanced Holder Data
All holder endpoints and real-time streams have been migrated to **Ridge Stream**, from our new high-performance service RidgeDB
### What's New
**REST Endpoints**
* **`/tokens/{token}/holders`** — Get top 100 holders (use /tokens//holders/pagination for pagination and higher limits )
* **`/tokens/{token}/holders/top`** — Fetch top holders by balance (excluding known wallets like lp)
* **`/holders/multi`** — Multi-token holder count lookups
* **`/holders/chart`** — Historical holder charts with more datapoints (now also includes SOL, USDC, and more)
**Real-Time Streams**
* **Holder count updates** — Live tracking of total holders
* **Wallet balance updates** — Now includes native SOL with improved reliability
* **Top 100 holders** — Real-time rankings of largest holders
* **Snipers and insiders** — Track early buyers and insider activity
You can now also get holder data for **large tokens** like WSOL, USDC, and USD1 that weren't available before. All holder counts and top 100 rankings work for these tokens via both API and real-time streaming.
## New Search Filters
Added new filters to the token search endpoint:
* **`launchpad`** — Filter by launch platform (`pumpfun`, `moonshot`, `letsbonk.fun`, `believe`)
* **`image`** — Search by exact image URL
* **`hasImage`** — Filter tokens that have/don't have images (`true`/`false`)
[View documentation →](/data-api/search/token-search)
## Paginated Token Holders Endpoint
We've launched a new endpoint for fetching all token holders with cursor-based pagination.
### What's New
**`GET /tokens/{tokenAddress}/holders/paginated`**
* **Cursor pagination** — Navigate through all holders efficiently
* **Up to 5,000 per page** — Fetch large batches in a single request
* **Ridge DB powered** — Fast queries even for tokens with millions of holders
* **Complete holder data** — Returns wallet, token account, amount, USD value, total holder count and ownership percentage
### The Improvement
Previously limited to 100 holders, this endpoint now handles tokens with any number of holders while maintaining consistent performance.
```bash theme={null}
GET /tokens/{tokenAddress}/holders/paginated?limit=1000&cursor=nextPageCursor
```
[View documentation →](/data-api/tokens/get-all-token-holders-paginated)
## Datastream
* **Fixed price change percentages on stats room** — Corrected percent change calculations in the stats room.
* **Improved pool selection** — Better pool selection on token and price rooms.
* **Transaction monitor updates** — Added Raptor to the transaction monitor; added Humidifi, Tessera, and Solfi V1/V2 support.
* **Stability improvements** — Fixed and improved stability of transaction and price updates.
## Datastream
* **New room:** `bundlers:{tokenAddress}` — Real-time bundler wallet updates (wallet, current/previous amount & %, and totalBundlerPercentage).
## Datastream - Trade rooms
* **Global Load Balancer** - Added a global load balancer for the Datastream that routes to US or EU based Datastream servers automatically.
* **Enhanced Datastream trade rooms** — Added `price` and `marketCap` to each token in Datastream trade rooms for better accuracy (uses main pool data). The main object `priceUsd` can be considered the exchange rate.
* **Faster transaction and price updates** — Reduced latency for real-time data delivery
* **Enhanced tokens overview API** — Pulse/Memescope now features improved filters and dramatically better performance
* **Upgraded Yellowstone gRPC** — New Rust client delivers faster streaming performance
## Data Accuracy & Reliability
Major improvements to data quality and consistency:
* **Program filtering** — Excluded unknown programs that could cause invalid data from arbitrage bots and other sources
* **Pool data updates** — Liquidity changes now trigger pool updates even without swaps
* **Time accuracy improvements** — Edge case handling now uses `blockTime` when gRPC is behind or transaction parsing is delayed by more than a few seconds
## New Features
**Automatic Pool Rotation**
* Main pool rotation now happens automatically for `price:token:{address}` and `token:{primary}` rooms — no client-side changes required
**Aggregated Price Room**
* New **`price:aggregated:{token}`** room provides min, average, median, and max price updates
* Aggregates price data across top 10 valid pools
* Each update includes individual pool prices for full transparency
**Pumpfun Mayhem Mode**
* Added support for Pumpfun Mayhem mode
* Pool data now includes `tokenProgram` and `isMayhemMode` fields
## Infrastructure
**Redis Server Upgrade**
* Deployed new Redis infrastructure
* Eliminates random 500/503 errors during high load periods
* Improved overall platform stability
## Aggregated Price Updates
We've added a new WebSocket room that provides aggregated price data across multiple liquidity pools for any token.
### What's New
**`price:aggregated:{tokenAddress}`**
* **Multi-pool aggregation** — Get median, average, min, and max prices calculated across top liquidity pools
* **Top pools data** — Detailed breakdown of the 10 highest liquidity pools with individual prices
* **Real-time updates** — Live price aggregation as pools update
* **Pool count tracking** — Know exactly how many pools contributed to the aggregated data
* **Automatic pool rotation** - No need to subscribe to new rooms after token migration.
### Why Use Aggregated Pricing?
Single pool prices can be manipulated or show temporary volatility. Aggregated pricing gives you:
* **More accurate market prices** — Median and average across multiple sources
* **Manipulation resistance** — Harder to distort when aggregating across pools
* **Price range visibility** — See min/max spread to identify arbitrage opportunities
* **Liquidity-weighted insights** — Focus on pools that matter most
```json theme={null}
{
"type": "message",
"data": {
"token": "So11111111111111111111111111111111111111112",
"timestamp": 1762964449215,
"price": 153.70666202103925,
"pool": "3nMFwZXwY1s1M5s8vYAHqd4wGs4iSxXE4LRoUMMYqEgF",
"aggregated": {
"median": 153.6850599485249,
"average": 153.6735820182654,
"min": 153.36863801111053,
"max": 153.71662179961638,
"poolCount": 10
},
"topPools": [
{
"poolId": "3ucNos4NbumPLZNWztqGHNFFgkHeRMBQAVemeeomsUxv",
"price": 153.68241854665007,
"liquidity": 17950616.091940343,
"market": "raydium-clmm"
},
...
]
},
"room": "price:aggregated:So11111111111111111111111111111111111111112"
}
```
Perfect for trading interfaces, price oracles, and portfolio tracking applications that need reliable, manipulation-resistant pricing.
[View documentation →](/datastream/websockets/priceaggregated)
## Ridge Stream — Enhanced Holder Data
All holder endpoints and real-time streams have been migrated to **Ridge Stream**, from our new high-performance service RidgeDB
### What's New
**Real-Time Streams**
* **Holder count updates** — Live tracking of total holders
* **Wallet balance updates** — Now includes native SOL with improved reliability
* **Top 100 holders** — Real-time rankings of largest holders
* **Snipers and insiders** — Track early buyers and insider activity
No updates yet. Check back soon!
## New Documentation Site
We've launched a brand-new documentation hub that brings all our products and APIs together — complete with guides, SDKs, and hands-on examples.
You can now explore detailed docs for:
* **Yellowstone gRPC** — Real-time Solana data streaming
* **Data API** — REST access to historical and live Solana data
* **Datastream** — WebSocket-based live data feeds
* **Solana RPC** — Enhanced endpoints powered by Ridge DB
* **Swap API** — High-performance token swaps and routing
The new docs include interactive code samples, SDK walkthroughs, and best practices to help you build faster and smarter on Solana.
# Get Bundlers Chart Data
Source: https://docs.solanatracker.io/data-api/chart/get-bundlers-chart-data
data-api/openapi.json get /bundlers/chart/{token}
Gets bundler holding percentage data over time. Returns up to 1000 of the most recent data points
# Get Holders Chart Data
Source: https://docs.solanatracker.io/data-api/chart/get-holders-chart-data
data-api/openapi.json get /holders/chart/{token}
Gets token holder count data over time. Returns up to 1000 of the most recent data points
# Get Insiders Chart Data
Source: https://docs.solanatracker.io/data-api/chart/get-insiders-chart-data
data-api/openapi.json get /insiders/chart/{token}
Gets insider holding percentage data over time. Returns up to 1000 of the most recent data points
# Get OHLCV Data for a token
Source: https://docs.solanatracker.io/data-api/chart/get-ohlcv-data-for-a-token
data-api/openapi.json get /chart/{token}
Gets OHLCV (Open, High, Low, Close, Volume) data for charts
# Get OHLCV Data for a token/pool pair
Source: https://docs.solanatracker.io/data-api/chart/get-ohlcv-data-for-a-tokenpool-pair
data-api/openapi.json get /chart/{token}/{pool}
Gets OHLCV (Open, High, Low, Close, Volume) data for charts for a specific pool
# Get Snipers Chart Data
Source: https://docs.solanatracker.io/data-api/chart/get-snipers-chart-data
data-api/openapi.json get /snipers/chart/{token}
Gets sniper holding percentage data over time. Returns up to 1000 of the most recent data points
# Get API Credits
Source: https://docs.solanatracker.io/data-api/credits/get-api-credits
data-api/openapi.json get /credits
Gets the remaining API credits for your API key
# Get Subscription Information
Source: https://docs.solanatracker.io/data-api/credits/get-subscription-information
data-api/openapi.json get /subscription
Gets current subscription information including credits, plan, and billing details
# Get Pool Events
Source: https://docs.solanatracker.io/data-api/events/get-pool-events
data-api/openapi.json get /events/{tokenAddress}/{poolAddress}
Gets raw event data for a specific token and pool. Returns binary data that needs to be decoded
# Get Token Events
Source: https://docs.solanatracker.io/data-api/events/get-token-events
data-api/openapi.json get /events/{tokenAddress}
Gets raw event data for live processing. Returns binary data that needs to be decoded
# Get First Token Buyers
Source: https://docs.solanatracker.io/data-api/pnl/get-first-token-buyers
data-api/openapi.json get /first-buyers/{token}
Retrieves the first 100 buyers of a token (since API started recording data) with PnL data for each wallet
# Get Token-Specific PnL
Source: https://docs.solanatracker.io/data-api/pnl/get-token-specific-pnl
data-api/openapi.json get /pnl/{wallet}/{token}
Gets Profit and Loss data for a specific token in a wallet
# Get Wallet PnL
Source: https://docs.solanatracker.io/data-api/pnl/get-wallet-pnl
data-api/openapi.json get /pnl/{wallet}
Gets Profit and Loss data for all positions of a wallet
# Get Historic Price Information
Source: https://docs.solanatracker.io/data-api/price/get-historic-price-information
data-api/openapi.json get /price/history
Gets historic price information for a single token
# Get lowest and highest price in time range
Source: https://docs.solanatracker.io/data-api/price/get-lowest-and-highest-price-in-time-range
data-api/openapi.json get /price/history/range
Gets the lowest and highest price in a time range
# Get Multiple Token Prices
Source: https://docs.solanatracker.io/data-api/price/get-multiple-token-prices
data-api/openapi.json get /price/multi
Gets price information for multiple tokens (up to 100)
# Get Price at Specific Timestamp
Source: https://docs.solanatracker.io/data-api/price/get-price-at-specific-timestamp
data-api/openapi.json get /price/history/timestamp
Gets specific historic price information for a token at a given timestamp
# Get Token Price
Source: https://docs.solanatracker.io/data-api/price/get-token-price
data-api/openapi.json get /price
Gets price information for a single token
# Post Multiple Token Prices
Source: https://docs.solanatracker.io/data-api/price/post-multiple-token-prices
data-api/openapi.json post /price/multi
Similar to GET /price/multi, but accepts an array of token addresses in the request body
# Risk Score
Source: https://docs.solanatracker.io/data-api/risk
Token risk assessment methodology and scoring system
The Risk Score API evaluates token investment risk across multiple factors, generating a normalized score from 1-10 to help users make informed trading decisions on Solana.
## Risk Categories
Risk factors are organized into four severity-based categories:
Potential issues requiring attention but may have legitimate explanations
Significant red flags indicating high risk or potential malicious activity
Token liquidity and holder concentration issues
Early buyer and insider wallet concentration risks
## Scoring Methodology
Final risk scores are normalized to 1-10 based on the sum of individual risk factor weights. Higher scores indicate higher risk.
## Warning Risk Factors
| Risk Factor | Description | Score |
| ------------------------ | --------------------------------------------------------------------- | ---------- |
| No social media | Token has no associated social media links | 2000 |
| No file metadata | Token has no file metadata | 100 |
| Pump.fun contract risks | Pump.fun contracts can be changed by Pump.fun at any time | 10 |
| Incomplete bonding curve | No Raydium liquidity pool, bonding curve not complete | 4000 |
| Transitioning to Raydium | Token is currently transitioning to Raydium | 100 |
| Price decrease | Price decreased by more than 50% in the last 24 hours | 1000 |
| Suspicious Volume | High percentage of buy transactions indicating potential manipulation | 1000-10000 |
## Danger Risk Factors
| Risk Factor | Description | Score |
| ------------------------ | --------------------------------------------------------------- | ----- |
| Freeze Authority Enabled | Tokens can be frozen and prevented from trading in the future | 7500 |
| Mint Authority Enabled | More tokens can be minted by the owner at any time | 2500 |
| Rugged | No liquidity, token is considered unsafe to purchase (Rugcheck) | 20000 |
| LP Burned | Allows the owner to remove liquidity at any time | 4000 |
### Dynamic Fee Risk (Meteora Curve)
| Fee Range | Level | Score |
| --------- | ------ | ----- |
| >5% | Danger | 1000 |
| >10% | Danger | 1500 |
| >20% | Danger | 3000 |
| >40% | Danger | 4000 |
| >50% | Danger | 5000 |
| >75% | Danger | 7500 |
## Liquidity Risk Factors
### Liquidity Levels
| Risk Factor | Description | Level | Score |
| ------------------ | ---------------------------------------------- | ------- | ----- |
| Very Low Liquidity | The total liquidity for this token is very low | Danger | 7500 |
| Low Liquidity | The total liquidity for this token is low | Warning | 5000 |
### Holders
| Threshold | Level | Score |
| --------- | ------ | ----- |
| >90% | Danger | 7000 |
| >80% | Danger | 6000 |
| >70% | Danger | 4600 |
| >60% | Danger | 4400 |
| >50% | Danger | 4300 |
| >40% | Danger | 4100 |
| >30% | Danger | 3500 |
| >20% | Danger | 2500 |
| >10% | Danger | 2000 |
| Risk Factor | Description | Level | Score |
| -------------- | ---------------------------------------------------- | ------ | ----- |
| Top 10 Holders | Top 10 holders own more than 15% of the total supply | Danger | 5000 |
## Snipers and Insiders
### Snipers Risk Levels
Wallets that bought tokens within the first few transactions or blocks:
| Ownership Percentage | Level | Score |
| -------------------- | ------- | ----- |
| >50% | Danger | 10000 |
| >30% | Danger | 6000 |
| >20% | Danger | 4000 |
| >10% | Warning | 3000 |
### Insiders Risk Levels
Wallets potentially connected to token creators or team:
| Ownership Percentage | Level | Score |
| -------------------- | ------- | ----- |
| >50% | Danger | 10000 |
| >30% | Danger | 7000 |
| >20% | Danger | 5000 |
| >10% | Warning | 3000 |
### Bundlers Risk Levels
Wallets that bundled tokens (bought in coordinated groups):
| Count/Percentage | Level | Score |
| ---------------- | ------- | ----- |
| ≥1000 wallets | Danger | 15000 |
| ≥500 wallets | Danger | 10000 |
| ≥100 wallets | Warning | 5000 |
| ≥1 wallet | Warning | 2000 |
| Ownership Percentage | Level | Score |
| -------------------- | ------- | ----- |
| >50% | Danger | 15000 |
| >30% | Danger | 10000 |
| >15% | Danger | 7000 |
| >5% | Warning | 3000 |
### Developer Holdings Risk Levels
Wallets identified as belonging to the token developer or creator:
| Ownership Percentage | Level | Score |
| -------------------- | ------- | ----- |
| >50% | Danger | 10000 |
| >30% | Danger | 8000 |
| >20% | Danger | 6000 |
| >10% | Danger | 4000 |
| >5% | Warning | 2500 |
| >1% | Warning | 1000 |
## API Response
Risk scores are returned on all `token` objects with enhanced snipers, insiders, bundlers, and developer data.
```json theme={null}
{
"risk": {
"snipers": {
"count": 5,
"totalBalance": 50000000,
"totalPercentage": 12.5,
"wallets": [
{
"address": "WalletAddress1...",
"balance": 20000000,
"percentage": 5.0
}
]
},
"insiders": {
"count": 3,
"totalBalance": 30000000,
"totalPercentage": 7.5,
"wallets": [
{
"address": "WalletAddress2...",
"balance": 15000000,
"percentage": 3.75
}
]
},
"bundlers": {
"count": 25,
"totalBalance": 10000000,
"totalPercentage": 2.5,
"wallets": [
{
"address": "BundleWallet1...",
"balance": 500000,
"percentage": 0.125
}
]
},
"top10": 25.5,
"dev": {
"percentage": 15.0,
"amount": 15000000
},
"rugged": false,
"risks": [
{
"name": "Snipers",
"description": "Snipers own 12.50% of the total supply.",
"value": "12.50%",
"level": "warning",
"score": 3000
},
{
"name": "Bundler Holdings",
"description": "Bundlers own 2.50% of the total supply.",
"value": "2.50%",
"level": "warning",
"score": 3000
},
{
"name": "Dev Holdings",
"description": "Developer holds 15.00% of the total supply.",
"value": "15.00%",
"level": "danger",
"score": 4000
},
{
"name": "Bonding curve not complete",
"description": "No raydium liquidity pool, bonding curve not complete",
"level": "warning",
"score": 4000
}
],
"score": 5,
"jupiterVerified": false
}
}
```
# Token Search
Source: https://docs.solanatracker.io/data-api/search/token-search
data-api/openapi.json get /search
Searches for tokens by symbol, name, or address with various filtering and sorting options
# Get Token-Pool Stats
Source: https://docs.solanatracker.io/data-api/stats/get-token-pool-stats
data-api/openapi.json get /stats/{token}/{pool}
Gets detailed stats for a token-pool pair over various time intervals
# Get Token Stats
Source: https://docs.solanatracker.io/data-api/stats/get-token-stats
data-api/openapi.json get /stats/{token}
Gets detailed stats for a token over various time intervals
# Get All-Time High Price
Source: https://docs.solanatracker.io/data-api/tokens/get-all-time-high-price
data-api/openapi.json get /tokens/{tokenAddress}/ath
Retrieves the all-time high price of a token (since the data API started recording)
# Get All Token Holders (Paginated)
Source: https://docs.solanatracker.io/data-api/tokens/get-all-token-holders-paginated
data-api/openapi.json get /tokens/{tokenAddress}/holders/paginated
Gets token holders with cursor-based pagination support. Returns holders sorted by amount in descending order.
# Get Graduated Tokens
Source: https://docs.solanatracker.io/data-api/tokens/get-graduated-tokens
data-api/openapi.json get /tokens/multi/graduated
Overview of all graduated launchpad tokens (Pump.fun, letsbonk.fun, jupiter studio etc)
# Get Graduating Tokens
Source: https://docs.solanatracker.io/data-api/tokens/get-graduating-tokens
data-api/openapi.json get /tokens/multi/graduating
Overview of all graduating launchpad tokens (Pump.fun, letsbonk.fun, jupiter studio etc)
# Get Latest Tokens
Source: https://docs.solanatracker.io/data-api/tokens/get-latest-tokens
data-api/openapi.json get /tokens/latest
Retrieves the latest 100 tokens
# Get Multiple Tokens
Source: https://docs.solanatracker.io/data-api/tokens/get-multiple-tokens
data-api/openapi.json post /tokens/multi
Accepts an array of token addresses in the request body (up to 20 per request)
# Get Token Bundlers
Source: https://docs.solanatracker.io/data-api/tokens/get-token-bundlers
data-api/openapi.json get /tokens/{token}/bundlers
Retrieves bundler information for a specific token, including top 500 bundler wallets and statistics
# Get Token by Pool Address
Source: https://docs.solanatracker.io/data-api/tokens/get-token-by-pool-address
data-api/openapi.json get /tokens/by-pool/{poolAddress}
Retrieves token information by searching with a pool address
# Get Token Holders (Top 100)
Source: https://docs.solanatracker.io/data-api/tokens/get-token-holders-top-100
data-api/openapi.json get /tokens/{tokenAddress}/holders
Gets the top 100 holders for a specific token and the total amount
# Get Token Information
Source: https://docs.solanatracker.io/data-api/tokens/get-token-information
data-api/openapi.json get /tokens/{tokenAddress}
Retrieves comprehensive information about a specific token
# Get Token Overview
Source: https://docs.solanatracker.io/data-api/tokens/get-token-overview
data-api/openapi.json get /tokens/multi/all
Gets an overview of latest, graduating, and graduated tokens (Axiom Pulse / Photon Memescope style)
# Get Tokens by Deployer
Source: https://docs.solanatracker.io/data-api/tokens/get-tokens-by-deployer
data-api/openapi.json get /deployer/{wallet}
Retrieves all tokens created by a specific wallet with pagination support
# Get Tokens by Volume
Source: https://docs.solanatracker.io/data-api/tokens/get-tokens-by-volume
data-api/openapi.json get /tokens/volume
Retrieves the top 100 tokens sorted by highest volume within the default timeframe
# Get Tokens by Volume with Timeframe
Source: https://docs.solanatracker.io/data-api/tokens/get-tokens-by-volume-with-timeframe
data-api/openapi.json get /tokens/volume/{timeframe}
Retrieves the top 100 tokens sorted by highest volume within the specified timeframe
# Get Top 20 Token Holders
Source: https://docs.solanatracker.io/data-api/tokens/get-top-20-token-holders
data-api/openapi.json get /tokens/{tokenAddress}/holders/top
Gets the top 20 holders for a token
# Get Top Performing Tokens
Source: https://docs.solanatracker.io/data-api/tokens/get-top-performing-tokens
data-api/openapi.json get /top-performers/{timeframe}
Retrieves the top performing tokens launched today within the specified timeframe
# Get Trending Tokens
Source: https://docs.solanatracker.io/data-api/tokens/get-trending-tokens
data-api/openapi.json get /tokens/trending
Gets the top 100 trending tokens based on transaction volume in the specified timeframe (default: past hour)
# Get Trending Tokens by Timeframe
Source: https://docs.solanatracker.io/data-api/tokens/get-trending-tokens-by-timeframe
data-api/openapi.json get /tokens/trending/{timeframe}
Gets the top 100 trending tokens based on transaction volume in the specified timeframe
# Get Top Traders (All Tokens)
Source: https://docs.solanatracker.io/data-api/top-traders/get-top-traders-all-tokens
data-api/openapi.json get /top-traders/all
Gets the most profitable traders across all tokens
# Get Top Traders (All Tokens) with Pagination
Source: https://docs.solanatracker.io/data-api/top-traders/get-top-traders-all-tokens-with-pagination
data-api/openapi.json get /top-traders/all/{page}
Gets the most profitable traders across all tokens, with optional pagination
# Get Top Traders for Specific Token
Source: https://docs.solanatracker.io/data-api/top-traders/get-top-traders-for-specific-token
data-api/openapi.json get /top-traders/{token}
Gets top 100 traders by PnL for a token
# Get Pool-Specific Trades
Source: https://docs.solanatracker.io/data-api/trades/get-pool-specific-trades
data-api/openapi.json get /trades/{tokenAddress}/{poolAddress}
Gets the latest trades for a specific token and pool pair
# Get Token Trades
Source: https://docs.solanatracker.io/data-api/trades/get-token-trades
data-api/openapi.json get /trades/{tokenAddress}
Gets the latest trades for a token across all pools
# Get User-Specific Pool Trades
Source: https://docs.solanatracker.io/data-api/trades/get-user-specific-pool-trades
data-api/openapi.json get /trades/{tokenAddress}/{poolAddress}/{owner}
Gets the latest trades for a specific token, pool, and wallet address
# Get User-Specific Token Trades
Source: https://docs.solanatracker.io/data-api/trades/get-user-specific-token-trades
data-api/openapi.json get /trades/{tokenAddress}/by-wallet/{owner}
Gets the latest trades for a specific token and wallet address
# Get Basic Wallet Information
Source: https://docs.solanatracker.io/data-api/wallet/get-basic-wallet-information
data-api/openapi.json get /wallet/{owner}/basic
Gets all tokens in a wallet with current value in USD (lightweight, non-cached option)
# Get Wallet Portfolio Chart
Source: https://docs.solanatracker.io/data-api/wallet/get-wallet-portfolio-chart
data-api/openapi.json get /wallet/{owner}/chart
Gets wallet portfolio chart data with historical values and PnL information
# Get Wallet Tokens
Source: https://docs.solanatracker.io/data-api/wallet/get-wallet-tokens
data-api/openapi.json get /wallet/{owner}
Gets all tokens in a wallet with current value in USD
# Get Wallet Tokens with Pagination
Source: https://docs.solanatracker.io/data-api/wallet/get-wallet-tokens-with-pagination
data-api/openapi.json get /wallet/{owner}/page/{page}
Retrieves wallet tokens using pagination with a limit of 250 tokens per request
# Get Wallet Trades
Source: https://docs.solanatracker.io/data-api/wallet/get-wallet-trades
data-api/openapi.json get /wallet/{owner}/trades
Gets the latest trades of a wallet
# Bundlers
Source: https://docs.solanatracker.io/datastream/websockets/bundlers
Subscribe to bundler wallet activity changes for a token
# Curve percentage
Source: https://docs.solanatracker.io/datastream/websockets/curvepercentage
Subscribe to curve percentage alerts (when tokens reach specific bonding curve percentages)
# Developer holdings
Source: https://docs.solanatracker.io/datastream/websockets/developerholdings
Subscribe to developer holdings changes for a token
# Fee tracking
Source: https://docs.solanatracker.io/datastream/websockets/feetracking
Subscribe to fee tracking for a token (Global fees)
# Graduated
Source: https://docs.solanatracker.io/datastream/websockets/graduated
Subscribe to just graduated tokens
# Graduating
Source: https://docs.solanatracker.io/datastream/websockets/graduating
Subscribe to tokens that are graduating (approaching bonding curve completion)
# Holders
Source: https://docs.solanatracker.io/datastream/websockets/holders
Subscribe to holder count changes for a token
# Insider tracking
Source: https://docs.solanatracker.io/datastream/websockets/insidertracking
Subscribe to insider balance and percentage changes for a token
# Latest tokens
Source: https://docs.solanatracker.io/datastream/websockets/latesttokens
Subscribe to new tokens and pools created on Solana.
# Metadata
Source: https://docs.solanatracker.io/datastream/websockets/metadata
Subscribe to token metadata updates
# Pool statistics
Source: https://docs.solanatracker.io/datastream/websockets/poolstatistics
Subscribe to pool statistics (multi-timeframe statistics)
# Pool transactions
Source: https://docs.solanatracker.io/datastream/websockets/pooltransactions
Subscribe to transactions for a specific token in a specific pool
# Pool updates
Source: https://docs.solanatracker.io/datastream/websockets/poolupdates
Subscribe to pool updates for a specific pool
# Pool wallet transactions
Source: https://docs.solanatracker.io/datastream/websockets/poolwallettransactions
Subscribe to transactions for pool and wallet
# Price aggregated
Source: https://docs.solanatracker.io/datastream/websockets/priceaggregated
Subscribe to aggregated price updates across multiple pools for a token
# Price all pools
Source: https://docs.solanatracker.io/datastream/websockets/priceallpools
Subscribe to price updates for a token from all pools
# Price by pool
Source: https://docs.solanatracker.io/datastream/websockets/pricebypool
Subscribe to price updates for a specific pool
# Price by token
Source: https://docs.solanatracker.io/datastream/websockets/pricebytoken
Subscribe to price updates for a specific token from the primary pool
# Sniper tracking
Source: https://docs.solanatracker.io/datastream/websockets/snipertracking
Subscribe to sniper balance and percentage changes for a token
# Token changes
Source: https://docs.solanatracker.io/datastream/websockets/tokenchanges
Subscribe to all pool changes for a token
# Token primary
Source: https://docs.solanatracker.io/datastream/websockets/tokenprimary
Subscribe to primary pool updates for a token (based on liquidity)
# Token statistics
Source: https://docs.solanatracker.io/datastream/websockets/tokenstatistics
Subscribe to token stats (multi-timeframe statistics)
# Token transactions
Source: https://docs.solanatracker.io/datastream/websockets/tokentransactions
Subscribe to swap transactions for a token
# Top10 holders
Source: https://docs.solanatracker.io/datastream/websockets/top10holders
Subscribe to top 10 holders percentage changes for a token
# Wallet balance
Source: https://docs.solanatracker.io/datastream/websockets/walletbalance
Subscribe to wallet balance changes
# Wallet token balance
Source: https://docs.solanatracker.io/datastream/websockets/wallettokenbalance
Subscribe to specific token balance changes for a wallet
# Wallet transactions
Source: https://docs.solanatracker.io/datastream/websockets/wallettransactions
Subscribe to swap transactions for a wallet
# Get Started
Source: https://docs.solanatracker.io/index
Build fast, scalable Solana apps with powerful APIs, real-time data, and enterprise-grade RPC.
Everything you need to build on Solana.
Trade across all major Solana DEXs.
Yellowstone gRPC streams with unlimited bandwidth.
Custom RPC methods like our getProgramAccountsV2 endpoint.
## RPC Infrastructure
Global, low-latency Solana RPC nodes.
Private, high-performance infrastructure.
## Streaming & Data APIs
Fastest shreds powered by Jito, available on all plans
Real-time token and wallet data.
Official Solana websocket RPC methods
Official Solana http methods
Your first API call in seconds.
Compare shared and dedicated RPC nodes.
Pricing for token, market, and analytics data.
## Core APIs
## Connect
Connect with 1,500+ Solana developers.
Contact the SolanaTracker team.
# Quick Start
Source: https://docs.solanatracker.io/quickstart
Get up and running with the Solana Tracker Data API in under 5 minutes
This guide will help you make your first API calls to the Solana Tracker Data API. You'll learn how to authenticate, make requests, and handle responses.
## Prerequisites
Before you begin, make sure you have:
Sign up for free to get your API key.
## Step 1: Get Your API Key
After creating your account, retrieve your API key from the dashboard. This key is used to authenticate your requests by passing it in the `x-api-key` header.
Visit [your account dashboard](https://www.solanatracker.io/account).
Click on the "API Keys" section in the sidebar.
Click the copy button next to your API key.
Keep your API key secure and never commit it to public repositories.
## Step 2: Make Your First API Call
Let's start by fetching the current price of SOL using the `/price` endpoint.
```bash cURL theme={null}
curl -X GET "https://data.solanatracker.io/price?token=So11111111111111111111111111111111111111112" \
-H "x-api-key: YOUR_API_KEY"
```
```javascript JavaScript theme={null}
const apiKey = 'YOUR_API_KEY';
const solMint = 'So11111111111111111111111111111111111111112';
fetch(`https://data.solanatracker.io/price?token=${solMint}`, {
headers: {
'x-api-key': apiKey
}
})
.then(response => response.json())
.then(data => console.log('SOL Price:', data.price));
```
```python Python theme={null}
import requests
api_key = 'YOUR_API_KEY'
sol_mint = 'So11111111111111111111111111111111111111112'
response = requests.get(
f'https://data.solanatracker.io/price?token={sol_mint}',
headers={
'x-api-key': api_key
}
)
data = response.json()
print(f"SOL Price: ${data['price']}")
```
```json Success Response theme={null}
{
"price": 175.42,
"priceQuote": 175.42,
"liquidity": 14187570.69,
"marketCap": 99213713748.19,
"lastUpdated": 1760274132867
}
```
## Step 3: Connect to RPC Nodes
In addition to the Data API, Solana Tracker provides high-performance RPC nodes for direct blockchain interactions. Note that the RPC endpoint URL and authentication method (passing the API key in the URL path) are different from the Data API.
```javascript @solana/web3.js theme={null}
import { Connection, PublicKey } from '@solana/web3.js';
const connection = new Connection(
'https://rpc-mainnet.solanatracker.io?api_key=YOUR_API_KEY',
{
commitment: 'confirmed',
wsEndpoint: 'wss://rpc-mainnet.solanatracker.io?api_key=YOUR_API_KEY'
}
);
// Get account balance
const publicKey = new PublicKey('YOUR_WALLET_ADDRESS');
const balance = await connection.getBalance(publicKey);
console.log(`Balance: ${balance / 1e9} SOL`);
// Subscribe to account changes
connection.onAccountChange(
publicKey,
(accountInfo) => {
console.log('Account updated:', accountInfo);
}
);
```
```python solana.py theme={null}
from solana.rpc.api import Client
from solders.pubkey import Pubkey
# Connect to RPC
client = Client("https://rpc-mainnet.solanatracker.io?api_key=YOUR_API_KEY")
# Get account balance
pubkey = Pubkey.from_string("YOUR_WALLET_ADDRESS")
response = client.get_balance(pubkey)
balance = response.value / 1e9
print(f"Balance: {balance} SOL")
# Get recent blockhash
blockhash = client.get_latest_blockhash()
print(f"Recent blockhash: {blockhash.value.blockhash}")
```
## Step 4: Explore Common Use Cases
Monitor real-time price changes for any SPL token using the `/price` endpoint.
```javascript theme={null}
const trackPrice = async (mint) => {
const response = await fetch(
`https://data.solanatracker.io/price?token=${mint}`,
{ headers: { 'x-api-key': API_KEY } }
);
const data = await response.json();
console.log(`Price: $${data.price}`);
};
// Track price every 5 seconds
setInterval(() => trackPrice('YOUR_TOKEN_MINT'), 5000);
```
Discover newly created tokens by using the `/search` endpoint and sorting by creation time.
```javascript theme={null}
const findNewTokens = async () => {
const response = await fetch(
'https://data.solanatracker.io/tokens/latest',
{ headers: { 'x-api-key': API_KEY } }
);
const result = await response.json();
result.data.forEach(token => {
console.log(`New token: ${token.token.symbol} on ${token.pools[0].market}`);
console.log(`Liquidity: $${token.pools[0].liquidity.usd}`);
});
};
```
Track token holdings and the total portfolio value for any wallet.
```javascript theme={null}
const getWalletTokens = async (walletAddress) => {
const response = await fetch(
`https://data.solanatracker.io/wallet/${walletAddress}`,
{ headers: { 'x-api-key': API_KEY } }
);
const portfolio = await response.json();
console.log(`Total Portfolio Value: $${portfolio.total}`);
portfolio.tokens.forEach(holding => {
const tokenInfo = holding.token;
console.log(`${tokenInfo.symbol}: ${holding.balance} ($${holding.value.toFixed(2)})`);
});
};
```
## Error Handling
Always implement proper error handling in your applications.
```javascript JavaScript theme={null}
try {
const response = await fetch('https://data.solanatracker.io/price?token=INVALID_TOKEN_ADDRESS', {
headers: { 'x-api-key': API_KEY }
});
if (!response.ok) {
const error = await response.json();
console.error(`API Error: ${error.message || response.statusText}`);
// Handle specific error codes
switch (response.status) {
case 401:
console.error('Invalid API key');
break;
case 429:
console.error('Rate limit exceeded');
break;
case 500:
console.error('Server error - please retry');
break;
}
} else {
const data = await response.json();
// Process successful response
}
} catch (error) {
console.error('Network error:', error);
}
```
```python Python theme={null}
import requests
from time import sleep
def api_call_with_retry(url, headers, max_retries=3):
for attempt in range(max_retries):
try:
response = requests.get(url, headers=headers)
if response.status_code == 200:
return response.json()
elif response.status_code == 429:
# Rate limited - wait and retry
print(f"Rate limit exceeded. Retrying in {2 ** attempt}s...")
sleep(2 ** attempt) # Exponential backoff
elif response.status_code == 401:
raise Exception("Invalid API key")
else:
print(f"Error {response.status_code}: {response.text}")
break
except requests.RequestException as e:
print(f"Network error: {e}")
if attempt < max_retries - 1:
sleep(1)
else:
raise
return None
```
**Need help?** Join our [Discord community](https://discord.gg/JH2e9rR9fc) or email [support@solanatracker.io](mailto:support@solanatracker.io).
# Build swap instructions
Source: https://docs.solanatracker.io/raptor/http/build-swap-instructions
raptor/http/openapi.json post /swap-instructions
Build swap instructions without transaction wrapper
# Build swap transaction
Source: https://docs.solanatracker.io/raptor/http/build-swap-transaction
raptor/http/openapi.json post /swap
Build a complete swap transaction from a quote
# Get swap quote
Source: https://docs.solanatracker.io/raptor/http/get-swap-quote
raptor/http/openapi.json get /quote
Get the best swap quote across all supported DEXes with optimal routing
# Get transaction status
Source: https://docs.solanatracker.io/raptor/http/get-transaction-status
raptor/http/openapi.json get /transaction/{signature}
Get the current status and details of a tracked transaction
# Quote and swap in one request
Source: https://docs.solanatracker.io/raptor/http/quote-and-swap-in-one-request
raptor/http/openapi.json post /quote-and-swap
Get quote and build transaction in single request
# Send transaction via Yellowstone Jet TPU
Source: https://docs.solanatracker.io/raptor/http/send-transaction-via-yellowstone-jet-tpu
raptor/http/openapi.json post /send-transaction
Send a signed transaction with ultra-low latency via Yellowstone Jet TPU
# Overview
Source: https://docs.solanatracker.io/raptor/overview
DEX aggregator and Swap API for Solana
**Public Beta** — Join [Discord](https://discord.gg/Gfnwee4T6S) for support queries.
**Binary Release** - Now available. [Github](https://github.com/solanatracker/raptor-binary)
***
## Endpoints
### Swap
| Endpoint | Description |
| ----------------------------- | ----------------------------------------------------------------------------------------------------------------- |
| `GET /quote` | Get swap quotes with multi-hop routing, dynamic slippage, DEX filtering, pool filtering, and platform fee support |
| `POST /swap` | Build complete swap transactions with priority fee calculation and compute budget optimization |
| `POST /swap-instructions` | Build swap instructions only (without transaction wrapper) |
| `POST /quote-and-swap` | Combined quote and swap in single request (optional feature) |
| `POST /send-transaction` | Send transactions via Yellowstone Jet TPU with automatic resending and confirmation tracking |
| `GET /transaction/:signature` | Track sent transaction status, latency, and parsed events |
### Analytics
| Endpoint | Description |
| ------------- | ------------------------------------------------------------------------ |
| `GET /health` | Health check with detailed status (pools, cache, Yellowstone connection) |
***
## WebSocket
| Feature | Details |
| ------------------ | --------------------------------------------------------------------------- |
| `/stream` | Real-time quote streaming with subscription management |
| `/stream/swap` | Real-time streaming swap quotes with pre-built transactions (ready to sign) |
| Slot-based updates | Automatic quote recalculation on pool state changes |
***
Program ID - Mainnet: RaptorD5ojtsqDDtJeRsunPLg6GvLYNnwKJWxYE4m87
## Supported DEXs
### Raydium
* Raydium AMM
* Raydium CLMM
* Raydium CPMM
* Raydium LaunchLab/Launchpad
### Meteora
* Meteora DLMM
* Meteora Dynamic AMM
* Meteora DAMM (Dynamic AMM V2)
* Meteora Curve
* Meteora DBC (Dynamic Bonding Curve)
### Orca
* Whirlpool (legacy)
* Whirlpool V2
### Bonding Curves
* Pump.fun
* Pumpswap
* Heaven (Buy/Sell)
* MoonIt (Buy/Sell)
* Boopfun (Buy/Sell)
### PropAMM
* Humidifi
* Tessera
* Solfi V1/V2
### Other
* FluxBeam
* PancakeSwap V3
***
## Routing
### Multi-Hop
* Up to 4-hop routes for optimal pricing
* Route-aware slippage calculation (accounts for multi-hop risk)
* DEX-specific routing preferences
* Pool filtering by address lists
* Circular arbitrage option
### Slippage
* Dynamic slippage based on volatility and route complexity
* Route-aware multi-hop slippage adjustment
* Manual slippage override (numeric or `"dynamic"`)
* Minimum output amount calculation with slippage protection
### Platform Fees
* Fee taken from input OR output tokens
* Configurable fee basis points (up to 10%)
* Fee wallet specification
* Extra charge on positive slippage
* Automatic fee adjustment in quotes and swaps
***
## Priority Fees
### Dynamic Calculation
* Route-specific priority fee calculation
* DEX-specific fee adjustments
* Recent fee data tracking (slots tracked, total fees)
* Maximum fee caps and overrides
### Priority Levels
| Level | Use Case |
| --------------------- | ------------------- |
| `Min` / `Low` | Cost-saving |
| `Auto` / `Medium` | Recommended default |
| `High` / `VeryHigh` | Speed priority |
| `Turbo` / `UnsafeMax` | Maximum speed |
***
## Transaction Management
### Yellowstone Jet TPU
* Transaction sending
* Automatic resending with slot alignment
* Multiple identity support (4 default, configurable)
### Tracking
* Real-time status monitoring (`pending` / `confirmed` / `failed` / `expired`)
* Latency measurement (send to confirm)
* Parsed Raptor program events
* Raw transaction storage
* Automatic cleanup
### Rate Limiting
* Configurable RPS (uses few RPC calls generally)
***
## CLI Flags
### Help & Version
```
-h, --help Show help message
-v, --version Show version information
```
### Pool Indexer
```
--no-pool-indexer Disable pool indexer client (Yellowstone only)
```
### DEX Filtering
```
--include-dexes Only include these DEXes (comma-separated)
--exclude-dexes Exclude these DEXes (comma-separated)
```
### Performance
```
--workers Number of worker threads (default: CPU cores)
```
### Feature Toggles
```
--enable-arbitrage Enable circular arbitrage (same input/output mint)
-s, --enable-quote-and-swap Enable the /quote-and-swap endpoint
--rpc-rate-limit Limit RPC calls to N per second (default: unlimited)
--enable-yellowstone-jet Enable Yellowstone Jet TPU sender for /send-transaction
--enable-websocket Enable WebSocket streaming quotes at /stream
```
### Yellowstone Jet TPU
```
--jet-identity Path to identity keypair for Jet TPU (optional)
--jet-identities Number of random identities for Jet (default: 4)
```
***
## Environment Variables
### CLI Flag Equivalents
| Variable | Flag |
| ------------------------ | -------------------------- |
| `NO_POOL_INDEXER` | `--no-pool-indexer` |
| `INCLUDE_DEXES` | `--include-dexes` |
| `EXCLUDE_DEXES` | `--exclude-dexes` |
| `WORKER_THREADS` | `--workers` |
| `ENABLE_ARBITRAGE` | `--enable-arbitrage` |
| `ENABLE_QUOTE_AND_SWAP` | `--enable-quote-and-swap` |
| `RPC_RATE_LIMIT` | `--rpc-rate-limit` |
| `ENABLE_YELLOWSTONE_JET` | `--enable-yellowstone-jet` |
| `JET_IDENTITY` | `--jet-identity` |
| `JET_NUM_IDENTITIES` | `--jet-identities` |
| `ENABLE_WEBSOCKET` | `--enable-websocket` |
### Additional Variables
| Variable | Description |
| ---------------------- | --------------------------------------------- |
| `RPC_URL` | Solana RPC endpoint |
| `YELLOWSTONE_ENDPOINT` | Yellowstone gRPC endpoint |
| `YELLOWSTONE_TOKEN` | Yellowstone auth token (optional) |
| `BIND_ADDR` | Server bind address (default: `0.0.0.0:8080`) |
# Transactions
Source: https://docs.solanatracker.io/raptor/transactions
Send transactions via Yellowstone Jet TPU and track confirmation status
## What This Does
* Sends transactions with low latency
* Tracks confirmation status in real time
* Automatically retries unconfirmed transactions
* Returns parsed transaction data and Raptor events
* Measures send → confirm latency
***
## Send a Transaction
Send a signed Solana transaction.
**Endpoint**
`POST /send-transaction`
**Request Body**
```json theme={null}
{
"transaction": "base64-encoded-transaction"
}
```
**Response**
```json theme={null}
{
"signature": "4vJ9JU1bJJE96FWSJKvHsmmFADCg4gpZQff4P3bkLKi",
"signature_base64": "RXNzaWduYXR1cmU=",
"success": true
}
```
**Notes**
* Returns immediately after accepting the transaction
* Sending and retrying happens in the background
* Transactions are retried for up to **30 seconds** or until confirmed
***
## Track a Transaction
Check the status of a transaction sent via `/send-transaction`.
**Endpoints**
* `GET /transaction/{signature}`
The signature can be **base58 or base64**.
**Response (example)**
```json theme={null}
{
"signature": "4vJ9JU1bJJE96FWSJKvHsmmFADCg4gpZQff4P3bkLKi",
"status": "confirmed",
"slot": 250123456,
"sent_at": 1703123456789,
"confirmed_at": 1703123456795,
"latency_ms": 6,
"transaction": { ... },
"events": [ ... ]
}
```
### Status Values
* `pending` – sent but not confirmed
* `confirmed` – finalized on-chain
* `failed` – transaction error
* `expired` – not confirmed before timeout
***
## Raptor Events
If the transaction interacts with the **Raptor program**, events are automatically parsed and returned.
**Supported Events**
* `SwapEvent`
* `SwapCompleteEvent`
* `PlaceOrderEvent`
* `FillOrderEvent`
* `CancelOrderEvent`
* `UpdateOrderEvent`
**Event Format**
```json theme={null}
{
"name": "SwapEvent",
"data": "base64-encoded-data",
"parsed": {
"dex": 1,
"amountIn": 1000000,
"amountOut": 999000
}
}
```
***
## Examples
### Send a Transaction
```js theme={null}
const response = await fetch('/send-transaction', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ transaction: signedTx })
});
const result = await response.json();
console.log(result.signature);
```
### Poll for Confirmation
```js theme={null}
async function waitForConfirmation(signature) {
for (let i = 0; i < 30; i++) {
const res = await fetch(`/transaction/${signature}`);
const tx = await res.json();
if (tx.status === 'confirmed' || tx.status === 'failed') {
return tx;
}
await new Promise(r => setTimeout(r, 1000));
}
throw new Error('Timeout');
}
```
### Read Swap Results
```js theme={null}
const tx = await fetch(`/transaction/${signature}`).then(r => r.json());
for (const event of tx.events ?? []) {
if (event.name === 'SwapEvent') {
console.log(event.parsed.amountIn, '→', event.parsed.amountOut);
}
}
```
***
## Errors
| Code | Meaning |
| ---- | --------------------------- |
| 400 | Invalid transaction |
| 404 | Transaction not tracked |
| 503 | Sender or tracking disabled |
```json theme={null}
{
"error": "Transaction not found",
"code": 404
}
```
# /stream
Source: https://docs.solanatracker.io/raptor/websocket/websockets/stream
WebSocket channel for subscribing to real-time quote updates
# /stream/swap
Source: https://docs.solanatracker.io/raptor/websocket/websockets/streamswap
WebSocket channel for streaming swap quotes with pre-built transactions. Subscribe to a token pair and receive real-time updates with ready-to-sign swap transactions whenever pool states change.
# Credits and Rate Limits
Source: https://docs.solanatracker.io/solana-rpc/credits-and-rate-limits
Credit costs and rate limits for Solana RPC API plans
Our API uses a credit-based system where different operations consume different amounts of credits. Most calls cost 1 credit, while resource-intensive operations cost 10 credits.
## Credit Costs
### Standard API Calls (1 Credit)
Most RPC methods cost 1 credit per call, including:
* Account queries (`getAccountInfo`, `getBalance`, etc.)
* Block queries (`getLatestBlockhash`, `getBlockHeight`, etc.)
* Transaction submission (`sendTransaction`)
* Priority Fee API calls
* All other methods not listed below
### Archival Data Calls (10 Credits)
Historical blockchain data retrieval costs 10 credits per call:
* `getTransaction` - Transaction details
* `getBlock` - Block information
* `getBlocks` - Multiple blocks
* `getBlockTime` - Block timestamps
* `getInflationReward` - Inflation rewards
* `getConfirmedBlock` - Confirmed block data
* `getConfirmedBlocks` - Multiple confirmed blocks
* `getConfirmedTransaction` - Confirmed transaction details
* `getConfirmedSignaturesForAddress2` - Confirmed signatures (v2)
* `getConfirmedSignaturesForAddress` - Confirmed signatures
* `getSignaturesForAddress` - All signatures for an address
### Program Account Queries
* `getProgramAccounts` - 10 credits per call
* `getTokenAccountsByOwner` - 10 credits per call
* `getProgramAccountsV2` - **1 credit per call** (custom optimized method)
* `getTokenAccountsByOwnerV2` - **1 credit per call** (custom optimized method)
* `getTokenAccountsByOwners` - **1 credit per call** (custom optimized method)
Use `getProgramAccountsV2` and `getTokenAccountsByOwnerV2` instead of their standard counterparts to reduce credit consumption by 90%.
### Digital Asset Standard (DAS) API (10 Credits)
All DAS API methods cost 10 credits per call:
* `getAsset` - Asset details
* `getAssetProof` - Merkle proof for compressed NFTs
* `getAssetsByOwner` - Assets by owner address
* `getAssetsByAuthority` - Assets by update authority
* `getAssetsByCreator` - Assets by creator address
* `getAssetsByGroup` - Assets by collection
* `searchAssets` - Search assets by criteria
* `getSignaturesForAsset` - Transaction history for an asset
* `getTokenAccounts` - Token account information
* `getNFTEditions` - NFT edition details
## Rate Limits by Plan
| Plan | Monthly Credits | General RPS | Send Transaction RPS | getProgramAccounts RPS | DAS API RPS | WebSocket Connections |
| ---------------- | --------------- | ----------- | -------------------- | ---------------------- | ----------- | --------------------- |
| **Free** | 500,000 | 10 | 1 | 1 | 2 | 2 |
| **Developer** | 15,000,000 | 60 | 5 | 15 | 10 | 25 |
| **Business** | 100,000,000 | 225 | 50 | 25 | 50 | 100 |
| **Professional** | 220,000,000 | 500 | 100 | 50 | 100 | 250 |
Rate limits are enforced per second. Requests exceeding your plan limits return a `429 Too Many Requests` error.
## Optimize Your Credit Usage
### Use Custom Methods
Replace expensive calls with optimized alternatives:
* Use `getProgramAccountsV2` instead of `getProgramAccounts`
* Use `getTokenAccountsByOwnerV2` instead of standard token account queries
### Cache Responses
Store frequently accessed data to reduce redundant API calls. Implement caching for:
* Static account data
* Historical transactions
* NFT metadata
### Implement WebSockets
Subscribe to account or program updates instead of polling:
* Real-time updates without repeated API calls
* More efficient than polling for changes
* Lower credit consumption
### Batch Operations
Group multiple queries when the API supports batching to reduce overhead.
### Monitor Usage
Track credit consumption in your dashboard to identify optimization opportunities and prevent overages.
## Frequently Asked Questions
Requests exceeding your rate limit receive a `429 Too Many Requests` HTTP error. Implement exponential backoff and retry logic in your application.
No. Credits reset at the start of each billing cycle and do not accumulate.
Yes. Upgrades take effect immediately with the new credit allowance and rate limits. This will restart your subscription.
View real-time credit consumption and rate limit usage in your account dashboard.
V2 methods like `getProgramAccountsV2` are custom optimized implementations that provide the same functionality as standard methods but consume 90% fewer credits (1 credit vs 10 credits).
## Need Help?
Contact our support team at [contact@solanatracker.io](mailto:contact@solanatracker.io) for questions about your specific use case or to discuss custom plans.
# getAccountInfo
Source: https://docs.solanatracker.io/solana-rpc/http/getaccountinfo
getaccountinfo post /
# getBalance
Source: https://docs.solanatracker.io/solana-rpc/http/getbalance
getbalance post /
Returns the lamport balance of the account at the specified address. This method provides the native SOL balance for any Solana account.
# getBlock
Source: https://docs.solanatracker.io/solana-rpc/http/getblock
getblock post /
# getBlockCommitment
Source: https://docs.solanatracker.io/solana-rpc/http/getblockcommitment
getblockcommitment post /
# getBlockHeight
Source: https://docs.solanatracker.io/solana-rpc/http/getblockheight
getblockheight post /
# getBlockProduction
Source: https://docs.solanatracker.io/solana-rpc/http/getblockproduction
getblockproduction post /
# getBlocks
Source: https://docs.solanatracker.io/solana-rpc/http/getblocks
getblocks post /
# getBlocksWithLimit
Source: https://docs.solanatracker.io/solana-rpc/http/getblockswithlimit
getblockswithlimit post /
# getBlockTime
Source: https://docs.solanatracker.io/solana-rpc/http/getblocktime
getblocktime post /
# getClusterNodes
Source: https://docs.solanatracker.io/solana-rpc/http/getclusternodes
getclusternodes post /
# getEpochInfo
Source: https://docs.solanatracker.io/solana-rpc/http/getepochinfo
getepochinfo post /
# getEpochSchedule
Source: https://docs.solanatracker.io/solana-rpc/http/getepochschedule
getepochschedule post /
# getFeeForMessage
Source: https://docs.solanatracker.io/solana-rpc/http/getfeeformessage
getfeeformessage post /
# getFirstAvailableBlock
Source: https://docs.solanatracker.io/solana-rpc/http/getfirstavailableblock
getfirstavailableblock post /
# getGenesisHash
Source: https://docs.solanatracker.io/solana-rpc/http/getgenesishash
getgenesishash post /
# getHealth
Source: https://docs.solanatracker.io/solana-rpc/http/gethealth
gethealth post /
# getHighestSnapshotSlot
Source: https://docs.solanatracker.io/solana-rpc/http/gethighestsnapshotslot
gethighestsnapshotslot post /
# getIdentity
Source: https://docs.solanatracker.io/solana-rpc/http/getidentity
getidentity post /
# getInflationGovernor
Source: https://docs.solanatracker.io/solana-rpc/http/getinflationgovernor
getinflationgovernor post /
# getInflationRate
Source: https://docs.solanatracker.io/solana-rpc/http/getinflationrate
getinflationrate post /
# getInflationReward
Source: https://docs.solanatracker.io/solana-rpc/http/getinflationreward
getinflationreward post /
# getLargestAccounts
Source: https://docs.solanatracker.io/solana-rpc/http/getlargestaccounts
getlargestaccounts post /
# getLatestBlockhash
Source: https://docs.solanatracker.io/solana-rpc/http/getlatestblockhash
getlatestblockhash post /
# getLeaderSchedule
Source: https://docs.solanatracker.io/solana-rpc/http/getleaderschedule
getleaderschedule post /
# getMaxRetransmitSlot
Source: https://docs.solanatracker.io/solana-rpc/http/getmaxretransmitslot
getmaxretransmitslot post /
# getMaxShredInsertSlot
Source: https://docs.solanatracker.io/solana-rpc/http/getmaxshredinsertslot
getmaxshredinsertslot post /
# getMinimumBalanceForRentExemption
Source: https://docs.solanatracker.io/solana-rpc/http/getminimumbalanceforrentexemption
getminimumbalanceforrentexemption post /
# getMultipleAccounts
Source: https://docs.solanatracker.io/solana-rpc/http/getmultipleaccounts
getmultipleaccounts post /
# getPriorityFeeEstimate
Source: https://docs.solanatracker.io/solana-rpc/http/getpriorityfeeestimate
getpriorityfeeestimate post /
Provides fee recommendations based on historical data, considering both global and local fee markets. Available on all Shared RPC plans and Dedicated Nodes.
# getProgramAccounts
Source: https://docs.solanatracker.io/solana-rpc/http/getprogramaccounts
getprogramaccounts post /
**⚡ Powered by Solana Ridge DB**
Get faster Solana account data with **Ridge DB**, our custom-built client designed specifically for high-performance account retrieval on Solana. Unlike standard RPC methods, Ridge DB uses specialized indexes that make querying program accounts significantly faster.
**What makes it different:**
Need to track only new accounts? Use `changedSince` to fetch accounts modified after a specific slot, perfect for incremental updates without re-fetching everything. Want to filter out dust? The `excludeZero` parameter automatically hides empty token accounts, reducing bandwidth and speeding up your queries.
Use cursor pagination to efficiently retrieve all accounts (up to 10k per request.)
**High Load Considerations**
This endpoint streams all accounts directly to your client. While this works great for most queries, it can return errors during high load or when querying programs with millions of accounts (like liquidity pools or protocol-owned accounts).
**Need better reliability?** Use **[getProgramAccountsV2](/solana-rpc/http/getprogramaccountsv2)** instead. The V2 method includes pagination support, making it more efficient and reliable for large programs and high-traffic scenarios.
# getProgramAccountsV2
Source: https://docs.solanatracker.io/solana-rpc/http/getprogramaccountsv2
getprogramaccountsv2 post /
Returns all accounts owned by the provided program Pubkey with enhanced pagination support. This V2 method provides efficient querying with cursor-based pagination, filtering capabilities, and incremental updates for large result sets.
**⚡ Powered by Solana Ridge DB**
Get faster Solana account data with **Ridge DB**, our custom-built client designed specifically for high-performance account retrieval on Solana. Unlike standard RPC methods, Ridge DB uses specialized indexes that make querying program accounts significantly faster.
**What makes it different:**
Need to track only new accounts? Use `changedSince` to fetch accounts modified after a specific slot, perfect for incremental updates without re-fetching everything. Want to filter out dust? The `excludeZero` parameter automatically hides empty token accounts, reducing bandwidth and speeding up your queries.
Use cursor pagination to efficiently retrieve all accounts (up to 10k per request.)
# getRecentPerformanceSamples
Source: https://docs.solanatracker.io/solana-rpc/http/getrecentperformancesamples
getrecentperformancesamples post /
# getRecentPrioritizationFees
Source: https://docs.solanatracker.io/solana-rpc/http/getrecentprioritizationfees
getrecentprioritizationfees post /
# getSignaturesForAddress
Source: https://docs.solanatracker.io/solana-rpc/http/getsignaturesforaddress
getsignaturesforaddress post /
# getSignatureStatuses
Source: https://docs.solanatracker.io/solana-rpc/http/getsignaturestatuses
getsignaturestatuses post /
# getSlot
Source: https://docs.solanatracker.io/solana-rpc/http/getslot
getslot post /
# getSlotLeader
Source: https://docs.solanatracker.io/solana-rpc/http/getslotleader
getslotleader post /
# getSlotLeaders
Source: https://docs.solanatracker.io/solana-rpc/http/getslotleaders
getslotleaders post /
# getStakeMinimumDelegation
Source: https://docs.solanatracker.io/solana-rpc/http/getstakeminimumdelegation
getstakeminimumdelegation post /
# getSupply
Source: https://docs.solanatracker.io/solana-rpc/http/getsupply
getsupply post /
# getTokenAccountBalance
Source: https://docs.solanatracker.io/solana-rpc/http/gettokenaccountbalance
gettokenaccountbalance post /
Returns the token balance of an SPL Token account. This method provides detailed balance information including raw amount, decimals, and human-readable formatted values for any SPL Token account address.
# getTokenAccountsByDelegate
Source: https://docs.solanatracker.io/solana-rpc/http/gettokenaccountsbydelegate
gettokenaccountsbydelegate post /
Returns all SPL Token accounts that have been delegated to a specific address. This method allows you to find token accounts where spending or management authority has been granted to a delegate, useful for tracking authorized token operations and delegated permissions.
# getTokenAccountsByOwner
Source: https://docs.solanatracker.io/solana-rpc/http/gettokenaccountsbyowner
gettokenaccountsbyowner post /
Returns all SPL Token accounts owned by the specified wallet address. This method allows you to retrieve a complete list of token holdings for any Solana wallet, useful for portfolio tracking and token balance queries.
**⚡ Powered by Solana Ridge DB**
Get faster Solana token account data with **Ridge DB**, our custom-built client designed for high-performance token account retrieval. Ridge DB uses specialized indexes that make fetching wallet token holdings significantly faster than standard RPC methods.
**What makes it different:**
Need to track only new tokens? Use `changedSince` to fetch accounts modified after a specific slot, perfect for incremental portfolio updates. Want to filter out dust? The `excludeZero` parameter automatically hides empty token accounts, keeping your results clean and reducing bandwidth.
**High Load Considerations**
This endpoint streams all token accounts directly to your client. While this works great for most wallets, it can return errors during high load or when querying wallets with millions of token accounts (like liquidity pools or protocol-owned accounts).
**Need better reliability?** Use **[getTokenAccountsByOwnerV2](/solana-rpc/http/gettokenaccountsbyownerv2)** instead. The V2 method includes pagination support, making it more efficient and reliable for large wallets and high-traffic scenarios.
# getTokenAccountsByOwners
Source: https://docs.solanatracker.io/solana-rpc/http/gettokenaccountsbyowners
gettokenaccountsbyowners post /
Returns token account balances for multiple wallets for a specific mint. Efficiently queries up to 250 wallets in a single request. Returns all token accounts per owner (if they have multiple) or zero balance if no account exists.
**⚡ Powered by Solana Ridge DB**
Get token balances for multiple wallets in a single request with **getTokenAccountsByOwners**. Powered by **Ridge DB**, our custom-built client designed for high-performance token account queries. Instead of making hundreds of individual requests, query up to 250 wallets at once for any token mint.
**What makes it different:**
Query up to 250 wallet addresses in one request, drastically reducing API calls and latency. Automatically returns all token accounts if a wallet has multiple accounts for the same mint. Wallets without a token account return a clean zero balance response instead of errors. Each account includes the slot when the balance was last updated, perfect for tracking changes and cache invalidation.
# getTokenAccountsByOwnerV2
Source: https://docs.solanatracker.io/solana-rpc/http/gettokenaccountsbyownerv2
gettokenaccountsbyownerv2 post /
Returns all SPL Token accounts owned by the provided wallet address with enhanced pagination support. This V2 method provides efficient querying with cursor-based pagination, filtering by mint or program ID, and incremental updates for portfolio tracking.
**⚡ Powered by Solana Ridge DB**
Get faster Solana account data with **Ridge DB**, our custom-built client designed specifically for high-performance account retrieval on Solana. Unlike standard RPC methods, Ridge DB uses specialized indexes that make querying program accounts significantly faster.
**What makes it different:**
Need to track only new accounts? Use `changedSince` to fetch accounts modified after a specific slot, perfect for incremental updates without re-fetching everything. Want to filter out dust? The `excludeZero` parameter automatically hides empty token accounts, reducing bandwidth and speeding up your queries.
Use cursor pagination to efficiently retrieve all accounts (up to 10k per request.)
# getTokenLargestAccounts
Source: https://docs.solanatracker.io/solana-rpc/http/gettokenlargestaccounts
gettokenlargestaccounts post /
Returns the 20 largest token accounts for a specific SPL Token mint. This method is useful for analyzing token distribution, identifying major holders, and understanding token concentration patterns.
# getTokenSupply
Source: https://docs.solanatracker.io/solana-rpc/http/gettokensupply
gettokensupply post /
Returns the total supply of an SPL Token type
# getTransaction
Source: https://docs.solanatracker.io/solana-rpc/http/gettransaction
gettransaction post /
# getTransactionCount
Source: https://docs.solanatracker.io/solana-rpc/http/gettransactioncount
gettransactioncount post /
# getVersion
Source: https://docs.solanatracker.io/solana-rpc/http/getversion
getversion post /
# getVoteAccounts
Source: https://docs.solanatracker.io/solana-rpc/http/getvoteaccounts
getvoteaccounts post /
# isBlockhashValid
Source: https://docs.solanatracker.io/solana-rpc/http/isblockhashvalid
isblockhashvalid post /
# minimumLedgerSlot
Source: https://docs.solanatracker.io/solana-rpc/http/minimumledgerslot
minimumledgerslot post /
# requestAirdrop
Source: https://docs.solanatracker.io/solana-rpc/http/requestairdrop
requestairdrop post /
# sendTransaction
Source: https://docs.solanatracker.io/solana-rpc/http/sendtransaction
sendtransaction post /
# simulateTransaction
Source: https://docs.solanatracker.io/solana-rpc/http/simulatetransaction
simulatetransaction post /
# Account subscribe
Source: https://docs.solanatracker.io/solana-rpc/websockets/accountsubscribe
# Account unsubscribe
Source: https://docs.solanatracker.io/solana-rpc/websockets/accountunsubscribe
# Block subscribe
Source: https://docs.solanatracker.io/solana-rpc/websockets/blocksubscribe
# Block unsubscribe
Source: https://docs.solanatracker.io/solana-rpc/websockets/blockunsubscribe
# Logs subscribe
Source: https://docs.solanatracker.io/solana-rpc/websockets/logssubscribe
# Logs unsubscribe
Source: https://docs.solanatracker.io/solana-rpc/websockets/logsunsubscribe
# Program subscribe
Source: https://docs.solanatracker.io/solana-rpc/websockets/programsubscribe
# Program unsubscribe
Source: https://docs.solanatracker.io/solana-rpc/websockets/programunsubscribe
# Root subscribe
Source: https://docs.solanatracker.io/solana-rpc/websockets/rootsubscribe
# Root unsubscribe
Source: https://docs.solanatracker.io/solana-rpc/websockets/rootunsubscribe
# Shred subscribe
Source: https://docs.solanatracker.io/solana-rpc/websockets/shredsubscribe
# Shred unsubscribe
Source: https://docs.solanatracker.io/solana-rpc/websockets/shredunsubscribe
# Signature subscribe
Source: https://docs.solanatracker.io/solana-rpc/websockets/signaturesubscribe
# Signature unsubscribe
Source: https://docs.solanatracker.io/solana-rpc/websockets/signatureunsubscribe
# Slot subscribe
Source: https://docs.solanatracker.io/solana-rpc/websockets/slotsubscribe
# Slots updates subscribe
Source: https://docs.solanatracker.io/solana-rpc/websockets/slotsupdatessubscribe
# Slots updates unsubscribe
Source: https://docs.solanatracker.io/solana-rpc/websockets/slotsupdatesunsubscribe
# Slot unsubscribe
Source: https://docs.solanatracker.io/solana-rpc/websockets/slotunsubscribe
# Vote subscribe
Source: https://docs.solanatracker.io/solana-rpc/websockets/votesubscribe
# Vote unsubscribe
Source: https://docs.solanatracker.io/solana-rpc/websockets/voteunsubscribe
# Libraries
Source: https://docs.solanatracker.io/swap-api/libraries
Official SDK libraries for Solana token swaps
# SDK Libraries
Official client libraries for integrating Solana token swaps into your application.
All SDKs support Pump.fun, PumpSwap, Orca, Meteora, Moonshot, Raydium, and Jupiter.
## Available SDKs
For Node.js, React, Next.js, and browsers
For Python applications and scripts
## Installation
```bash npm theme={null}
npm install solana-swap
```
## Quick Start
### JavaScript
```javascript theme={null}
import { SolanaTracker } from 'solana-swap';
const tracker = new SolanaTracker('YOUR_API_KEY', 'YOUR_PRIVATE_KEY');
// Get quote
const quote = await tracker.getRate({
from: 'So11111111111111111111111111111111111111112',
to: '4k3Dyjzvzp8eMZWUXbBCjEvwSkkk59S5iCNLY3QrkX6R',
amount: 1,
slippage: 10
});
// Execute swap
const swap = await tracker.swap({
from: 'So11111111111111111111111111111111111111112',
to: '4k3Dyjzvzp8eMZWUXbBCjEvwSkkk59S5iCNLY3QrkX6R',
fromAmount: 0.1,
slippage: 10,
payer: 'YOUR_WALLET_ADDRESS'
});
```
### Python
```python theme={null}
from solana_swap import SolanaTracker
tracker = SolanaTracker('YOUR_API_KEY', 'YOUR_PRIVATE_KEY')
# Get quote
quote = tracker.get_rate(
from_token='So11111111111111111111111111111111111111112',
to_token='4k3Dyjzvzp8eMZWUXbBCjEvwSkkk59S5iCNLY3QrkX6R',
amount=1,
slippage=10
)
# Execute swap
swap = tracker.swap(
from_token='So11111111111111111111111111111111111111112',
to_token='4k3Dyjzvzp8eMZWUXbBCjEvwSkkk59S5iCNLY3QrkX6R',
from_amount=0.1,
slippage=10,
payer='YOUR_WALLET_ADDRESS'
)
```
## React Integration
```javascript theme={null}
import { useState } from 'react';
import { SolanaTracker } from 'solana-swap';
function SwapComponent() {
const [quote, setQuote] = useState(null);
const tracker = new SolanaTracker(process.env.NEXT_PUBLIC_API_KEY);
async function getQuote(amount) {
const result = await tracker.getRate({
from: 'So11111111111111111111111111111111111111112',
to: '4k3Dyjzvzp8eMZWUXbBCjEvwSkkk59S5iCNLY3QrkX6R',
amount: parseFloat(amount),
slippage: 10
});
setQuote(result);
}
async function executeSwap() {
const swap = await tracker.swap({
from: 'So11111111111111111111111111111111111111112',
to: '4k3Dyjzvzp8eMZWUXbBCjEvwSkkk59S5iCNLY3QrkX6R',
fromAmount: quote.amountIn,
slippage: 10,
payer: walletAddress
});
console.log('Swap completed:', swap.txn);
}
return (