# Check a token developer's history (past launches and rugs)

> Check a Robinhood Chain token creator's track record in one call: every token they launched, peak and current market cap, graduations, rugs, dev selling.

Source: https://docs.crius.sh/guides/check-developer-history/ · Updated 2026-10-28

Short answer

Call `GET /v1/robinhood/dev/{address}` (Free plan, 5 credits). `summary` gives `tokens_created`, `graduated`, `graduation_rate_pct`, `rugged` and the best and median peak market cap; `tokens[]` lists each launch with `status`, `ath_market_cap_usd`, `market_cap_usd`, `liquidity_usd`, `dev_sold_pct` and `rugged`. Get the creator from the token profile's `launch.creator`.

[GET `/dev/{address}`](https://docs.crius.sh/reference/wallets/developer-profile/) [GET `/token/{address}`](https://docs.crius.sh/reference/tokens/token-profile/) [GET `/wallet/{address}/connections`](https://docs.crius.sh/reference/wallets/wallet-connections/)

A developer profile is a token creator’s track record: every token the wallet launched on a launchpad or deployed directly, how high each one went, where it is now, whether it graduated, whether it rugged, and how much of it the developer sold. It’s the first thing to check before buying a new launch. A creator with ten dead tokens behind them is telling you something the contract can’t.

## Check the developer in one call

Example [Free plan · 5 credits](https://docs.crius.sh/reference/wallets/developer-profile/)

### CHARGE's creator: one Pons launch, graduated, not a rug

Has the developer of Charge AI (0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca) launched other tokens, and how did they do?

GET/v1/robinhood/dev/0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca

 

**cURL**

```bash
curl "https://api.crius.sh/v1/robinhood/dev/0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca" \
  -H "x-api-key: $CRIUS_API_KEY"
```

**JavaScript**

```js
const res = await fetch("https://api.crius.sh/v1/robinhood/dev/0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca", {
  headers: { "x-api-key": process.env.CRIUS_API_KEY },
});
const { data, meta } = await res.json();
```

**Python**

```python
import os, requests

r = requests.get(
    "https://api.crius.sh/v1/robinhood/dev/0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca",
    headers={"x-api-key": os.environ["CRIUS_API_KEY"]},
)
body = r.json()
print(body["data"])
```

**Real response 200 Captured Oct 28, 2026 · 61 lines (arrays trimmed)**

```json
{
  "data": {
    "address": "0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca",
    "first_seen_ts": 1792283372000,
    "funded_by": {
      "address": "0xd782268f600403843484b70710daee6846fc0db8",
      "amount_eth": 0.008148386337868892,
      "label": "bridge:Relay solver"
    },
    "summary": {
      "best_ath_market_cap_usd": 68675.8,
      "by_launchpad": {
        "pons": 1
      },
      "graduated": 1,
      "graduation_rate_pct": 100,
      "median_ath_market_cap_usd": 68675.8,
      "rugged": 0,
      "tokens_created": 1
    },
    "tokens": [
      {
        "address": "0x7b8892cea949bc60d494681d1bc3ea96071ab0b8",
        "ath_market_cap_usd": 68675.8,
        "ath_scope": "all_time",
        "created_block": 88385886,
        "created_ts": 1791982834000,
        "deployed_via": "launchpad",
        "dev_sold_pct": null,
        "launchpad": "pons",
        "launchpad_name": "Pons",
        "liquidity_usd": 5611.81,
        "logo": "https://api.crius.sh/v1/robinhood/logo/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8.png?size=128",
        "market_cap_usd": 3773.42,
        "name": "Charge AI",
        "rugged": false,
        "status": "graduated",
        "symbol": "CHARGE"
      }
    ],
    "top_tokens": [
      {
        "address": "0x7b8892cea949bc60d494681d1bc3ea96071ab0b8",
        "ath_market_cap_usd": 68675.8,
        "logo": "https://api.crius.sh/v1/robinhood/logo/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8.png?size=128",
        "symbol": "CHARGE"
      }
    ]
  },
  "meta": {
    "block": 100406874,
    "block_age_ms": 1212,
    "block_ts": 1793225085000,
    "chain": "robinhood",
    "finalized_block": 100397649,
    "lag_ms": 26,
    "next_cursor": null,
    "rugged_rule": "market cap < 10% of ATH (ATH > $5k) and liquidity < $500",
    "safe_block": 100401329
  }
}
```

What this tells you

-   `summary.tokens_created: 1` with `by_launchpad: {"pons": 1}`, `graduated: 1` and `graduation_rate_pct: 100`: a first-time creator whose only token completed its bonding curve.
-   The token is CHARGE (`0x7b8892cea949bc60d494681d1bc3ea96071ab0b8`), `deployed_via: "launchpad"` on Pons, created in block 88385886 (`created_ts: 1791982834000`, 2026-10-14 13:00 UTC), `status: "graduated"`.
-   `ath_market_cap_usd: 68675.8` against `market_cap_usd: 3773.42` now: about 95% below its peak. Yet `rugged: false` and `summary.rugged: 0`, because `liquidity_usd: 5611.81` is still above the $500 in `meta.rugged_rule` (“market cap < 10% of ATH (ATH > $5k) and liquidity < $500”). The token faded; nobody pulled the liquidity.
-   `dev_sold_pct: null`: the creator never held any CHARGE, so it couldn’t dump on buyers. Its [trade history](https://docs.crius.sh/guides/get-wallet-trade-history/#creator-no-trades) is empty too.
-   `funded_by` is `0xd782268f600403843484b70710daee6846fc0db8` (`bridge:Relay solver`, 0.008148386337868892 ETH): the wallet was funded over a bridge, not by another known dev. [Connected wallets](https://docs.crius.sh/guides/find-connected-wallets/#creator-connections) confirms no `linked_devs`.
-   `top_tokens` lists the creator’s best launches by peak market cap (up to three); here only CHARGE.

[Developer profile reference](https://docs.crius.sh/reference/wallets/developer-profile/) [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20CHARGE's%20creator%3A%20one%20Pons%20launch%2C%20graduated%2C%20not%20a%20rug&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Fcheck-developer-history%2F%23charge-dev%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Fdev%2F0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A)

## What the fields mean

| Field | Meaning |
| --- | --- |
| `summary.tokens_created`, `by_launchpad` | Tokens launched or deployed, in total and per launchpad (`direct` for contracts deployed without one). |
| `summary.graduated`, `graduation_rate_pct` | Launches that completed their bonding curve, and their share. |
| `summary.rugged` | Tokens that match `meta.rugged_rule`. |
| `summary.best_ath_market_cap_usd`, `median_ath_market_cap_usd` | The highest and the median peak market cap of the creator's tokens. |
| `tokens[].status` | Launch stage, for example `graduated`. |
| `tokens[].deployed_via`, `launchpad`, `launchpad_name` | `launchpad` or `direct`, and which launchpad. |
| `tokens[].created_block`, `created_ts` | When the token was created. |
| `tokens[].ath_market_cap_usd`, `ath_scope`, `market_cap_usd` | Peak market cap, the period it covers (`all_time`), and the market cap now. |
| `tokens[].liquidity_usd` | Liquidity now, across the token's pools. |
| `tokens[].dev_sold_pct` | Share of the tokens the creator received that it later moved out of its wallet; `null` if it never held any. |
| `tokens[].rugged` | `true` when the token matches the rug rule. |
| `top_tokens[]` | Up to three best launches by peak market cap: `address`, `symbol`, `logo`, `ath_market_cap_usd`. |
| `funded_by` | The creator's first funder: `address`, `label`, `amount_eth`. |

`sort` orders `tokens[]` by `created` (default, newest first), `ath` or `market_cap`. `limit` takes up to 500 (default 50); page with `cursor` (`meta.next_cursor`).

## What to look for

-   **Many launches, few graduations.** A creator with dozens of tokens and a `graduation_rate_pct` near zero is making throwaway tokens: most never found enough buyers to fill the curve.
-   **`rugged` above zero.** Read which tokens, and check `dev_sold_pct` on them: a dev who sold 100% into a dying token did the dumping.
-   **A low median peak.** `median_ath_market_cap_usd` far below `best_ath_market_cap_usd` means one lucky hit among many failures.
-   **The wallet is new.** A fresh creator wallet says nothing on its own. Check who funded it: a creator funded by another dev’s wallet should be judged by that dev’s history too. [Connected wallets](https://docs.crius.sh/guides/find-connected-wallets/) shows the link.

## Use it in your app

1.  **Find the creator.** The token profile (`GET /v1/robinhood/token/{address}`, anonymous plan) has `launch.creator` for launchpad tokens. For CHARGE it’s `0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca`.
    
2.  **Get a Free key and call `/dev/{creator}`.** 5 credits per call; send the key in `x-api-key`.
    
3.  **Turn the summary into a verdict.** For example: warn when `summary.rugged` is 1 or more, or when `tokens_created` is high and `graduation_rate_pct` is low. Show the past tokens so users can judge for themselves.
    
4.  **Combine it with the token’s own checks.** The [security score](https://docs.crius.sh/guides/token-security-score/) covers the contract, taxes and liquidity, and [bundles & snipers](https://docs.crius.sh/guides/detect-bundles-and-snipers/) who bought the launch.
    

```js
// Dev check for a new launch: find the creator, then read their track record.
const token = "0x7b8892cea949bc60d494681d1bc3ea96071ab0b8";
const api = "https://api.crius.sh/v1/robinhood";
const headers = { "x-api-key": process.env.CRIUS_API_KEY };

const { data: profile } = await (await fetch(`${api}/token/${token}`, { headers })).json();
const creator = profile.launch?.creator;
if (!creator) throw new Error("not a launchpad token");

const { data: dev } = await (await fetch(`${api}/dev/${creator}?sort=created`, { headers })).json();
const s = dev.summary;
console.log(`${s.tokens_created} tokens, ${s.graduated} graduated (${s.graduation_rate_pct}%), ${s.rugged} rugged`);
for (const t of dev.tokens) {
  console.log(t.symbol, t.status, `peak $${t.ath_market_cap_usd}`, `now $${t.market_cap_usd}`, t.rugged ? "RUGGED" : "", `dev sold ${t.dev_sold_pct ?? "-"}%`);
}
```

## Frequently asked questions

**How do I check if a token's developer has rugged before?**

Get the creator from the token profile (`launch.creator` on `/token/{address}`, no key needed), then call `/dev/{creator}`. `summary.rugged` counts their past tokens that rugged, and each entry in `tokens[]` has `rugged`, `ath_market_cap_usd`, `market_cap_usd` and `dev_sold_pct`.

**What counts as a rug?**

A token whose market cap is under 10% of its all-time high (when that high was above $5k) and whose liquidity is under $500. The rule is returned in `meta.rugged_rule`. A token that fell hard but still has liquidity isn't counted as a rug: CHARGE is down about 95% from its peak but keeps $5,611.81 of liquidity.

**What does \`dev\_sold\_pct\` mean?**

The share of the tokens the creator received that later left its wallet, from 0 to 100. A dev who bought their own launch and sold everything shows 100. It's `null` when the creator never held the token.

**Does it include tokens deployed without a launchpad?**

Yes. `tokens[]` covers launchpad launches by the creator (`deployed_via: "launchpad"`) and token contracts it deployed directly (`deployed_via: "direct"`). `summary.by_launchpad` counts them per launchpad.

**Which plan does the developer profile need?**

The Free plan (a free API key), 5 credits per call. See [Plans & limits](https://docs.crius.sh/plans-and-limits/).

## Related

[Guide **Connected wallets** Find who funded a Robinhood Chain wallet, which wallets it funded, who it swaps tokens with and who shares its funder, to spot alt wallets, dev links, sybils. Read](https://docs.crius.sh/guides/find-connected-wallets/) [Guide **Detect bundles & snipers** Find out who bought a Robinhood Chain token's launch, how much of the supply snipers and bundles took and whether they still hold it, with a real insider launch that fell 97%. Read](https://docs.crius.sh/guides/detect-bundles-and-snipers/) [Guide **Token security score** Score any Robinhood Chain token from 0 to 100 with one API call. Honeypot, buy and sell taxes, owner powers, LP locks, v4 hook risk and insider launches, with real examples. Read](https://docs.crius.sh/guides/token-security-score/) [Concept **Launch risk** How Crius spots insider control of a Robinhood Chain token with a clean contract (snipers, wallet farms, uniform holders, LP control) and the thresholds it uses. Read](https://docs.crius.sh/concepts/launch-risk/) [Concept **Launchpads** How token launchpads on Robinhood Chain work (bonding curves, graduation to Uniswap pools, LP locks) and which launchpads Crius attributes, including Pons, Flap.sh, Bankr, Long.xyz and Flywheel. Read](https://docs.crius.sh/concepts/launchpads/) [API reference **Developer profile API** A token creator's track record: every token they deployed or launched, with peak market cap, current state and outcomes. Read](https://docs.crius.sh/reference/wallets/developer-profile/)