Getting started

Strak documentation

Strak is a terminal for every tokenized stock on Solana. Next to price and volume it shows one number no one else puts on the screen: turnover, the 24 hour volume divided by the liquidity behind it. Everyone shows the price. Strak shows whether it's lying.

Numbers in this strip are read from /api/registry when the page loads.

Why this exists

A tokenized stock on Solana trades in an AMM pool. The price you see is simply where the last trades left that pool, and the 24h volume next to it is the sum of those trades. Both numbers are easy to inflate: a wallet that swaps back and forth with itself moves volume up and nudges the price wherever it likes, and nothing on a normal price screen tells you it happened.

There is one thing a loop can't hide: how many times it had to push the pool's entire depth through itself to produce that volume. Real demand for a stock rarely turns a pool over dozens of times a day. Strak measures exactly that, for every tokenized stock on the chain, and colours the board by it.

Who it is for

• Traders who want to know whether a price has a market behind it before they trade against it.
• Researchers and writers who need a single, reproducible number for "this volume looks fake".
• Builders who want the whole tokenized equity universe on Solana as one clean JSON file.

Getting started

Quick start

1. Open the terminal. The board lists every stock, sorted by turnover, highest first. Click any column header to sort by it; click again to flip the order.
2. Star what you follow. The star next to a stock puts it on the Watchlist tab. The list lives in your browser only.
3. Read the colour of the row. No tint is normal trading. A violet edge means 12x to 50x. A green glow means above 50x: the volume is painted.
4. Click a stock. The detail panel shows the verdict bar, candles, pool depth and how often the whole pool changes hands.
5. Check the wrappers. If the same company trades under another issuer, the prices are listed side by side. A wide gap means one of the pools is not pricing the stock.
6. Verify on chain. Every stock links to its mint and its pool on Solscan.

Getting started

Reading the terminal

The board

Each row is one tokenized stock: its symbol, name and issuer dot, price, 24h change, 24h volume and turnover. The row's tint follows the turnover band. Above the table:

• Issuer tabs: All, Backpack, xStocks, Ondo, each with its live count, and Pre-IPO on the right, which swaps the board for a separate universe rather than filtering it.
• Search: matches symbol (NVDAx), plain ticker (NVDA) or company name.
• Sort: Turnover, Volume, Depth (liquidity), Change, A to Z.
• Above 12x only: hides everything in the normal band.

The tape across the top runs the 24 highest turnovers with their 24h change. The status pill shows the US equity session in New York time (pre-market, open, after hours, closed), because the stocks these tokens track only move on news and fundamentals during that session.

The detail panel

The board refreshes itself every two minutes. The timestamp under the table says whether you are looking at the live registry or the static snapshot.

Method

Turnover

Turnover is the whole product in one ratio:

Both inputs are in US dollars and cover the same token over the same 24 hours, so the ratio has no unit. It reads as "how many times did the traded volume cover the depth behind the price". A turnover of 3x means the day's trades added up to three times the pool.

Turnover as time

A ratio is easy to compute and hard to feel. Strak also shows it as time: if a day has 1440 minutes and the pool turned over t times, the whole depth changed hands once every 1440 / t minutes.

A worked example

Precision

Turnover is computed once per registry build and rounded to two decimals. Volume and liquidity come from the same Jupiter record, so both sides of the ratio are always from the same moment.

Method

The three bands

Every stock falls into one of three bands. The counts are live.

Why 12x and 50x

The thresholds are heuristics, not laws of nature, and they are stated in the open so anyone can argue with them. They come from turning the ratio into time:

• 12x is a full turn of the pool every two hours for 24 hours straight, including the hours when the underlying US market is closed and nothing new is known about the company. A busy, healthy pool can get there on a big news day; it rarely stays there.
• 50x is a full turn every half hour, all day and all night. At that pace the same dollars would have to cross the pool again and again. Real demand for a stock does not look like that. A loop of trades does.

Values are compared with > 12 and > 50: exactly 12.00x is still normal, exactly 50.00x is still hot.

Method

Who makes the volume

Turnover says the volume does not fit the pool. It does not say who is producing it. For that, Strak reads the stock's last 300 swaps, across every pool, and groups them by wallet. Four numbers come out, and together they separate a busy market from a loop.

The same numbers are on the landing page for the hottest pools, updating every 20 seconds, and under every chart in the terminal. Through the API they come from /api/trades.

Method

What turnover can't tell you

Turnover is a screen, not a verdict from a court. Read it with these limits in mind:

• High is not proof. Earnings, index news or a sudden re-rating can push an honest pool into the hot band for a day. Look at the chart and at the other wrappers before concluding anything.
• Low is not a clean bill. A pool can be manipulated with little volume, for example by one large trade in a thin pool. Low turnover only says the volume is plausible.
• Thin pools are noisy. A stock needs at least $5K of liquidity to be on the board, but near that floor a single trade moves the ratio a lot.
• 24 hours is a window. A burst an hour ago and a steady day can produce the same number. The candles show which it was.
• Aggregator data. Volume and liquidity are Jupiter's figures for the token across its pools. Strak does not recount swaps itself; every figure links to the chain so it can be checked.

Method

Case files

Dated snapshots from past registry runs. They are not live data, and each one carries the date of the run it came from.

Data

Universe and issuers

Strak covers tokenized stocks from three issuers. Each one names its tokens its own way, which is how the same company can appear two or three times.

Inclusion rules

A token is on the board when all of these hold:

1. It is in Jupiter's verified token list.
2. It carries one of the issuer tags above.
3. It does not carry the unknown tag. Copies that reuse a real ticker are tagged this way and are dropped.
4. It has at least $5,000 of liquidity. Below that a pool is decoration, not a market. Issuers mint many listings nobody trades; this rule removes them.
5. It is the deepest listing of its ticker for that issuer. If an issuer has two tokens with the same ticker, the one with more liquidity stays.

Tokens tagged as stocks but without an issuer tag are not included.

Tickers and symbols

Every record carries two names. symbol is the token's own symbol (NVDAx). ticker is the plain company ticker with the issuer suffix removed (NVDA). The terminal groups wrappers of one company by ticker.

Data

Pre-IPO tokens

A second, smaller universe trades on Solana: tokens that track companies with no listed shares at all. OpenAI, Anthropic, SpaceX, Neuralink, Anduril, Polymarket, Kalshi, Figure AI. Two issuers compete on the same names, PreStocks and Tessera, the second prefixing its symbols with a t.

They sit on their own tab and never mix into the board, because they break the assumption everything else rests on.

How they are picked

Same liquidity floor of $5,000, same duplicate collapsing. The difference is the tag: a token joins this list when Jupiter tags it prestocks or tessera and it does not carry commodities. That last rule keeps out tokenized gold and silver, which are tagged as real-world assets but are not stocks in any sense.

Tokens tagged only stocks or rwa, with no issuer behind them, are in neither list.

In the API

They arrive as a separate preipo array next to equities, in exactly the same shape. count covers listed stocks only, so nothing that reads the board picks them up by accident.

const { equities, preipo } = await (await fetch('https://usestrak.xyz/api/registry')).json();

equities.length;   // listed stocks
preipo.length;     // pre-IPO, a separate universe

Data

Sources and refresh

Every number comes from a public, free API. Nothing is typed in by hand.

The pipeline

1. Fetch Jupiter's verified list (one request, about 3,600 tokens).
2. Filter by the inclusion rules and collapse duplicates.
3. Ask DexScreener for the pairs of the remaining mints, 30 per request, and keep the deepest pair of each.
4. Compute turnover and sort by volume.

A full build takes a few seconds. The CDN keeps each answer for five minutes, so one build serves every visitor in that window. If the upstreams fail, the site falls back to the static snapshot in /data/equities.json, and the terminal labels the board as a snapshot instead of live.

Data

Field reference

Each entry in equities has these fields. Money is in US dollars.

The envelope around the list:

{
  "updatedAt": 1790370000000,     // when this build ran, Unix ms
  "chain": { "name": "Solana", "id": "solana" },
  "count": 93,                    // listed stocks only
  "equities": [ … ],
  "preipo": [ … ],                // same shape, see Pre-IPO tokens
  "live": true                    // only on /api/registry
}

Developers

API overview

The same endpoints the site runs on are open to anyone. No key, no sign up. Responses are JSON, served from the site's own origin with CDN caching.

Developers

GET /api/registry

Builds the board from Jupiter and DexScreener and returns it in the shape described in Field reference, with "live": true.

curl -s https://usestrak.xyz/api/registry | jq '.equities | sort_by(-.turnover) | .[0:5] | map({symbol, turnover})'

const res = await fetch('https://usestrak.xyz/api/registry');
const { equities, updatedAt } = await res.json();

const hot = equities.filter((e) => e.turnover > 12);
console.log(`${hot.length} stocks above 12x as of ${new Date(updatedAt).toISOString()}`);

Developers

GET /api/candles

The chart's fallback. The terminal reads Jupiter's chart API straight from the browser; when that fails, it asks here. This route asks Jupiter from the server and, if Jupiter is down too, GeckoTerminal for the token's deepest pool. The answer has the same shape either way.

curl -s "https://usestrak.xyz/api/candles?mint=<mint>&interval=1_HOUR&candles=100"

Answer: {"candles": [{"time", "open", "high", "low", "close", "volume"}, …], "source": "jupiter"}, oldest first, time in Unix seconds, prices and volume in USD. source says which upstream answered.

Developers

GET /api/trades

The latest swaps of one stock across all its pools, newest first, with the wallet behind each and a summary of who is carrying the volume. Source is Jupiter's trade feed, read 30 at a time up to 300 swaps or five seconds, whichever comes first; the CDN keeps the answer 20 seconds. If Jupiter does not answer and a pool is given, GeckoTerminal's last 300 swaps of that pool stand in, and scope in the answer says pool instead of token.

curl -s "https://usestrak.xyz/api/trades?mint=<mint>" | jq .stats

{
  "trades": [
    { "t": 1790372807000, "kind": "buy", "usd": 23.87, "wallet": "H9fi…enKm", "tx": "5XVj…EdJ9" }
  ],
  "stats": {
    "count": 300,          // swaps read
    "usd": 37988.96,       // their total value
    "wallets": 189,        // distinct addresses
    "minutes": 10.2,       // how long those 300 swaps took
    "perMin": 29.46,
    "median": 43.12,       // median trade, USD
    "top3Share": 0.3782,   // share of volume carried by the three biggest wallets
    "roundTripWallets": 37,
    "roundTripShare": 0.1337,
    "top": [ { "wallet": "4K9G…BLrs", "usd": 5711.27, "n": 3, "buy": 3, "sell": 0 } ]
  }
}

Only the 60 most recent swaps are returned in trades; stats always covers all 300. Statuses match the candles route: 400 for a bad address, 429 when the upstream is rate limiting, 502 otherwise.

Developers

GET /api/sparks

24 hourly closes for the pools the landing page draws sparklines for: the 8 highest turnovers and the 22 most traded stocks. It takes no parameters on purpose: one constant URL means the CDN holds one answer for half an hour, and the whole site costs about 30 upstream calls per half hour. Closes come from Jupiter's hourly candles for the whole token, with GeckoTerminal as the fallback.

{
  "sparks": { "<pool>": [44.1, 44.3, …, 44.9] },   // oldest first
  "count": 25,                                  // pools answered
  "of": 25                                      // pools asked
}

When fewer than 60% of pools answered, the response is cached for one minute instead of thirty, so a rate-limited batch is not pinned. Where a pool has no candles, the landing draws a coarse line from the pool's own pc field: four real points at 24h, 6h, 1h and now.

Developers

Static files

/data/equities.json is the board as of the last deploy, in the same shape as the live route without live. Use it as a fallback or when you need a fixed snapshot. /data/cases.json holds the dated case files.

Separately, the whole board is snapshotted every hour and kept. That record is what the Turnover over time panel under each chart is drawn from, and every stock seen above 50x in it is kept as a dated case.

Developers

Deep links

Link straight to a stock or an issuer. Useful for posts, bots and research notes.

Reference

Glossary

AMM pool

A smart contract holding two assets, for example a stock token and USDC. The price is set by the ratio of the two, and every trade moves it.

Liquidity

The USD value sitting in the pools behind a token. It is how much a trade can lean on before the price moves a lot.

Volume, 24h

The USD value of all buys and sells of the token in the last 24 hours.

Turnover

Volume divided by liquidity. How many times the day's trading covered the depth.

Wash trading

Trading with yourself, or with a friendly counterparty, to create volume and move a price without real demand.

Issuer

The company that holds the real shares and mints the token that tracks them: Backpack Securities, Backed (xStocks) or Ondo.

Wrapper

One issuer's token for a company. NVDAx is the xStocks wrapper of NVIDIA.

Price gap

The difference between two wrappers of the same company. Both track the same share, so a wide gap means one pool is not pricing it.

Pre-IPO token

A token tracking a company whose shares are not publicly traded. There is no exchange price behind it, so nothing to check the pool price against.

Mint

A token's address on Solana.

Reference

Changelog

Reference

Disclaimer

Strak is an informational tool. Nothing on this site is financial advice, an offer or a recommendation to buy or sell anything. Turnover describes how reported volume relates to pool depth; it does not predict prices and it does not prove misconduct. Data comes from third parties and can be late, incomplete or wrong. Check anything that matters on chain before acting on it.