# GMGN (/docs/nodes/data/gmgn)

Solana meme token data covering trending, K-line, holders, smart money, and wallet analytics.



The GMGN node queries the [GMGN OpenAPI](https://docs.gmgn.ai/index/gmgn-agent-api) for Solana meme token data: real-time trending rankings, K-line candles, security and pool details, top holders/traders, wallet activity, trenches (new launches), token signals, KOL/smart-money trades, and dev-created tokens. GMGN's value over generic chain explorers is its meme-trading lens: smart-money counts, KOL holdings, rat-trader ratios, and bundler exposure are first-class fields rather than derived metrics. GMGN's API also covers BSC, Base, and Ethereum, but this node is scoped to Solana to match the rest of the Solaris AI stack.

The node exposes read-only data operations. Trading (swap, strategy orders, cooking create-token) requires GMGN's signed-auth mode (Ed25519 request signing) and is intentionally not wired in yet. When it lands it ships as a separate v2.

Prerequisites [#prerequisites]

A GMGN API key is required. A public demo key (`gmgn_solbscbaseethmonadtron`) exists for testing only; ship workflows with your own key.

How to get an API key [#how-to-get-an-api-key]

GMGN issues API keys against an Ed25519 public key you upload. The Credentials page can generate that keypair for you in the browser, or you can bring your own (`openssl genpkey -algorithm ed25519`).

1. Open [Credentials](/docs/credentials/adding) in Solaris AI, click **Add credential**, pick platform **GMGN**, then click **Generate keypair**. The page derives the Ed25519 keypair locally and shows the public half.
2. Log in at [gmgn.ai/ai](https://gmgn.ai/ai).
3. Open the API Management tab directly: [gmgn.ai/ai?chain=sol\&tab=api\_management](https://gmgn.ai/ai?chain=sol\&tab=api_management).
4. Click **Create API Key**, paste the public key from step 1 into **Upload Public Key**, give it a label, and confirm. Read access is enough for this node. For swaps, use the [Jupiter](/docs/nodes/defi/jupiter) node.
5. Copy the returned API key and paste it into the Solaris AI **API Key** field. Save the credential.

Walkthrough video (starts from the API Management page after login):

<video src="https://cdn.solarisai.io/gmgn.mp4" preload="metadata" className="my-4 w-full rounded border border-border" />

> **Private key custody:** The keypair is generated in your browser via Web Crypto and never leaves the device. Solaris AI does not store this private key and cannot recover it. V1 read-only GMGN data does not use the private key after API key creation, so for this node the primary path is: generate the public key, upload it to GMGN, then paste the returned API key here. Save the private key only if you plan to use future signed GMGN trading features. The keygen helper is a convenience, you can also generate the keypair yourself with openssl and upload to GMGN directly.

Operations [#operations]

All operations run against Solana (`chain=sol`). The field is fixed and omitted from the config UI. Token and market operations take a token mint; portfolio operations take a wallet address.

Token [#token]

**`getTokenInfo`**: fundamentals for a token (name, symbol, market cap, holder count, price, 24h volume, social links). Use this as the first step of any "research a token" workflow before deciding whether to query pool or holder breakdowns.

**`getTokenSecurity`**: security audit signal (is the contract open source, is mint authority renounced, honeypot detection, wash-trade flag, rug ratio score 0 to 1). Pair with `getTokenInfo` for a buy/skip gate before any trade workflow.

**`getTokenPoolInfo`**: liquidity pool details (which DEX/launchpad the token trades on, pool liquidity, bonding curve status via `is_on_curve` which indicates whether the token has graduated from a launchpad to open DEX trading).

**`getTokenTopHolders`**: paginated list of holders sorted by balance. Useful for concentration analysis (does the top wallet hold >20%? is one wallet about to dump?). `limit` clamps to 1 to 100.

**`getTokenTopTraders`**: wallets that have traded the token most by volume/PnL. Distinct from holders since a top trader may have already exited. Useful for finding KOL-style accounts to follow.

Market [#market]

**`getTrendingSwaps`**: chain-wide trending tokens over an interval. Returns the same ranking the GMGN web app shows. Interval enum: `1m`, `5m`, `1h`, `6h`, `24h`. The 1-minute window is GMGN's headline differentiator vs. competitors who only refresh hourly. Sort by `volume`, `swaps`, `price`, `change1h`, `marketcap`, or `holder_count`. Optional preset filters (`not_risk`, `not_honeypot`) drop unsafe tokens before they reach the response.

**`getTokenKline`**: OHLCV candles for a single token. Resolutions: `1m`, `5m`, `15m`, `1h`, `4h`, `1d`. `timeFrom` and `timeTo` are Unix **seconds** (the executor converts to ms for the API). Each side defaults independently: omitted `timeFrom` becomes `now - 24h`, omitted `timeTo` becomes `now`.

**`getTrenches`**: new-launch feed grouped into `new_creation`, `near_completion`, and `completed` categories (all three by default). Filter by launchpad platform (Pump.fun, letsbonk, bonkers, ...) and apply an optional advanced filter object (e.g. `{"min_holder_count": 100, "max_rug_ratio": 0.2}`). `limit` clamps to 1 to 80 per category.

**`getTokenSignalV2`**: pull tokens that just tripped one or more GMGN signals (price spikes, large buys, smart-money entries, etc.). Configure via a JSON array of groups: each group can set `signal_type` (number array), `mc_min`/`mc_max`, `trigger_mc_min`/`trigger_mc_max`, `total_fee_min`/`total_fee_max`, and `min_create_or_open_ts`/`max_create_or_open_ts` (Unix seconds strings).

Track [#track]

**`getKol`**: KOL (key-opinion-leader) trade records. `limit` clamps to 1 to 200. Returns a feed of recent trades by GMGN-tagged KOL wallets so workflows can mirror or alert on tape they care about.

**`getSmartMoney`**: same shape as `getKol`, but the wallet cohort is GMGN's smart-money classification (high win-rate, profitable, repeat-bidder wallets) rather than KOL accounts.

**`getCreatedTokens`**: tokens created by a developer wallet, optionally sorted by `market_cap` or `token_ath_mc` with `asc`/`desc` direction, and filtered to only `migrated` or `non_migrated` tokens. Useful for dev-history due diligence ("has this dev shipped anything that lasted?").

Portfolio [#portfolio]

**`getWalletActivity`**: recent on-chain trade activity for a wallet. Pair with templating to feed a wallet's last N trades into an AI summary node.

**`getWalletStats`**: aggregate stats (PnL, win rate, trade style) for one or more wallets over a `period` window (`1d`, `7d`, `30d`, `all`). Supports multi-wallet comparison: fill **Wallet Address** or **Additional Wallets** (comma-separated), or both, as long as at least one wallet is present.

**`getWalletTokenBalance`**: single-token balance for a wallet. Useful as a precondition check (does this wallet still hold X before we trigger a sell condition?).

Account and network meta [#account-and-network-meta]

**`getUserInfo`**: account info bound to the GMGN API key. Takes no parameters. Use as a credential health check.

**`getGasPrice`**: GMGN's recommended Solana priority-fee tier (fast/standard/safe). The Solana scheduler is fee-driven, so workflows that broadcast transactions can read this and feed it into a pump.fun / Phoenix / Raydium node's `priorityFee` field.

**`getCookingStatistics`**: aggregate read-side metrics for GMGN's cooking (auto-buy + auto-exit) strategy engine. The signed-auth side of cooking (creating tokens) is parked for v2; this read-only stats endpoint is exposed today.

Configuration [#configuration]

| Field           | Type      | Required                        | Description                                                                            |
| --------------- | --------- | ------------------------------- | -------------------------------------------------------------------------------------- |
| address         | string    | Token ops + `getTokenKline`     | Token mint address                                                                     |
| walletAddress   | string    | Wallet ops + `getCreatedTokens` | Single wallet to query                                                                 |
| walletAddresses | string    | Optional, `getWalletStats`      | Additional comma-separated wallets                                                     |
| tokenAddress    | string    | `getWalletTokenBalance`         | Mint to check the balance of                                                           |
| interval        | string    | `getTrendingSwaps`              | `1m` \| `5m` \| `1h` \| `6h` \| `24h`                                                  |
| resolution      | string    | `getTokenKline`                 | `1m` \| `5m` \| `15m` \| `1h` \| `4h` \| `1d`                                          |
| timeFrom        | number    | No                              | Kline window start, Unix **seconds**                                                   |
| timeTo          | number    | No                              | Kline window end, Unix **seconds**                                                     |
| period          | string    | `getWalletStats`                | `1d` \| `7d` \| `30d` \| `all`                                                         |
| orderBy         | string    | No                              | Trending sort or `getCreatedTokens` sort (`market_cap` \| `token_ath_mc`)              |
| direction       | string    | No                              | `getCreatedTokens` sort direction (`asc` \| `desc`)                                    |
| migrateState    | string    | No                              | `getCreatedTokens` filter (`migrated` \| `non_migrated`)                               |
| filters         | string\[] | No                              | Trending presets: `not_risk`, `not_honeypot`                                           |
| types           | string\[] | No                              | `getTrenches` categories (`new_creation`, `near_completion`, `completed`); empty = all |
| platforms       | string\[] | No                              | `getTrenches` launchpads (Pump.fun, letsbonk, ...); empty = all                        |
| filtersJson     | string    | No                              | `getTrenches` advanced filters, JSON object of `{key: number\|string}`                 |
| groupsJson      | string    | `getTokenSignalV2`              | JSON array of signal-group objects (see Market)                                        |
| limit           | number    | No                              | Clamped per op: trenches 1 to 80, kol/smartmoney 1 to 200, others 1 to 100             |

Output [#output]

Most operations return the standard envelope:

```json
{
  "success": true,
  "operation": "getTokenInfo",
  "chain": "sol",
  "address": "So11111111111111111111111111111111111111112",
  "data": { /* raw GMGN response */ }
}
```

The upstream payload is always under `.data`. Reference fields downstream with the response name (default `gmgnResponse`), for example `{gmgnResponse.data.price}` after `getTokenInfo` or `{gmgnResponse.data[0].symbol}` after `getTrendingSwaps`.

Two ops do **not** accept a chain parameter upstream, so the envelope omits the `chain` echo for them: `getUserInfo` and `getCookingStatistics`. Their shape is `{success, operation, data}`.

Common use cases [#common-use-cases]

* **Pre-trade due diligence**: chain `getTokenInfo`, then `getTokenSecurity`, then AI summarize, then conditional execute.
* **Trending scanner**: poll `getTrendingSwaps` on a cron, filter for `not_risk` + `not_honeypot`, route the top result to a Telegram alert.
* **Launch radar**: cron `getTrenches` for `near_completion` on selected launchpads, AI-rank by smart-money count, alert on the top hit.
* **Signal mirror**: `getTokenSignalV2` with smart-money signal types, then route into a Phoenix or pump.fun buy with an upstream wallet cap.
* **Wallet copy-trade research**: `getWalletStats` over `30d` plus `getKol` / `getSmartMoney` feeds, AI-rank by win rate, persist the top wallets to a dataset.
* **Dev background check**: `getCreatedTokens` against a candidate dev wallet, filter `migrated`, summarize ATH and survival.
* **Fee-aware broadcast**: `getGasPrice` before signing, feed the fast tier into the trading node's `priorityFee` field.
* **Position monitoring**: schedule `getWalletTokenBalance` for held positions, branch on balance drops via the Condition node.

Notes and limits [#notes-and-limits]

* **Rate limits**: GMGN returns 429 with an `x-ratelimit-reset` header on burst. The node surfaces the reset time in the error message; back off in a Delay node before retrying.
* **Solana-only**. EVM chains aren't wired up; the executor rejects any non-`sol` chain value (e.g. from an imported workflow) with a clear error.