> The index of these docs, for agents: https://traktor.fun/llms.txt

# Signals

The signal feed under a key, a page at a time, newest first or tailed forward by arrival.

`GET /v1/signals` answers with the events Traktor's signal feed shows, such as big buys (`whale_buy`), pumps, new holders and listings, each in the shape the board renders.

### `GET /v1/signals`

The signal feed the board renders, newest first by default, a page at a time by arrival. An event's `live` net and volume are `null` where its token's board row has none.

- URL: `https://api.traktor.fun/v1/signals`
- Credential: API key
- REST units: 2 units

| Parameter | In | Type | Required | Default | Bounds | Description |
| --- | --- | --- | --- | --- | --- | --- |
| `v` | query | integer | no |  | 1 | Grammar version; send 1, or leave it out. |
| `chains` | query | list | no |  | solana, robinhood, bnb, base, arc, arbitrum, ethereum, monad, hyperevm, elysium | Chains to include, comma-separated; empty means all. |
| `platforms` | query | list | no |  | fomo, gmgn, pump, axiom, coinbase, padre, maestro, bloom, trojan, bonkbot, bankr, photon | Apps to include; an event with no app, such as a listing, always passes. |
| `types` | query | list | no |  | net_in, net_out, vol_spike, buyers, buy_pressure, sell_pressure, dip_buy, rotation, whale_buy, whale_sell, top_buy, top_sell, kol_buy, smart_buy, dev_buy, dev_sell, insider_buy, smart_cluster, top_cluster, top_exit, top_early, top_net, holders_up, holder_surge, holder_exodus, supply_share, holder_growth, mcap_up, pump, dump, ath, pump_fade, new_token, graduation, revival, dex_paid, dex_boost, cto, liq_add, liq_pull | Signals to include; empty means all. |
| `tiers` | query | list | no |  | 1, 2, 3 | Sizes to include, 1 to 3; empty means all. |
| `limit` | query | integer | no | 100 | 1–500 | Events per page. |
| `order` | query | enum | no | desc | desc, asc | Newest first or oldest first, by arrival. |
| `cursor` | query | cursor | no |  |  | `meta.page.cursor` from the previous page. |

Limits:

- Invalid keys: 30 a minute, per IP
- Events examined: 10,000 rows, per request
- Cursor lifetime: 24 hours, per request
- Newest arrivals an ascending page holds back: 15 seconds by default, per request

```bash cURL
curl -s "https://api.traktor.fun/v1/signals?types=whale_buy,pump" \
  -H "Authorization: Bearer $TRAKTOR_API_KEY"
```

```ts TypeScript
const response = await fetch("https://api.traktor.fun/v1/signals?types=whale_buy,pump", {
  headers: { Authorization: `Bearer ${process.env.TRAKTOR_API_KEY}` },
});
const body = await response.json();
```

```python Python
import os
import requests

response = requests.get(
    "https://api.traktor.fun/v1/signals",
    params={"types": "whale_buy,pump"},
    headers={"Authorization": f"Bearer {os.environ['TRAKTOR_API_KEY']}"},
)
print(response.json())
```

Errors: `invalid_parameter`, `unknown_parameter`, `duplicate_query_parameter`, `filter_version_unsupported`, `limit_out_of_range`, `invalid_cursor`, `cursor_query_mismatch`, `cursor_expired`, `missing_credentials`, `invalid_key`, `key_revoked`, `subscription_inactive`, `key_in_query`, `method_not_allowed`, `rate_limited`, `quota_exhausted`, `rate_limit_unavailable`, `internal_error`. Every code: https://traktor.fun/docs/errors.md

Every event keeps the facts it was detected with. Names and pictures for the wallet in it, and the wallet's year, are filled in when it is read, from answers each server holds for up to a minute: a new name or mark can take that long to show, two pages read moments apart can name a wallet differently inside it, and `meta.asOf` dates the events, not these.

No event is served for a token that no launchpad we know made, as no board lists one: a verified stock is the exception. Nor is one served for a major, whatever launchpad it is tagged with: a stablecoin, a chain's wrapped native, a coin bridged or wrapped onto a chain such as cbBTC or WBTC, or another major traktor names by address. That is read from the launchpad the event was written with, so a token tagged later stays off the events written before.

## The wallet behind a trade

Big buys and sells, top-trader trades, dev trades and rotations name their wallet in `detail.wallet`. Where a source names it, `detail.handle` and `detail.x` say who it is, and `marks` says whether it is known as a KOL or smart money.

A top-trader trade (`top_buy`, `top_sell`) is one made from a wallet of the traders page's top 100 by year profit, from $500, and `detail.rank` is the trader's place there; or one from a trader placed among the top 10,000 by year profit, named or not: from $500 for places 1 to 100, $1k for 101 to 1,000 and $2.5k for 1,001 to 10,000, and `detail.place` is that place. The tier is the trade's size whoever made it. While the service holds neither list, no trade is called a top trader's.

A KOL buy (`kol_buy`) or smart money buy (`smart_buy`) is a buy of $500 or more from a wallet known as a KOL or as smart money, named or not; `detail.kol` and `detail.smart` say which marks the wallet carried, and the big buy of the same trade carries them too. A wallet carrying both fires both. Neither is sent yet: they wait on a switch, off until the mobile app draws a signal type it does not know.

Dev sold (`dev_sell`) and Dev bought more (`dev_buy`) are a sale or buy of $100 or more by the wallet named as the token's creator; a buy in the minute after the token was created is its launch buy and none. A token with no creator named yet has no dev trades. Every other signal the same trade fired (a big, top-trader, KOL or smart-money one) carries `detail.dev: true` where the dev signal fired. Neither is sent yet: they wait on a switch of their own, for the same reason.

## Insiders buying

Insiders buying (`insider_buy`) is the share of supply held by the wallets flagged as insiders, bundlers or snipers rising two points or more between two readings of the token at most an hour apart. `detail.holders` names the class that rose most (`insiders`, `bundlers` or `snipers`), `detail.fromPct` and `detail.toPct` are its share before and after, in percent, and `detail.windowMin` the minutes between the readings; `value` is the rise in points, and `at` is the later reading's time. A wallet can sit in more than one class, so no figure adds the classes up. A class a reading did not measure is no rise, and none is measured on Robinhood. It is not sent yet: it waits on a switch of its own, for the same reason.

`detail.realizedYearUsd` is what the wallet realized over the last year on every chain of its kind, named or not, and `detail.winRateYear` is that year's win rate, from 0 to 1. Both are left out where the wallet has not been measured, never sent as zero, and the win rate never appears without the year. A wallet not measured yet is queued for a later sweep, which asks a limited number of wallets; until then both are left out.

## Piling in, top traders and Pump fading

Smart money piling in (`smart_cluster`) is three, five or eight proven wallets each buying $250 or more of one token within 30 minutes. A proven wallet is one known as a KOL or as smart money, or one that realized $10k or more over the last year at a win rate of 50% or better. `detail.wallets` is how many, also the `value`, `detail.usd` what they bought between them inside the half hour and `detail.windowMin` the window; `at` is the time of the buy that completed the count. A wallet that sells the token leaves the count until it buys again. No wallet is named in it. For half an hour after one of our deploys the count starts empty, so it can come up short.

Top traders piling in (`top_cluster`) is three, five or eight traders placed in the top 1,000 by year profit, as Top trader buy places them, each buying $250 or more of one token within 30 minutes. A trader counts once whichever of its wallets it buys from, and a sale from any of them takes it out of the count until it buys again. `detail.traders` is how many, also the `value`, `detail.usd` what they bought between them inside the half hour, `detail.windowMin` the window and `detail.bestPlace` the best place among them; `at` is the time of the buy that completed the count. No trader is named in it, and it is silent while no ranking is held. For half an hour after one of our deploys the count starts empty, so it can come up short.

Top traders heading out (`top_exit`) is the same count turned around: three, five or eight of those traders each selling $250 or more of one token within 30 minutes, a trader counted once whichever of its wallets it sells from, and a buy from any of them taking it back out of the count until it sells again. Its `detail` holds the same `traders`, `usd`, `windowMin` and `bestPlace`, for the sales, and `at` is the time of the sale that completed the count. It warns the people holding the token; it names no trader, is silent while no ranking is held, and can come up short for half an hour after one of our deploys.

Top traders in early (`top_early`) is one, two or four of those traders each buying $250 or more of a token inside its first 15 minutes, counted from its launch, unless we saw it trade before that launch time or know no launch, then from its first trade we saw: the same start a token's age on the board counts from. It is one line a token, said again louder as more traders get in, and a trader counts once across its wallets, out of the count after a sale until it buys again. `detail.traders` is how many, also the `value`, `detail.usd` what they bought, `detail.ageMin` how many minutes in the latest of those buys came, `detail.since` whether that is from the `launch` or the `first_trade`, and `detail.bestPlace` the best place among them. A token we cannot time says nothing.

Top traders net buying (`top_net`) is what those traders bought less what they sold of one token, every priced trade of theirs, in the 15 minutes up to a buy of $250 or more by one of them, at $5k, $25k or $100k, once two or more of them each net $250 or more. A trader's wallets net together, and once the ranking moves a trader past 1,000 its sales still count against the buys we already hold from it, but its later buys are left out. `detail.usd` is the net, also the `value`, `detail.traders` how many net $250 or more, `detail.windowMin` the window and `detail.bestPlace` the best place among them, and `at` is the time of the buy that ends the 15 minutes. It names no trader, is silent while no ranking is held, and can come up short for half an hour after one of our deploys.

Pump fading (`pump_fade`) is a token, within the hour after its pump, standing 15%, 30% or 50% under the highest market cap read since that pump while its five-minute trading is net selling. `detail.dropPct` is how far under, `detail.fromCap` and `detail.marketCap` the high and the cap now, `detail.pumpAgoMin` the minutes since the latest pump and `detail.netUsd` the five minutes' net flow; `value` is the drop as a negative percent. In the hour after one of our deploys the high is read back from the signals already sent, so it can be lower than the true one.

All six are served now, and a request that names no `types` gets them; the board starts them on for its readers, as it does every signal, though no backtest has backed them yet.

## Holders growing

Holders growing (`holder_growth`) is the number of wallets holding a token, every wallet and not only fomo's, rising by 50, 200 or 1,000 and by a fifth or more between two readings of the token at most 15 minutes apart, while the ten largest wallets' share of supply rose 2 points at most. `detail.from` and `detail.to` are the counts before and after, `detail.deltaPct` the rise in percent, `detail.top10FromPct` and `detail.top10ToPct` the ten largest wallets' share before and after, in percent, and `detail.windowMin` the minutes between the readings; `value` is the rise in holders, and `at` is the later reading's time. A reading that did not measure the ten largest wallets' share sends none. It is served now, and the board starts it on for its readers, as it does every signal, though no backtest has backed it yet.

## Paging

Events are ordered by when they were written, not by `at`. An event's `at` is when it happened, a block time, and a later write can carry an earlier `at`, so a walk on it would skip events.

- With the default `order=desc`, the first page is the newest events, and `meta.page.cursor` walks back from there.
- With `order=asc`, the walk runs forward from the oldest event in the last 72 hours, or from a cursor. Pass each page's `meta.page.cursor` to the next request to tail the feed. A page with nothing new keeps the cursor it was given.
- An ascending page leaves out the events written in the 15 seconds before `meta.asOf` by default, which may still be committing, and gives them on a later page.
- In either order, `meta.asOf` is when the events the page walked were read, which can be up to 15 seconds before the request: the newest page is the newest as of then.

A cursor carries its filters and its order: changing either under it is `400 cursor_query_mismatch`. A cursor lives 24 hours. A page reaches back 72 hours, and `meta.retention` says so.

`chains`, `platforms`, `types` and `tiers` filter on what each event carries. The board's market-cap, liquidity and other screens are not part of this route. Each request examines at most 10,000 events; a page that stopped there carries the `scan_capped` caveat and a cursor to continue from.

For one token's signals, read `GET /v1/tokens/{chain}/{address}/signals` on the [Tokens](https://traktor.fun/docs/tokens.md) page.

## The Signals board

`GET /v1/signals/board` answers with three readings of the newest signals under the board's filter: the pulse, the hot tokens the Signals page draws beside its feed, and the traders.

### `GET /v1/signals/board`

The pulse, hot tokens and traders of the newest signals the board's filter admits; the Signals page draws the hot tokens. A hot token's `live` net and volume are `null` where its board row has none.

- URL: `https://api.traktor.fun/v1/signals/board`
- Credential: API key
- REST units: 2 units

| Parameter | In | Type | Required | Default | Bounds | Description |
| --- | --- | --- | --- | --- | --- | --- |
| `chains` | query | list | no |  | solana, robinhood, bnb, base, arc, arbitrum, ethereum, monad, hyperevm, elysium | Chains to include, comma-separated; empty means all. |
| `platforms` | query | list | no |  | fomo, gmgn, pump, axiom, coinbase, padre, maestro, bloom, trojan, bonkbot, bankr, photon | Apps to include; empty means all. |
| `windowMinutes` | query | enum | no | 60 | 5, 15, 30, 60, 240, 1440 | The board's window, which the market-cap, flow and other screens read. |
| `dexSignals` | query | list | no |  | paid, boost, cto | DEX signals; a token with any of them matches. |
| `stockPairs` | query | list | no |  | up to 12 items | Stock tickers the token pairs with, or `ANY-STOCK` for any stock. |
| `minNet` | query | money | no |  |  | Net flow at least. A negative floor keeps outflow in view rather than screening it away. |
| `maxNet` | query | money | no |  |  | Net flow at most — set it negative to find only what is being distributed. |
| `minVolume` | query | money | no |  | from 0 | Traded volume at least, both sides together. |
| `minBuyers` | query | integer | no |  | from 0 | Distinct buying wallets at least — breadth, where volume is only size. |
| `minSellers` | query | integer | no |  | from 0 | Distinct selling wallets at least. |
| `minTrades` | query | integer | no |  | from 0 | Trades at least. |
| `minRatio` | query | number | no |  | from 0 | Dollars bought per dollar sold — 2 means twice as much buying as selling. |
| `minChange` | query | number | no |  |  | Price move across the window, at least. Negative finds what is falling. |
| `maxChange` | query | number | no |  |  | Price move across the window, at most. |
| `minTopTraders` | query | money | no |  | from 0 | What the top 10,000 traders by year profit bought in the window, at least. Counted over the Board's six windows alone: on any other window, or for a buy with nothing priced, a token is in no band. |
| `minMcap` | query | money | no |  | from 0 | Market cap at least. |
| `maxMcap` | query | money | no |  | from 0 | Market cap at most. Tokens with no cap yet are kept — a brand-new one is small by definition. |
| `minLiq` | query | money | no |  | from 0 | Pool depth at least — what the token can absorb before price moves. |
| `maxLiq` | query | money | no |  | from 0 | Pool depth at most. |
| `minLiqPct` | query | number | no |  | from 0 | Depth as a share of market cap — how much of the cap there is real money behind. |
| `minHolders` | query | integer | no |  | from 0 | Wallets holding the token on chain, at least, as its data provider last counted them; a token nobody counted is in no band. |
| `minFomoHolders` | query | integer | no |  | from 0 | Wallets on fomo still holding a position. |
| `minHeldPct` | query | number | no |  | from 0 | Share of circulating supply sitting in fomo wallets — how much of the token the crowd here owns. |
| `minAth` | query | number | no |  | from 0 | Multiple back to the all-time high, at least — headroom above the current price. |
| `maxAth` | query | number | no |  | from 0 | Multiple back to the high, at most — near its own top. |
| `maxAge` | query | string | no |  |  | Younger than, in hours since the token launched on chain, or first traded on our tape where that came first or no launch is dated. Takes hours above zero, or a duration such as `30m`, `4h` or `3d`. |
| `minAge` | query | string | no |  |  | Older than, in hours since the token launched on chain, or first traded on our tape where that came first or no launch is dated. Takes hours above zero, or a duration such as `30m`, `4h` or `3d`. |
| `minCurve` | query | number | no |  | from 0 | Bonding-curve progress, at least, in percent; a token that has graduated counts as 101. |
| `maxCurve` | query | number | no |  | from 0 | Bonding-curve progress, at most, in percent; 100 keeps only tokens still on their curve. |
| `types` | query | list | no |  | net_in, net_out, vol_spike, buyers, buy_pressure, sell_pressure, dip_buy, rotation, whale_buy, whale_sell, top_buy, top_sell, kol_buy, smart_buy, dev_buy, dev_sell, insider_buy, smart_cluster, top_cluster, top_exit, top_early, top_net, holders_up, holder_surge, holder_exodus, supply_share, holder_growth, mcap_up, pump, dump, ath, pump_fade, new_token, graduation, revival, dex_paid, dex_boost, cto, liq_add, liq_pull | Signals to read; empty means all. |
| `tiers` | query | list | no |  | 1, 2, 3 | Sizes to read, 1 to 3; empty means all. |
| `limit` | query | integer | no | 100 | 1–400 | The newest signals the panels read. |
| `bucketMinutes` | query | enum | no | 5 | 1, 2, 3, 5, 10, 15, 30, 60 | The pulse's interval, in minutes. |

Limits:

- Invalid keys: 30 a minute, per IP

```bash cURL
curl -s "https://api.traktor.fun/v1/signals/board?types=whale_buy,pump" \
  -H "Authorization: Bearer $TRAKTOR_API_KEY"
```

```ts TypeScript
const response = await fetch("https://api.traktor.fun/v1/signals/board?types=whale_buy,pump", {
  headers: { Authorization: `Bearer ${process.env.TRAKTOR_API_KEY}` },
});
const body = await response.json();
```

```python Python
import os
import requests

response = requests.get(
    "https://api.traktor.fun/v1/signals/board",
    params={"types": "whale_buy,pump"},
    headers={"Authorization": f"Bearer {os.environ['TRAKTOR_API_KEY']}"},
)
print(response.json())
```

Errors: `invalid_parameter`, `unknown_parameter`, `duplicate_query_parameter`, `window_out_of_range`, `screen_conflict`, `too_many_addresses`, `limit_out_of_range`, `data_unavailable`, `market_busy`, `market_fold_pending`, `missing_credentials`, `invalid_key`, `key_revoked`, `subscription_inactive`, `key_in_query`, `method_not_allowed`, `rate_limited`, `quota_exhausted`, `rate_limit_unavailable`, `internal_error`. Every code: https://traktor.fun/docs/errors.md

It reads the newest signals whose tokens the board's filter admits, `limit` of them, then keeps the `types` and `tiers` it names; left empty, each keeps every signal, where the page starts from its reader's switches. The panels read the last hour of what is kept, and `window` says where it opens and how many signals it holds. The window is what the read covered, whatever `types` and `tiers` keep of it: a read that reached `limit` inside the hour opens it near its oldest signals instead, leaving up to the oldest tenth out as stragglers, with `full: false`, because a busier hour holds more than was read, and so does a read whose scan of the newest stored signals ran out before the hour did.

- `pulse` counts the window's signals by lean, `bullish`, `bearish` or `neutral`, in intervals of `bucketMinutes` that start on the interval's boundary, so the first opens before `window.from` and it and the last can cover less than a whole interval.
- `hotTokens` are the tokens that fired two or more signals, the most first, each with every kind it fired, its `lean` where one side outnumbers the other at least two to one and more than half the neutral ones, and in `live` the board's current reading of it, its `netUsd` and `volumeUsd` `null` where the board's row has none.
- `traders` are the wallets behind the window's big-trade, top-trader and rotation signals, the most money first. Their sizes are the signalled trades', not the wallet's whole day. A trader goes by the name, X account and marks a source gave it, or by none where nobody named it: no wallet address or transaction id is in the answer. Its `handle` and `displayName` have the marks a reader cannot see (control, zero-width, bidi and tag characters among them) taken out, a line break or tab read as a space, and are cut to 40 and 50 characters, so either can differ from the same wallet's `detail.handle` or `detail.displayName` on `/v1/signals`.

The board's filter is read as on the [market](https://traktor.fun/docs/market.md#market-filter) routes: a name it does not know is `400 invalid_parameter`, never dropped, and every fault in the query is refused before admission. A board still being built is `503 data_unavailable`, and its units come back.