Solana TradingView Chart

Most Solana charts break at the data layer, not the UI. The candlestick widget renders fine, but candles arrive out of order, history stops loading when the user scrolls back, and the last bar freezes because the live feed quietly dropped. The hard part of a TradingView integration is the feed, not the chart.

TL;DR

Resolve a symbol or address to a canonical token or pool
Seed the visible viewport with up to 5000 candles
Backfill older history only when the user scrolls back
Keep the last candle live over REST or WebSocket
Optionally overlay liquidity under the price

Reference architecture for a Solana TradingView Chart API: resolve, seed, backfill, and live candle layers

All requests share the base URL https://public-api.birdeye.so, authenticate with the X-API-KEY header, and select the network with x-chain: solana.

The trick behind the whole design is fetching only what is on screen: stream or poll the visible candle, and pull older history only when the user scrolls back. That keeps credit usage flat as chart traffic grows. Birdeye publishes an official TradingView datafeed example at github.com/birdeye-so/tradingview-example-js-api, and the approach below matches it.

The five stage pipeline

Resolve a token or pair

When a user types a symbol or pastes a mint, you need a canonical address before requesting anything else. Search returns token results and market results in one call.Endpoint: GET /defi/v3/search, GET /defi/v3/price/stats/single

import requests

url = "https://public-api.birdeye.so/defi/v3/search"
params = {
    "chain": "solana",
    "keyword": "BONK",
    "target": "token",
    "search_by": "symbol",
    "search_mode": "exact",
    "sort_by": "volume_24h_usd",
    "sort_type": "desc",
    "limit": 20
}
headers = {"accept": "application/json", "x-chain": "solana", "X-API-KEY": "YOUR_API_KEY"}

response = requests.get(url, params=params, headers=headers).json()

const url = new URL("https://public-api.birdeye.so/defi/v3/search");
url.search = new URLSearchParams({
  chain: "solana",
  keyword: "BONK",
  target: "token",
  search_by: "symbol",
  search_mode: "exact",
  sort_by: "volume_24h_usd",
  sort_type: "desc",
  limit: "20"
}).toString();

const response = await fetch(url, {
  headers: { accept: "application/json", "x-chain": "solana", "X-API-KEY": "YOUR_API_KEY" }
}).then((res) => res.json());

curl --request GET \
  --url 'https://public-api.birdeye.so/defi/v3/search?chain=solana&keyword=BONK&target=token&search_by=symbol&search_mode=exact&sort_by=volume_24h_usd&sort_type=desc&limit=20' \
  --header 'accept: application/json' \
  --header 'x-chain: solana' \
  --header 'X-API-KEY: YOUR_API_KEY'

sort_by and sort_type are both required. The response groups results by type, so read data.items[], find the group where type is token, and take result[0].address. Market groups carry the pool address for pool level OHLCV and the liquidity overlay later.

For the toolbar, price/stats/single returns price, percent change, and high and low in one call. On Solana the payload is a direct array under data, while EVM nests it under data.items, so branch your parser if you extend to EVM.

Seed the viewport with up to 5000 candles

The first paint should fill the visible viewport in one request.Endpoint: GET /defi/v3/ohlcv

import requests

url = "https://public-api.birdeye.so/defi/v3/ohlcv"
params = {
    "address": "TOKEN_ADDRESS",
    "type": "15m",
    "currency": "usd",
    "time_from": 1726700000,
    "time_to": 1726704000,
    "mode": "range",
    "padding": "false"
}
headers = {"accept": "application/json", "x-chain": "solana", "X-API-KEY": "YOUR_API_KEY"}

response = requests.get(url, params=params, headers=headers).json()

const url = new URL("https://public-api.birdeye.so/defi/v3/ohlcv");
url.search = new URLSearchParams({
  address: "TOKEN_ADDRESS",
  type: "15m",
  currency: "usd",
  time_from: "1726700000",
  time_to: "1726704000",
  mode: "range",
  padding: "false"
}).toString();

const response = await fetch(url, {
  headers: { accept: "application/json", "x-chain": "solana", "X-API-KEY": "YOUR_API_KEY" }
}).then((res) => res.json());

curl --request GET \
  --url 'https://public-api.birdeye.so/defi/v3/ohlcv?address=TOKEN_ADDRESS&type=15m&currency=usd&time_from=1726700000&time_to=1726704000&mode=range&padding=false' \
  --header 'accept: application/json' \
  --header 'x-chain: solana' \
  --header 'X-API-KEY: YOUR_API_KEY'

Each item in data.items[] carries o, h, l, c, v, v_usd, and unix_time, mapping one to one onto a TradingView bar object. To chart a specific pool instead of an aggregated token, call /defi/v3/ohlcv/pair with the pool address, which drops currency and adds inversion to flip base and quote.

Backfill history on scroll back

When the user pans left, request an older window by shifting time_from and time_to to the period just before your earliest loaded candle, keeping the same type so the series stays continuous.Endpoint: GET /defi/history_price

curl --request GET \
  --url 'https://public-api.birdeye.so/defi/history_price?address=TOKEN_ADDRESS&address_type=token&type=15m&time_from=1726600000&time_to=1726700000' \
  --header 'accept: application/json' \
  --header 'x-chain: solana' \
  --header 'X-API-KEY: YOUR_API_KEY'

For very long ranges where a candle by candle load is wasteful, fall back to history_price, which returns a lightweight line series of unixTime and value points instead of full OHLCV.

Second level candles have limited retention: 1s for 2 weeks, 15s and 30s for 3 months. Cap second level intervals to recent ranges in your UI, or backfill requests come back empty.

Keep the last candle live

This is the layer that makes the chart feel real time, and the one place where your package tier changes the implementation.Endpoint: GET /defi/v3/ohlcv (any paid tier), SUBSCRIBE_PRICE (Premium and up)

curl --request GET \
  --url 'https://public-api.birdeye.so/defi/v3/ohlcv?address=TOKEN_ADDRESS&type=1m&currency=usd&mode=count&count_limit=2&time_to=1726704000' \
  --header 'accept: application/json' \
  --header 'x-chain: solana' \
  --header 'X-API-KEY: YOUR_API_KEY'

A poll interval close to the candle interval is usually enough. For a 1m chart, polling every few seconds keeps the forming bar fresh without wasting credits. This works on every paid tier with no WebSocket.

For the lowest latency live bar on a Premium package and up, open one socket and subscribe to the price stream instead.

import asyncio, json, websockets

WS_URL = "wss://public-api.birdeye.so/socket/solana?x-api-key=YOUR_API_KEY"

async def stream_live_candle():
    async with websockets.connect(WS_URL, subprotocols=["echo-protocol"]) as ws:
        await ws.send(json.dumps({
            "type": "SUBSCRIBE_PRICE",
            "data": {
                "queryType": "simple",
                "chartType": "1m",
                "address": "TOKEN_ADDRESS",
                "currency": "usd",
                "mode": "raw"
            }
        }))
        async for message in ws:
            event = json.loads(message)
            if event.get("type") == "PRICE_DATA":
                update_last_candle(event["data"])

Sending a new SUBSCRIBE_PRICE overwrites the previous one. To follow several tokens, send a single complex query with all of them, up to 100, and resend the full list whenever it changes. Implement ping pong so the connection is not dropped on idle network, and backfill missed candles over REST on reconnect.

Add a liquidity overlay

Most charts stop at price. A liquidity ribbon under the candles is a feature competitors rarely expose, and it is one call.Endpoint: GET /defi/v3/liquidity/ohlc/pair

curl --request GET \
  --url 'https://public-api.birdeye.so/defi/v3/liquidity/ohlc/pair?address=PAIR_ADDRESS&time=1726704000&direction=back&count=100' \
  --header 'accept: application/json' \
  --header 'x-chain: solana' \
  --header 'X-API-KEY: YOUR_API_KEY'

Solana only, up to 100 records per request, anchored at a time timestamp and paged by direction rather than a time_from/time_to range. Set direction=back to page older candles and direction=forward to move toward the present.

Watch your credit budget

If you poll for the live layer, wire this in from day one so a tight interval does not quietly burn your budget. Endpoint: GET /utils/v1/credits

import requests

url = "https://public-api.birdeye.so/utils/v1/credits"
headers = {"X-API-KEY": "YOUR_API_KEY"}

response = requests.get(url, headers=headers).json()

const response = await fetch("https://public-api.birdeye.so/utils/v1/credits", {
  headers: { "X-API-KEY": "YOUR_API_KEY" }
}).then((res) => res.json());

curl --request GET \
  --url 'https://public-api.birdeye.so/utils/v1/credits' \
  --header 'X-API-KEY: YOUR_API_KEY'

Poll hourly and widen your live poll interval automatically if remaining credits drop below a safe threshold, rather than running into a 429 mid session.

Before you ship

The history call uses padding=false so the chart does not invent flat candles.
Backfill keeps the same type, and second level intervals are capped to their retention windows.
The live layer degrades gracefully: REST poll on any tier, WebSocket from Premium up.
The price stats parser branches on chain if you target EVM later.
Credit usage is observable so a tight poll interval cannot surprise you with a 429.

FAQ

Do I need a WebSocket to make the chart live?

No. REST polling of the latest OHLCV candle keeps the chart live on every paid tier and is the primary path. WebSocket streaming is a lower latency option available from the Premium package up.

How do I chart a specific pool instead of the token?

Use /defi/v3/ohlcv/pair with the pool address, and set inversion if you need to flip base and quote.

Why are my older second level candles empty?

They fell outside the retention window. 1s is kept for 2 weeks, 15s and 30s for 3 months. Switch to 1m or higher for ranges beyond those limits.

Paint the visible viewport first, attach the live layer last, and backfill only when the user scrolls. That order is what keeps a Solana chart fast and its credit cost flat as traffic grows.

TL;DR

​The five stage pipeline

​Watch your credit budget

​Before you ship

​FAQ

The five stage pipeline

Watch your credit budget

Before you ship

FAQ