# Get a token's full activity feed (trades, transfers, liquidity)

> Get every event of a Robinhood Chain token in one feed, from trades and transfers to liquidity, burns, owner actions, locks and graduation, with real examples.

Source: https://docs.crius.sh/guides/get-token-activity-feed/ · Updated 2026-10-28

Short answer

Call `GET /v1/robinhood/token/{address}/transactions`. It returns one newest-first feed of everything that happened to the token: `buy`, `sell`, `add_liquidity`, `remove_liquidity`, `transfer`, `mint`, `burn`, `owner_action`, `lock`, `fee_claim`, `launch` and `graduation`. Each row has `type`, `block`, `ts`, `tx`, `finality`, the sender (`actor`) and the decoded `method`. Filter with `type`, `wallet`, `min_usd`, `from`, `to` and `finality`. Free plan (API key needed), 2 credits per call.

[GET `/token/{address}/transactions`](https://docs.crius.sh/reference/trades/activity-feed/) [GET `/token/{address}/trades`](https://docs.crius.sh/reference/trades/trade-tape/)

The activity feed is a token’s full history as one timeline. Instead of stitching together swaps, ERC-20 transfers, LP events, locker events and contract calls yourself, you get them merged and decoded, newest first, with one cursor. Use it for a token page’s “Activity” tab, for auditing what a contract owner did, or for tracking liquidity being added and pulled.

## Get the latest activity in one call

Example [Free plan · 2 credits](https://docs.crius.sh/reference/trades/activity-feed/)

### Charge AI's latest events: three sells, three ways of sending them

What happened to Charge AI (0x7b8892cea949bc60d494681d1bc3ea96071ab0b8) most recently, and who did it?

GET/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/transactions?limit=3

 

**cURL**

```bash
curl "https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/transactions?limit=3" \
  -H "x-api-key: $CRIUS_API_KEY"
```

**JavaScript**

```js
const res = await fetch("https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/transactions?limit=3", {
  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/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/transactions?limit=3",
    headers={"x-api-key": os.environ["CRIUS_API_KEY"]},
)
body = r.json()
print(body["data"])
```

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

```json
{
  "data": [
    {
      "actor": "0xffb51d3cc36b1356d5b9418198adee9f29283c58",
      "actor_tags": [],
      "amount_base": 788818.58267172958349331,
      "amount_quote": 0.001303958643843039,
      "block": 100128111,
      "dex": "uniswap_v4",
      "fees": {
        "token_tax": {
          "pct": 0
        }
      },
      "finality": "finalized",
      "id": "100128111-7-34",
      "method": "dagSwapTo(uint256,address,(uint256,address,uint256,uint256,uint256),(address[],address[],uint256[],bytes[],uint256)[])",
      "pool": "0x871b166182fd708d5d16a4daa9a42f05a653fa51ee2b195097f425e0d9ca4913",
      "quote_symbol": "ETH",
      "trader": "0xffb51d3cc36b1356d5b9418198adee9f29283c58",
      "trader_tags": [],
      "ts": 1793196203320,
      "tx": "0x8d68dc0ee4294bf07b052c4684ccc7211e9944438fa23c0866ccadb1aa1a0999",
      "type": "sell",
      "value_usd": 3.04084
    },
    {
      "actor": "0x06386c82d3d4be2704f9ca7da3b0b7422cf7472c",
      "actor_tags": [],
      "amount_base": 740848.926745217054477405,
      "amount_quote": 0.001227267922525477,
      "block": 99713565,
      "dex": "uniswap_v4",
      "fees": {
        "token_tax": {
          "pct": 0
        }
      },
      "finality": "finalized",
      "id": "99713565-9-26",
      "method": null,
      "pool": "0x871b166182fd708d5d16a4daa9a42f05a653fa51ee2b195097f425e0d9ca4913",
      "quote_symbol": "ETH",
      "trader": "0x06386c82d3d4be2704f9ca7da3b0b7422cf7472c",
      "trader_tags": [],
      "ts": 1793152958500,
      "tx": "0x74cd5b3dd10ab859b6e6da32e9352880cce954a8702378879f078c76936dc489",
      "type": "sell",
      "value_usd": 2.88648
    },
    {
      "actor": "0x4337044e8b7a221d141fe622eb2460f050a6b6c2",
      "actor_tags": [],
      "amount_base": 3467283.726496635780002732,
      "amount_quote": 0.005777579700862946,
      "block": 99235194,
      "dex": "uniswap_v4",
      "fees": {
        "token_tax": {
          "pct": 0
        }
      },
      "finality": "finalized",
      "id": "99235194-5-13",
      "method": "handleOps((address,uint256,bytes,bytes,bytes32,uint256,bytes32,bytes,bytes)[],address)",
      "pool": "0x871b166182fd708d5d16a4daa9a42f05a653fa51ee2b195097f425e0d9ca4913",
      "quote_symbol": "ETH",
      "trader": "0x4498f864313237eb18f593fecd47181979551376",
      "trader_tags": [
        "smart_account",
        "fomo"
      ],
      "ts": 1793103300400,
      "tx": "0x504e29889e0ff0dd2a4a5e70f4e47d2fe0f9c48eed33604fad83a199efd10c94",
      "type": "sell",
      "value_usd": 13.3484
    }
  ],
  "meta": {
    "block": 100406803,
    "block_age_ms": 823,
    "block_ts": 1793225078000,
    "chain": "robinhood",
    "finalized_block": 100397649,
    "history": "complete",
    "lag_ms": 80,
    "next_cursor": "99235194-13",
    "safe_block": 100401329
  }
}
```

What this tells you

-   All three rows are `type: "sell"` in the CHARGE/ETH Uniswap v4 pool, and all are `finality: "finalized"`: settled on Ethereum.
-   The newest sold 788,818.58 CHARGE for 0.001303958643843039 ETH (`value_usd: 3.04084`). Its `method` is `dagSwapTo(…)`, a router call, and `actor` equals `trader`: the wallet sent its own transaction.
-   The second has `method: null` (the function wasn’t one Crius can decode) and is again sent by the trader itself.
-   The third, $13.3484, is a smart-wallet trade: `actor` is the bundler 0x4337044e8b7a221d141fe622eb2460f050a6b6c2 calling `handleOps(…)`, and `trader` 0x4498f864313237eb18f593fecd47181979551376 has `trader_tags: ["smart_account", "fomo"]`.
-   `fees.token_tax.pct: 0` on each: sellers received everything the pool paid out.
-   `meta.history: "complete"`: the feed goes back to the token’s first block. Page with `meta.next_cursor` (`"99235194-13"`).

[Activity feed reference](https://docs.crius.sh/reference/trades/activity-feed/) [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20Charge%20AI's%20latest%20events%3A%20three%20sells%2C%20three%20ways%20of%20sending%20them&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Fget-token-activity-feed%2F%23charge-feed%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Ftoken%2F0x7b8892cea949bc60d494681d1bc3ea96071ab0b8%2Ftransactions%3Flimit%3D3%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A)

## Event types and their fields

Every row has `id`, `type`, `block`, `ts`, `tx`, `finality`, `actor` (the transaction sender), `actor_tags` and `method` (the decoded function the transaction called). The rest depends on the type:

| `type` | What it is | Extra fields |
| --- | --- | --- |
| `buy`, `sell` | A swap in any pool or launch curve | `trader`, `trader_tags`, `pool`, `dex`, `amount_base`, `amount_quote`, `quote_symbol`, `value_usd`, `fees.token_tax.pct` |
| `add_liquidity`, `remove_liquidity` | Liquidity added to or removed from a pool | `provider`, `pool`, `dex`, `amounts` (both tokens), `value_usd` |
| `transfer`, `mint`, `burn` | ERC-20 movements. Mints come from `0x0`; burns go to `0x0` or a dead address | `from`, `to`, `amount`, `value_usd` |
| `owner_action` | An event emitted by the token contract itself (ownership, trading switches, setters, upgrades) | `contract`, `event` (decoded) |
| `lock` | An event from a locker or vesting contract that involves the token | `contract`, `contract_label`, `event` |
| `fee_claim` | A fee claim or collect event involving the token | `contract`, `event` |
| `launch`, `graduation` | The launchpad lifecycle | `launchpad`, `creator` |

## Filter the feed

| Parameter | Example | Use |
| --- | --- | --- |
| `type` | `type=add_liquidity,remove_liquidity` | Only some event types (comma list) |
| `wallet` | `wallet=0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca` | One wallet’s trades, liquidity changes and transfers, e.g. the creator’s |
| `min_usd` | `min_usd=1000` | Skip small events |
| `from`, `to` | `from=launch&to=graduation` | A range: `block:N`, `ts:MS`, `mcap:USD`, `launch`, `trading_open`, `graduation` or `ath` |
| `finality` | `finality=safe` | Only events at that finality level or better |
| `limit`, `cursor` | `limit=100` | Page size, and `meta.next_cursor` for the next page |

`from=launch&to=graduation`, for example, gives you everything that happened while a launchpad token was on its bonding curve, and `type=owner_action` every change the token contract recorded (ownership, trading switches, settings).

## Use it in your app

1.  **Get a free key** at [dashboard.crius.sh](https://dashboard.crius.sh) and send it in the `x-api-key` header. Each call costs 2 credits.
    
2.  **Render rows by `type`.** Trades show side, amount and USD; liquidity rows show `amounts`; transfers show `from` → `to`. Use `actor_tags` and `trader_tags` to label bots, smart accounts and app wallets.
    
3.  **Mark unsettled rows.** Rows with `finality: "latest"` are confirmed by the sequencer but not yet posted to Ethereum. See [Finality & reorgs](https://docs.crius.sh/concepts/finality/).
    
4.  **Page back with `cursor`**, or keep the newest `id` and poll for new rows. For real-time updates, use the [WebSocket stream](https://docs.crius.sh/guides/stream-trades-websocket/).
    

```js
// Liquidity history of a token: every add and remove since launch.
const token = "0x7b8892cea949bc60d494681d1bc3ea96071ab0b8";
const url = new URL(`https://api.crius.sh/v1/robinhood/token/${token}/transactions`);
url.search = new URLSearchParams({ type: "add_liquidity,remove_liquidity", from: "launch", limit: "100" });

const res = await fetch(url, { headers: { "x-api-key": process.env.CRIUS_API_KEY } });
const { data, meta } = await res.json();
for (const e of data) {
  const sides = e.amounts.map((a) => `${a.amount} ${a.symbol}`).join(" + ");
  console.log(new Date(e.ts).toISOString(), e.type, sides, `$${e.value_usd}`, e.provider);
}
if (meta.next_cursor) console.log("more: cursor =", meta.next_cursor);
```

Plan needed

The activity feed is on the Free plan: without a key it returns `403 plan_required` with `required_plan: "free"` (see [Errors](https://docs.crius.sh/errors/)). The swaps alone are available without a key from the [trade tape](https://docs.crius.sh/guides/get-token-trades/).

## Frequently asked questions

**How do I see all transactions of a Robinhood Chain token?**

Call `GET /v1/robinhood/token/{address}/transactions` with a free API key. It merges trades, transfers, liquidity changes, mints and burns, lock events, fee claims, the contract owner's actions and launchpad events into one list, newest first, and pages back to the token's first block with `cursor`.

**What's the difference between the activity feed and the trade tape?**

The [trade tape](https://docs.crius.sh/guides/get-token-trades/) (`/trades`) has swaps only, with full detail: price, gas, router (`via`), executor and signer. It's on the anonymous plan. The activity feed (`/transactions`) has every event type in one timeline, with less detail per trade, and needs a free key.

**How do I find when a token's owner renounced ownership or changed taxes?**

Filter the feed with `type=owner_action`. Those rows are events emitted by the token contract itself, decoded, so calls like `renounceOwnership`, `openTrading`, setters and upgrades show up with the block and transaction they happened in.

**Why is the actor different from the trader?**

`actor` is the address that sent the transaction. For trades through a smart-wallet app, that's a bundler or relayer, while `trader` is the wallet whose balance changed. In the example, `actor` 0x4337044e8b7a221d141fe622eb2460f050a6b6c2 sent an ERC-4337 bundle (`handleOps`) for the smart account 0x4498f864313237eb18f593fecd47181979551376.

## Related

[Guide **Token trades** Get every buy and sell of a Robinhood Chain token with USD value, price, gas, tax and the real trader behind routers and smart wallets. Real examples, no key. Read](https://docs.crius.sh/guides/get-token-trades/) [Guide **Check liquidity locks** Find out whether a Robinhood Chain token's liquidity is locked, burned or held by wallets that can pull it, pool by pool, with the locker and unlock date. Real examples from Pons tokens. Read](https://docs.crius.sh/guides/check-liquidity-locked/) [Guide **Stream trades** Stream every trade of a Robinhood Chain token, pool or wallet over the Crius WebSocket, with Node.js and Python clients that reconnect, resume and backfill. Read](https://docs.crius.sh/guides/stream-trades-websocket/) [Concept **Finality & reorgs** Finality levels on Robinhood Chain (latest, safe, finalized), how the Crius API marks them, and how chain reorganizations are handled in REST and WebSocket. Read](https://docs.crius.sh/concepts/finality/) [API reference **Activity feed API** One chronological feed of everything that happened to the token: buys and sells, liquidity adds and removes, plain transfers, mints and burns, LP lock events, fee claims, owner actions on the contract Read](https://docs.crius.sh/reference/trades/activity-feed/)