# Crypto Wallet Analytics API - Nansen Smart Money, Token Flows (`nabeelbaghoor/crypto-wallet-smart-money-api`) Actor

Pull Nansen on-chain data into a dataset: Smart Money net flows, holdings and DEX trades, token screener, holders, flows, buyers and sellers, DEX trades, transfers and OHLCV, plus wallet balances, transactions, counterparties, related wallets, PnL and labels. Bring your own API key.

- **URL**: https://apify.com/nabeelbaghoor/crypto-wallet-smart-money-api.md
- **Developed by:** [Nabeel Hassan](https://apify.com/nabeelbaghoor) (community)
- **Categories:** Developer tools, Business, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 token market record returneds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Crypto Wallet Analytics API - Nansen Smart Money, Token Flows

Export Nansen on-chain analytics (Smart Money flows, token holders and trades, wallet balances, PnL and labels) into an Apify dataset with your own Nansen API key.

This actor wraps the official Nansen API. It turns a list of token contract addresses, wallet addresses or entity names into clean, deduplicated rows you can download as JSON, CSV or Excel, schedule hourly or daily, or feed into trading research, risk monitoring, compliance checks, dashboards, spreadsheets and AI agents. Bring your own API key.

### What it does

- **Smart Money net flows, holdings and DEX trades**: which tokens Nansen's curated set of top performing wallets is buying, selling and holding, across Ethereum, Solana, Base, BNB Chain, Arbitrum and more.
- **Token screener**: trending tokens by volume, buy and sell volume, net flow, liquidity, market cap, FDV, token age and trader counts, over 5 minutes to 30 days, filtered by trader type and Smart Money label.
- **Token God Mode analytics for one token**: token information and spot metrics, flow intelligence by cohort (Smart Money, whales, exchanges, public figures, top PnL traders, fresh wallets), inflow and outflow buckets over time, top buyers and sellers, DEX trades, top transfers, top holders and OHLCV price candles.
- **Wallet profiler**: current and historical token balances, transactions, counterparties, related wallets (funders, deployers, linked addresses), PnL summary with win rate, PnL per token, and Nansen's entity and behaviour labels, for one wallet or a whole Nansen entity such as an exchange or fund.
- **Address labels everywhere**: holders, traders, counterparties and transfer parties carry their Nansen label where one exists.
- **Pagination handled for you**: every page is read until the endpoint says it is the last one or the row cap is reached.
- **Pay only for results**: empty answers are recorded as a free row that says why, never charged.

### Input

| Field | Used by | What it does |
| --- | --- | --- |
| `mode` | all | One of 20 modes: `tokenScreener`, `tokenInformation`, `tokenFlowIntelligence`, `tokenFlows`, `tokenWhoBoughtSold`, `tokenDexTrades`, `tokenTransfers`, `tokenHolders`, `tokenOhlcv`, `walletBalances`, `walletHistoricalBalances`, `walletTransactions`, `walletCounterparties`, `walletRelatedWallets`, `walletPnlSummary`, `walletPnl`, `walletLabels`, `smartMoneyNetflow`, `smartMoneyHoldings`, `smartMoneyDexTrades` |
| `tokenAddresses` | token modes | Contract addresses on the chosen chain, one request each |
| `walletAddresses` | wallet modes | Wallet addresses, one request each |
| `entityNames` | balances, historical balances, counterparties, PnL | Nansen entity names such as Binance |
| `chain` | token and wallet modes | The chain the token or wallet lives on; `all` works for most wallet modes |
| `chains` | screener and Smart Money modes | One or more chains (screener: up to 5) |
| `screenerTimeframe`, `tokenTimeframe`, `candleInterval` | screener; token information and flow intelligence; candles | The window or candle resolution |
| `dateFrom`, `dateTo`, `lookbackDays` | flows, buyers and sellers, trades, transfers, candles, wallet history, transactions, counterparties, PnL | Date window, one year at most; default the last 7 days |
| `flowLabel`, `holderType`, `aggregateByEntity`, `tradeSide`, `counterpartySource`, `counterpartyGroupBy`, `onlySmartMoney`, `hideSpamTokens` | the endpoint named in each field | Documented endpoint options |
| `smartMoneyLabels`, `includeStablecoins`, `includeNativeTokens` | screener, holders, trades, counterparties, Smart Money | Label and token-type filters |
| `sortField`, `sortDirection` | most list modes | Sort by a documented column such as `value_usd` or `netflow` |
| `extraFilters` | most list modes | Any other documented Nansen filter, for example `{"value_usd": {"min": 10000}}` |
| `maxResults` | all | Row cap per run, default 200; it also sets the page size |
| `apiKey` | all | Your Nansen API key (secret) |

Only the inputs the chosen endpoint documents are sent. Anything else is left off with a warning, because the Nansen API answers an unknown filter with an empty result rather than an error.

Example: top Smart Money holders of USDC on Ethereum, biggest first.

```json
{
    "mode": "tokenHolders",
    "chain": "ethereum",
    "tokenAddresses": ["0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48"],
    "holderType": "smart_money",
    "sortField": "value_usd",
    "maxResults": 100,
    "apiKey": "YOUR_NANSEN_API_KEY"
}
```

### How to get an API key

Sign in at [app.nansen.ai/api](https://app.nansen.ai/api) and create an API key. The Free plan includes 100 trial credits and then 10 a day; Pro includes 2,000 a month and credits can be bought on top. Each request spends credits on your key: 1 for most token and wallet endpoints, 5 for holders, counterparties and the Smart Money endpoints, and 100 for wallet labels (0 when a wallet has none). Failed requests are not billed by Nansen.

### Example output

```json
{
    "mode": "tokenHolders",
    "modeLabel": "Token holders",
    "recordType": "wallet",
    "identifier": "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
    "found": true,
    "chain": "ethereum",
    "tokenAddress": "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
    "tokenSymbol": null,
    "walletAddress": null,
    "entityName": null,
    "address": "0x28c6c06298d514db089934071355e5743bf21d60",
    "addressLabel": "Binance 14",
    "timestamp": null,
    "valueUsd": 1250000000.5,
    "transactionHash": null,
    "note": null,
    "retrievedAt": "2026-10-10T12:00:00.000Z",
    "id": "0xa0b8...|3f1c2d9e8a7b6c5d4e3f",
    "token_amount": 1250000000.5,
    "total_outflow": 310000000,
    "total_inflow": 295000000,
    "balance_change_24h": -15000000,
    "balance_change_7d": 42000000,
    "balance_change_30d": 120000000,
    "ownership_percentage": 0.021
}
```

Every field Nansen returns is kept as is (snake_case), next to the common camelCase columns.

### FAQ

#### What is the Nansen API?

The Nansen API is the developer interface to Nansen, an on-chain analytics platform that labels hundreds of millions of blockchain addresses and tracks Smart Money, the wallets with the strongest trading record. It serves token analytics (Token God Mode), wallet profiles (Profiler), Smart Money aggregates, Hyperliquid perps and prediction market data over JSON POST endpoints.

#### Do I need my own API key?

Yes. This actor is bring-your-own-key: it calls Nansen with your key, so the data, the credit cost and the licence terms are those of your own Nansen account. Without a key the run ends cleanly with a message saying so.

#### How do I see what Smart Money is buying right now?

Use `smartMoneyNetflow` with the chains you care about. Each row is a token with its Smart Money net flow over 1 hour, 24 hours, 7 days and 30 days, trader count, sector, age and market cap. Sort by `net_flow_24h_usd` to rank by the last day. `smartMoneyDexTrades` lists the individual swaps from the last 24 hours.

#### How do I find the top holders or buyers of a token?

Use `tokenHolders` with a token address and a holder type (all holders, Smart Money, whales, exchanges or public figures), or `tokenWhoBoughtSold` with buyers or sellers over a date window. Both carry the Nansen label of each address.

#### How do I profile a wallet?

Use `walletBalances`, `walletTransactions`, `walletCounterparties`, `walletRelatedWallets`, `walletPnlSummary`, `walletPnl` and `walletLabels` with one or more wallet addresses. Balances, counterparties and PnL also take a Nansen entity name such as Binance, which reads every wallet attributed to that entity.

#### Which chains are supported?

Ethereum, Solana, Base, BNB Chain, Arbitrum, Optimism, Polygon, Avalanche, Linea, Mantle, Sonic, Sei, Monad, HyperEVM, TRON, TON, Sui, NEAR, Bitcoin, Starknet and more, depending on the endpoint. A chain the chosen endpoint does not support ends the run with the list it does.

#### What do I pay?

Two separate things. Nansen charges credits on your own key per request. This actor charges per row it returns: 0.005 USD per token market record, trade, transfer or transaction, 0.01 USD per wallet record (holder, buyer, balance, counterparty, PnL), 0.015 USD per Smart Money record and 0.02 USD per wallet label. Empty answers and refusals are never charged.

#### What happens if my key is wrong or out of credits?

The run ends cleanly, not as a failure, with the provider's reason in the status message: a rejected key, an empty credit balance, or an endpoint or option your plan does not include. A bad address or date for one target is recorded as a free row and the run moves on to the next target.

### Keyword map

Nansen API, Smart Money tracker data, crypto wallet analytics, on-chain wallet data, wallet PnL, wallet labels, token holders, whale tracking, token flows, exchange flows, DEX trades, token screener, blockchain analytics API, Ethereum and Solana wallet data, OHLCV.

### Terms and data use

Data comes from your own Nansen account under Nansen's Terms of Service and its Data Redistribution Guidelines (docs.nansen.ai/guides/redistribution-guide). In short:

- **Free to redistribute**: wallet balances, historical balances, wallet PnL and PnL summary.
- **Redistribute with attribution** ("Powered by Nansen API" or a link to nansen.ai): token transfers, DEX trades, who bought or sold, flows, flow intelligence, token screener, wallet transactions, counterparties and related wallets.
- **Restricted** (Nansen approval plus significant modification): Smart Money net flows, and token holders filtered to Smart Money.
- **Internal use only, never redistributed**: wallet labels, Smart Money holdings and Smart Money DEX trades.

Attribution is not required for personal or internal use. The actor itself only moves your own data into your own Apify storage; anything you publish or resell from it is your responsibility under those terms. Nansen also asks that its data is not used to build competing products. This actor is not affiliated with or endorsed by Nansen.

# Actor input Schema

## `mode` (type: `string`):

Token modes read one token at a time from Token addresses. Wallet modes read one wallet at a time from Wallet addresses (several also take Nansen entity names such as Binance). The token screener and the three Smart Money modes read one market-wide list. Each request spends Nansen credits on your key: 1 for most token and wallet endpoints, 5 for holders, counterparties and Smart Money, 100 for wallet labels.

## `tokenAddresses` (type: `array`):

Token modes. Contract addresses on the chosen chain, one per line, for example 0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48 (USDC on Ethereum) or a Solana mint address. Each address is one request.

## `walletAddresses` (type: `array`):

Wallet modes. Wallet addresses, one per line, as the chain writes them (EVM 0x addresses, Solana, Bitcoin, TRON and so on). Each address is one request.

## `entityNames` (type: `array`):

Wallet balances, historical balances, counterparties, PnL summary and PnL by token. Nansen entity names such as Binance or Wintermute, one per line, to read every wallet Nansen attributes to that entity at once.

## `chain` (type: `string`):

Token and wallet modes. The chain the token or wallet lives on. All chains works for wallet balances, transactions, counterparties, PnL and labels. Each endpoint supports its own list; an unsupported pick ends the run with the list it takes.

## `chains` (type: `array`):

Token screener and Smart Money modes. One or more chains to cover (the screener takes up to 5 per request). All chains is accepted by the Smart Money modes.

## `screenerTimeframe` (type: `string`):

Token screener. The window the volume, flow and trader counts cover. The screener is live only; it has no historical snapshots.

## `tokenTimeframe` (type: `string`):

Token information and token flow intelligence. The window the spot metrics and cohort flows cover.

## `candleInterval` (type: `string`):

Token price candles. The OHLCV resolution.

## `dateFrom` (type: `string`):

Token flows, who bought or sold, DEX trades, transfers, candles and the wallet history, transaction, counterparty and PnL modes. Start of the window: a date such as 2026-09-01 or a UTC time such as 2026-09-01T00:00:00Z. Leave empty to read the last lookback days. The window may span one year at most.

## `dateTo` (type: `string`):

End of the window, in the same forms as Date from. Leave empty for now.

## `lookbackDays` (type: `integer`):

How many days back to read when Date from is empty.

## `flowLabel` (type: `string`):

Token flows. Which wallet cohort the inflow and outflow buckets track.

## `holderType` (type: `string`):

Token holders. Which holders to list.

## `aggregateByEntity` (type: `boolean`):

Token holders. Sum the wallets Nansen attributes to one entity (an exchange, a fund) into one row.

## `tradeSide` (type: `string`):

Who bought or sold a token. Whether to list the top buyers or the top sellers.

## `counterpartySource` (type: `string`):

Wallet counterparties. Which transfers count as interactions.

## `counterpartyGroupBy` (type: `string`):

Wallet counterparties. One row per counterparty wallet or per counterparty entity.

## `onlySmartMoney` (type: `boolean`):

Token DEX trades and token transfers. Keep only trades or transfers made by Smart Money wallets.

## `hideSpamTokens` (type: `boolean`):

Wallet balances, historical balances and transactions. Leave out tokens Nansen flags as suspicious.

## `smartMoneyLabels` (type: `array`):

Token screener, holders, who bought or sold, DEX trades, counterparties and the Smart Money modes. Keep only wallets with these labels. The screener and Smart Money modes take Fund, Smart Trader, 30D, 90D and 180D Smart Trader and Smart HL Perps Trader; other labels are left off there with a note.

## `includeStablecoins` (type: `boolean`):

Token screener, Smart Money net flows and holdings. Leave unticked to keep the endpoint default (the screener includes stablecoins, the Smart Money modes leave them out).

## `includeNativeTokens` (type: `boolean`):

Token screener, Smart Money net flows and holdings. Include ETH, SOL and other native, wrapped-native and staking tokens.

## `sortField` (type: `string`):

Optional. A column of the chosen endpoint to sort by, such as value_usd, volume, netflow, net_flow_24h_usd, block_timestamp or trade_value_usd. A field the endpoint does not sort by ends the run with the list it takes.

## `sortDirection` (type: `string`):

Used with Sort by.

## `extraFilters` (type: `object`):

Advanced. Nansen filters passed through verbatim, for example {"value_usd": {"min": 10000}}, {"market_cap_usd": {"min": 1000000}} or {"trader_address_label": "Wintermute"}. Range filters take min and max. Only the filter names the chosen endpoint documents are sent; any other is left off with a warning, because an unknown filter returns nothing rather than an error.

## `maxResults` (type: `integer`):

The most rows this run returns and charges for, across all targets and pages. It also sets the page size, so a small value keeps credit use low.

## `requestsPerMinute` (type: `integer`):

Pacing. Nansen allows 300 requests a minute on the Free plan and 1,500 on Pro, and answers 429 above it, which the actor waits out and retries.

## `apiKey` (type: `string`):

Your own Nansen API key, from app.nansen.ai/api. Stored as a secret and sent only in the apikey header; it is never logged. You can instead set the DATA_API_KEY environment secret.

## Actor input object example

```json
{
  "mode": "tokenScreener",
  "chain": "ethereum",
  "chains": [
    "ethereum"
  ],
  "screenerTimeframe": "24h",
  "tokenTimeframe": "1d",
  "candleInterval": "1d",
  "lookbackDays": 7,
  "flowLabel": "smart_money",
  "holderType": "all_holders",
  "aggregateByEntity": false,
  "tradeSide": "BUY",
  "counterpartySource": "Combined",
  "counterpartyGroupBy": "wallet",
  "onlySmartMoney": false,
  "hideSpamTokens": true,
  "sortDirection": "DESC",
  "maxResults": 200,
  "requestsPerMinute": 60
}
```

# Actor output Schema

## `records` (type: `string`):

One row per token, wallet, trade, transfer, candle, label or Smart Money record.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {};

// Run the Actor and wait for it to finish
const run = await client.actor("nabeelbaghoor/crypto-wallet-smart-money-api").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {}

# Run the Actor and wait for it to finish
run = client.actor("nabeelbaghoor/crypto-wallet-smart-money-api").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{}' |
apify call nabeelbaghoor/crypto-wallet-smart-money-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,nabeelbaghoor/crypto-wallet-smart-money-api"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/aUue9aEngk4VPc7XB/builds/dky3D4gLhRg4d8SQI/openapi.json