blog / solana-token-risk-api-for-bot-builders

Solana token risk API for bot builders: score every mint before your bot buys

A Solana token risk API lets your bot check a mint before it buys: send the address, get back a score and the reasons, and skip anything with a hard red flag. With MemeScore that is one call — GET /v1/check?mint=… — returning a 0–100 score, a verdict, plain-English reasons, the score’s four parts and RugCheck’s raw flags. Bots that buy without a check are the easiest exit liquidity on Solana. A single pre-trade filter means your bot spends its capital on coins that at least are not built to trap it.

This guide covers what the API returns, how to wire it into a bot, how limits and caching work, and what it does not do yet. Full reference: API docs.

What does the API return?

A real response, trimmed:

{
  "mint": "DezXAZ8z7PnrnRJjz3wXBoRgixCa6xjnB7YaB1pPB263",
  "score": 20,
  "parts": {"safety": 0, "demand": 96, "smart": 0, "social": 0},
  "capped": true,
  "verdict": "Rug pattern",
  "level": "rug",
  "reasons": ["Dev has launched 10 coins", "No X account or website"],
  "positives": ["Real, organic buyers"],
  "flags": ["mutable metadata"],
  "top10": 36.54,
  "liq": 5723858.26,
  "memescore_v1": null
}

The fields that matter most for a bot:

Every field is described on the response fields page. As the BONK example shows, a famous coin can still trip a hard flag (here, mutable metadata) — the score reports risk signals, not popularity.

How do you call it?

Create a key on your account page (API and Enterprise plans), then:

curl -s "https://memescore.io/v1/check?mint=$MINT" -H "X-API-Key: $MEMESCORE_KEY"

In Python, as a pre-trade gate:

import requests

def safe_to_consider(mint, key):
    r = requests.get("https://memescore.io/v1/check",
                     params={"mint": mint},
                     headers={"Authorization": f"Bearer {key}"},
                     timeout=15)
    if r.status_code == 429:
        return None  # back off: honour Retry-After
    r.raise_for_status()
    d = r.json()
    if "error" in d or d.get("capped") or d.get("level") == "rug":
        return False
    v1 = d.get("memescore_v1") or {}
    if v1.get("p_rug_6h") is not None and v1["p_rug_6h"] > 0.2:
        return False
    return True

The 0.2 threshold is an example, not a recommendation — tune it on your own results. JavaScript and more examples are in the quickstart.

What rules should a bot apply?

A reasonable starting point:

  1. Hard skip when capped is true or level is rug.
  2. Size down on caution, and read reasons in your logs to learn which ones cost you.
  3. Add your own rules on top10, liq and flags.
  4. Get a sell quote from your router at your trade size before buying. MemeScore does not simulate sells yet (coming soon).
  5. Re-check before adding to a position — authorities, liquidity and holders can change.

How do limits and caching work?

Errors are listed on the errors page. A 200 with an error field means the token was not found.

Can the bot watch new launches instead of polling?

Yes. API and Enterprise plans include GET /v1/feed: freshly graduated pump.fun coins and trending coins, already scored. Poll it instead of scoring every new mint yourself. Push webhooks are not available yet (coming soon), so poll at a sensible interval — the feed is rebuilt on a short cycle, and polling faster returns the same data.

GET /v1/search?q= turns a name or ticker into the right mint, with a possible_copycat flag — useful for Telegram bots where users type $TICKER. GET /v1/traders?mint= lists tracked wallets that traded a coin, with fast flippers flagged.

What are common integration patterns?

How do you tune it over time?

Log every check your bot makes next to the trade outcome. After a few hundred trades you will see which reasons actually cost you money in your strategy, and where your thresholds should sit. That is more useful than any generic setting, including ours.

Why trust the score in a bot?

You should not trust it blindly — you should measure it. We publish ours. GET /v1/ledger returns every v1 score, timestamped before the outcome and graded after 24 hours, so you can audit it yourself. The summary at /proof.json shows a back-test on 915 unseen graduated pump.fun coins: 33% of the riskiest tenth by score crashed 90% within six hours, versus 2% of the safest half. The live forward test is in progress, with early graded results — a small sample so far — in the same file. Past results do not guarantee future ones.

What the API does not do (yet)

Honest list, so you can plan around it:

How much does it cost?

API keys come with the API and Enterprise plans, each with a set number of keys, daily and per-minute caps, and the graduation feed. Plans and current prices are on the pricing page, and the API overview explains which plan fits which kind of bot. You can try the score for free on the homepage first.

Get started

  1. Run a free check on a few coins your bot traded last week.
  2. Read the methodology to see what drives the score.
  3. Pick a plan on pricing, create a key, and follow the quickstart.

Analytics only, not financial advice. MemeScore never asks for a wallet and never trades.

Frequently asked questions

Is there an API to check if a Solana token is a rug?

Yes. MemeScore’s GET /v1/check?mint= returns a 0–100 risk score, a verdict (Clean, Caution or Rug pattern), plain-English reasons, the four score parts and RugCheck’s raw flags in one JSON response. It needs an API key from an API or Enterprise plan; see docs and pricing.

How fast is the MemeScore API?

Results are cached per mint for a short window, so repeat calls for the same coin come back quickly with X-Cache: HIT. A fresh check waits on RugCheck, Jupiter and Helius, so budget a few seconds and set a timeout. Live status is at /status.

What are the API rate limits?

Limits are per account: a daily cap that resets at 00:00 UTC and a rolling per-minute cap, shared across all your keys and the website. Every response carries X-RateLimit headers, and GET /v1/usage shows what is left without using a check. Current numbers are on the rate limits page.

Does the API simulate a sell or detect bundles?

Not yet; both are coming soon. Today the score includes RugCheck’s linked-holder and insider flags and caps the score on hard flags such as active freeze authority or a custom token program. Request your own router quote for the sell side before buying.

Check a token free · How the score works · API docs · Pricing

← All posts · FAQ · Comparisons · Not financial advice.