# Solana

> Solana on Chord — swaps through Chord's own router and Jupiter, best of both, open to everyone, and data from Chord's own tape of 11 venues; base58 addresses, units, the /v1/sol/trade/* and /v1/chains/solana/* families.

Source: https://getchord.xyz/docs/networks/solana/

| | |
| --- | --- |
| Chain id | none — the path segment is the literal `solana` (`/v1/chains/solana/*`) |
| Addresses | base58, **case-sensitive** (mints, wallets, pools); signatures base58 |
| Gas | SOL |
| Quote anchors | USDC `EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v` > USDT `Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB` > wSOL `So11111111111111111111111111111111111111112` (in a SOL/USDC pool, SOL is the token) |
| Trading | **open to everyone** since 2026-10-15: SOL ↔ any token through Chord's own router and Jupiter, whichever leaves the wallet with more (`/v1/sol/trade/*`, [below](#swaps)) |
| Chord tape since | live from 2026-10-03 12:01 UTC, plus a backfill of the days before: read `coverageSince` on `GET /v1/chains/solana/overview` |

## Swaps

A Solana swap quoted by Chord is SOL against one token, bought or sold. For every quote Chord builds, at the same moment, the
transaction of each route below **for your wallet**, simulates it on the chain, and reads what your wallet would end up with:
tokens for a buy, SOL for a sell, after every fee. You get the route that leaves you with the most.

| `route` | What it is |
| --- | --- |
| `direct` | **Chord's own router.** It builds the swap itself, from the pool accounts, on Raydium AMM v4, CPMM and CLMM, Orca Whirlpool, Meteora DLMM and DAMM v2, and the launch curves Meteora DBC, Raydium LaunchLab, pump.fun and PumpSwap. Pools come from Chord's tape; a large order can be split over two pools (`hops`). No third party in the path. |
| `jupiter` | Jupiter's swap API (Metis), without Jupiter's fee. |
| `jupiter_meta` | Jupiter's order: Metis, Jupiter's RFQ market makers, DFlow and OKX bid for it. Jupiter's fee is inside the amount; on RFQ and gasless orders Jupiter or the market maker pays the network fee (`gasless: true`). |

So a swap through Chord gets Jupiter's price whenever Jupiter is better (majors, where most of the liquidity sits in prop AMMs and
market makers only Jupiter reaches), and Chord's own route when it is as good (ties go to `direct`, then `jupiter`), when Jupiter has
no route yet for a new token, or when Jupiter is down or rate-limited. `compared` in the answer shows what every route offered. A
route that would hand back less than half of the input's market value is refused.

**Status.** Open to everyone since 2026-10-15 21:25 UTC, no key needed (an `X-API-Key` raises the rate limit, as everywhere else).
`GET /v1/sol/trade/config` says, for the caller, whether the lane is `enabled`, `open` to everyone, and `allowed` for you. Chord
takes no fee on Solana today (`feeBps: 0`); Jupiter's own fee applies on `jupiter_meta` quotes and is already inside the amount.

**One swap, step by step.** Amounts are base units as decimal strings: lamports for SOL, the token's smallest unit otherwise.

1. `GET /v1/sol/trade/quote?mint=&side=buy|sell&amount=&wallet=&slippageBps=100` — `amount` is lamports for a buy, tokens (smallest unit) for a sell. The answer's `quote.tx` is an unsigned v0 transaction, base64, exactly the one simulated; `outAmount` is what the simulation delivered, `minOut` the least the transaction accepts.
2. Sign `quote.tx` **unchanged** with the wallet. On `jupiter_meta` the wallet can be the second signer, not the fee payer.
3. `POST /v1/sol/trade/send` with `{ "tx": "<signed, base64>" }`. Chord relays only a transaction it quoted in the last three minutes, signed by the wallet it quoted; `jupiter_meta` orders go through Jupiter's execute endpoint.
4. Poll `GET /v1/sol/trade/tx/{signature}`: `pending`, then `confirmed` / `finalized` (with `receivedOut`, read from the chain with the same measure as the quote), `failed` or `expired`.

An RFQ quote carries `expireAt` (Unix seconds) and lives a few seconds: ask again when fewer than ten seconds are left.
`GET /v1/sol/trade/balances?wallet=&mint=` and `/holdings?wallet=` give the wallet's SOL and token balances for a swap form.

**Not covered.** Token ↔ token (SOL is always one side). Chord's own route does not go through a second pool (token → USDC → SOL)
or reach prop AMMs and RFQ makers: for those tokens and sizes the Jupiter routes win and are what you get.

## What the tape reads

Chord decodes the swap **events** of 11 venues straight from Solana blocks, and checks every swap against the pool vaults' balance changes in the same transaction:

PumpSwap · pump.fun bonding curve · Meteora DBC · Meteora DAMM v2 · Meteora DLMM · Meteora pools (dynamic AMM v1) · Raydium CLMM · Raydium CPMM · Raydium AMM v4 · Raydium LaunchLab · Orca Whirlpool

Venue ids in responses: `pumpswap` · `pumpfun` · `meteora_dbc` · `meteora_damm_v2` · `meteora_dlmm` · `meteora_pools` · `raydium_clmm` · `raydium_cpmm` · `raydium_v4` · `raydium_launchlab` · `orca`.

## What it does not read

- **Prop AMMs** (SolFi, HumidiFi and the like) and **order books**. Most SOL/USDC and other major-pair flow runs there, so those pairs show far less volume on Chord than on an all-market source. The tape is accurate for pump.fun, Meteora and Raydium style tokens; do not use it for a market-wide SOL volume.
- **Transfers.** A wallet's PnL is average cost over the swaps inside the window. A token that arrived by transfer, or was bought before the window, and is then sold shows up as a sell without a buy: the position is marked `partial: true` and those sells carry no realized PnL. `heldAmount` is bought minus sold inside the window, never the on-chain balance.

## Coverage and freshness

- Totals are complete from `coverageSince` (Unix seconds, on `/overview`) to now; a "24 hours" window never starts before it (`coverageHours` under 24 = a partial day). Quote that field rather than a date.
- `GET /v1/chains/solana/status` is the ingest's own health: `ok`, `lagSlots`, `blockAgeS` (age of the newest block written), swaps per minute, per-venue decode counters. A `false` `ok` or a large `blockAgeS` means every other route is behind by that much: say so when you show the numbers.
- Boards and stats are cached for 10 to 30 seconds, the trader board for 5 minutes.

## Addresses, units, names

- **Never lower-case a Solana address.** Base58 is case-sensitive: a lower-cased mint is another string, refused with `400 BAD_ADDRESS` when it is no longer valid base58 and answered `404 TOKEN_NOT_FOUND` otherwise. EVM validators (`0x` + 40 hex) do not apply.
- **Amounts are whole units**: `tokenAmount`, `heldAmount`, `supply` are in tokens with decimals applied; `quoteAmount` is in whole units of the pool's quote (SOL, USDC, USDT, or the other token of a token-to-token pool — see `pools[].quote`). Prices and `*Usd` fields are US dollars.
- **Every timestamp is Unix seconds, `updatedAt` included** (elsewhere in the API `updatedAt` is milliseconds).
- `symbol`, `name` and `image` are whatever the token's creator wrote. Many mints share a symbol: identify a token by its mint.
- **Most of Solana's busiest tokens are wallets trading with themselves.** On 13 and 14 October 2026, about two thirds of the 400 most traded tokens on the tape (some 70 % of their volume) had under 3 % of their volume from wallets that went one way. The token boards leave out such volume-bot tapes, and tickers that imitate SOL, USDC or USDT on another mint: `screened` says how many and how much volume, every row carries `oneWayPct` (the share of 24-hour volume from wallets that bought or sold, not both at about the same size), `/chains/solana/token/{address}` carries `flow24h` and search rows carry `screen`. A low `oneWayPct` on a row that is shown (a deep market whose flow is mostly arbitrage) still means its volume is not demand.

## Endpoints

| Need | Call |
| --- | --- |
| Is the tape current | `GET /v1/chains/solana/status` |
| 24-hour totals, venue share, hourly buckets, `coverageSince` | `GET /v1/chains/solana/overview` |
| The 24-hour token board | `GET /v1/chains/solana/tokens?sort=volume\|trades\|change\|new&limit=` |
| Find a token by mint, symbol or name | `GET /v1/chains/solana/search?q=` (exact symbol or name; a mint returns that token) |
| One token: price, change, market cap, liquidity, venues, pools, hourly | `GET /v1/chains/solana/token/{mint}?hours=24` (pass 24 or more: the 24-hour totals come from the same hourly rows) |
| Newest prints of a token | `GET /v1/chains/solana/token/{mint}/trades?limit=&before=` |
| Candles of the token's main pool (or `pool=`) | `GET /v1/chains/solana/token/{mint}/candles?tf=1m\|5m\|15m\|1h\|4h\|1d&limit=` |
| Who traded a token (whole UTC hours from `since`) | `GET /v1/chains/solana/token/{mint}/traders?hours=1..48&limit=` |
| The day's traders by realized PnL or volume | `GET /v1/chains/solana/traders?sort=pnl\|volume&days=1\|2&limit=` |
| A wallet's tokens and PnL | `GET /v1/chains/solana/wallet/{address}?days=1..45` |
| A wallet's swaps | `GET /v1/chains/solana/wallet/{address}/trades?limit=&before=` |

Full parameters, response fields and real examples: the **Solana data** section of the API reference. No key is needed. `/v1/candles`, `/v1/tokens/*`, `/v1/quote` and the other chain-id routes do not take Solana.

```bash
curl -s "https://api.getchord.xyz/v1/chains/solana/tokens?sort=trades&limit=5"
curl -s "https://api.getchord.xyz/v1/chains/solana/token/7VertkgF9KLhxxJXHX6uaWuoYZTP9LdGj2bWmVXVpump?hours=24"
curl -s "https://api.getchord.xyz/v1/chains/solana/token/7VertkgF9KLhxxJXHX6uaWuoYZTP9LdGj2bWmVXVpump/candles?tf=1h&limit=48"
```

## Paging

`/trades` routes take `before` (Unix seconds, exclusive). Pass the last row's `ts` for the next page; several swaps can share one second, so overlap with `ts + 1` and drop rows whose `tx` you already hold. A token's page looks back at most two days from `before`, a wallet's at most seven.