# Crypto Wallet Tracker API - Arkham Entity Labels and Transfers (`nabeelbaghoor/crypto-wallet-tracker-entity-labels-api`) Actor

Arkham Intel API in a dataset: who owns a crypto wallet (entity labels for exchanges, funds, whales), entity profiles, search, labelled transfers, counterparties, token balances and daily USD fund flows on Ethereum, Bitcoin, Solana, Tron, Base and more. Bring your own key.

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

## Pricing

from $10.00 / 1,000 label, entity or search result 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 Tracker API - Arkham Entity Labels and Transfers

Find out who owns a crypto wallet and follow the money: Arkham Intel API entity labels, labelled transfers, counterparties, token balances and daily USD fund flows, straight into an Apify dataset. Bring your own API key.

BYOK, not live-tested: every route, parameter and response field here comes from Arkham's published API reference, and the key handling was probed against the live host with invalid keys, but no run has used a real Arkham key yet.

### What it does

- **Address labels (wallet owner lookup)**: the Arkham entity behind an address (Binance, Coinbase, Wintermute, Jump Trading, BlackRock, a named whale), its type (cex, fund, market maker, individual) and the address label (Hot Wallet, Cold Wallet, Deposit), on one chain or on every chain at once.
- **Entity profiles**: entity type, website, Twitter, LinkedIn, Crunchbase and Arkham tags such as Proof of Reserves.
- **Search**: find the Arkham entity ID, labelled addresses, exchange entities, tokens and ENS names for any name.
- **Transfers**: enriched on-chain transfers with sender and receiver attributed, token, amount, historical USD value and transaction hash. Filter by entity, address, entity type (type:cex, type:fund), deposit addresses (deposit:binance), token, direction, USD value and time; sort by time, amount or USD.
- **Counterparties**: who an address or entity sends to and receives from, ranked by USD volume, with transaction counts.
- **Token balances**: every token an address or entity holds per chain, with price, 24h change and USD value.
- **Fund flow**: daily USD inflow, outflow, net flow and cumulative totals per chain for an address or entity, such as exchange inflows and outflows.
- Covers Ethereum, Bitcoin, Solana, Tron, BNB Smart Chain, Base, Arbitrum, Polygon, Optimism, Avalanche, Dogecoin, Zcash, HyperEVM, HyperCore and more.
- Read only: every call is a GET, so nothing in your Arkham account changes. Unlabelled addresses and empty lookups are free rows, never charged.

### How to get an API key

Arkham API plans are custom and start at 100 USD a month; request access (or a trial) with the form at arkm.com/api. Once access is granted, create a key in the API Keys tab of arkm.com/api-dashboard and paste it into the API key field, or set the `DATA_API_KEY` environment secret.

### Input

| Field | Type | Used by | Description |
| --- | --- | --- | --- |
| `mode` | select | all | addressLabels, addressLabelsAllChains, entityProfile, search, transfers, addressCounterparties, entityCounterparties, addressBalances, entityBalances, addressFlow, entityFlow |
| `addresses` | list | address modes | Blockchain addresses, one per line |
| `entities` | list | entity modes | Arkham entity IDs such as binance or wintermute |
| `searchQueries` | list | search | Names, addresses, ENS names or tokens |
| `searchLimit` | integer | search | Results per category, 1 to 50 (default 10) |
| `chains` | multi-select | most modes | Limit to these chains; empty means every chain |
| `baseFilter` | list | transfers | Entities, addresses or filter forms on either side |
| `fromFilter` / `toFilter` | list | transfers | Sender or receiver filters (type:cex, deposit:binance, service:all, !binance) |
| `tokens` | list | transfers, counterparties | Token IDs (tether, usd-coin) or contract addresses |
| `direction` | select | transfers, counterparties | all, in, out, self |
| `timeWindow` | select | transfers, counterparties | any, 1h, 24h, 7d, 30d, 1M, 1y |
| `timeFrom` / `timeTo` | text | transfers, counterparties | Date, RFC 3339 time or Unix timestamp |
| `usdMin` / `usdMax` | number | transfers (usdMin also counterparties) | USD value bounds |
| `sortBy` / `sortDirection` | select | transfers | time, value or usd; desc or asc |
| `counterpartyTags` | list | counterparties | Arkham tags such as whale or kol |
| `cheapBalances` | boolean | entityBalances | Faster balances, up to 24 hours behind |
| `maxResults` | integer | all | Row cap per run (default 100, max 10,000) |
| `requestsPerMinute` | integer | all | Pacing; heavy endpoints are always held to 1 a second |
| `apiKey` | secret | all | Your Arkham Intel API key |

Example: every USDT transfer over 1 million USD into exchanges in the last 24 hours.

```json
{
    "mode": "transfers",
    "toFilter": ["type:cex"],
    "tokens": ["tether"],
    "usdMin": 1000000,
    "timeWindow": "24h",
    "maxResults": 200
}
```

### Example output

Address labels for `0x28C6c06298d514Db089934071355E5743bf21d60`:

```json
{
    "mode": "addressLabels",
    "modeLabel": "Address labels",
    "recordType": "addressLabel",
    "identifier": "0x28C6c06298d514Db089934071355E5743bf21d60",
    "found": true,
    "chain": "ethereum",
    "address": "0x28C6c06298d514Db089934071355E5743bf21d60",
    "entityId": "binance",
    "entityName": "Binance",
    "entityType": "cex",
    "label": "Hot Wallet",
    "tokenSymbol": null,
    "valueUsd": null,
    "timestamp": null,
    "transactionHash": null,
    "retrievedAt": "2026-10-12T09:00:00.000Z",
    "note": null,
    "arkhamEntity": { "id": "binance", "name": "Binance", "type": "cex", "website": "https://binance.com", "twitter": "https://twitter.com/binance" },
    "arkhamLabel": { "address": "0x28C6c06298d514Db089934071355E5743bf21d60", "chainType": "evm", "name": "Hot Wallet" },
    "contract": false,
    "isUserAddress": false,
    "depositServiceId": null,
    "predictedEntity": false
}
```

A transfer row adds `fromAddressHash`, `fromEntityName`, `fromLabel`, `toAddressHash`, `toEntityName`, `toLabel`, `tokenSymbol`, `unitValue`, `valueUsd` (historical USD) and `transactionHash`, plus the full `fromAddress` and `toAddress` objects.

### FAQ

#### What is the Arkham Intel API?

It is the programmatic side of Arkham Intelligence, the blockchain analytics platform that attributes wallets to real-world entities such as exchanges (Binance, Coinbase, Kraken), funds (BlackRock, Grayscale), market makers (Wintermute, Jump Trading), governments and individuals. The API returns those labels plus transfers, balances, counterparties and flows.

#### How do I find out who owns a crypto wallet address?

Use the address labels mode with the address. The row gives the Arkham entity name and type (for example Binance, cex) and the address label (for example Hot Wallet or Binance Deposit). The all chains mode checks the same address on every EVM chain at once. Addresses Arkham has not attributed come back as free rows with found set to false.

#### How do I track exchange inflows and outflows?

Use the entity fund flow mode with an exchange ID such as binance or coinbase. Each row is one day on one chain with USD inflow, outflow, net flow and cumulative totals. For individual movements, use transfers with `toFilter` set to `type:cex` (deposits to any exchange) or to an entity ID.

#### How do I follow whale and fund transfers?

Use the transfers mode with `baseFilter` set to an entity ID (for example jump-trading or wintermute) or an address, add `usdMin` for large transfers only, and choose a time window. Both sides of each transfer carry Arkham's entity and label.

#### Where do I get an entity ID?

Run the search mode with the name, for example Jump Trading. The arkhamEntities and services hits carry the `entityId` to use in the entities input and in transfer filters. IDs are lower case.

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

Yes. This actor sends your own Arkham Intel API key in the API-Key header and never stores it in the dataset or logs. Arkham API plans are usage-based and start at 100 USD a month; trials are available through arkm.com/api.

#### What do I pay?

Pay per result on Apify: 0.01 USD per attributed address, entity profile or search hit; 0.008 USD per transfer or counterparty; 0.005 USD per token balance or daily flow point. Unlabelled addresses, empty lookups and refusals are never charged. Your Arkham credits are used separately (for example 2 credits per transfer row and 50 per counterparty call), and `maxResults` caps both.

#### What happens if my key is wrong or my plan does not cover an endpoint?

A rejected key (HTTP 401), an endpoint or filter outside your plan, or a reached credit cap (HTTP 402 or 403) ends the run cleanly with a status message that says what to change. Rate limits (HTTP 429) are waited out and retried. An address or entity the API refuses (HTTP 400 or 404) becomes a free row with the API's own words, and the run moves on.

#### Why do transfer filters return 403?

Arkham grants transfer access by capability. Without transfers.filter, only the default feed and a single address or entity as base are allowed; custom sorting, from and to filters, or token filters need the full capability. Ask Arkham to add it to your plan.

### Pricing

| Event | Price | Charged for |
| --- | --- | --- |
| `intelligence-record` | 0.01 USD | Each attributed address, entity profile or search hit |
| `activity-record` | 0.008 USD | Each transfer or counterparty |
| `balance-record` | 0.005 USD | Each token balance or daily fund flow point |

### Keyword map

crypto wallet tracker, who owns this wallet, wallet owner lookup, blockchain address labels API, crypto entity labels, wallet attribution API, Arkham API, Arkham Intelligence API, on-chain intelligence, whale tracker, exchange inflows and outflows, exchange wallet tracker, fund flow tracker, crypto transfers API, labelled transactions, counterparty analysis, token balances by entity, Ethereum, Bitcoin, Solana, Tron, Base, Arbitrum.

### Terms and data use

Use of the Arkham Intel API is governed by your Arkham API plan and the Arkham Intelligence Terms of Service, which forbid copying, selling or distributing the service content except as Arkham expressly authorises. Keep the datasets for your own use and check your API agreement before sharing or redistributing them. Arkham describes its attribution as confidence-scored investigative intelligence, not standalone evidence. This actor is not affiliated with or endorsed by Arkham Intelligence.

# Actor input Schema

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

Address labels says who controls a wallet: the Arkham entity (exchange, fund, market maker, person) and the address label, on one chain or every chain. Entity profile reads an entity's type, links and tags. Search finds entity IDs, labelled addresses, tokens and ENS names for a name. Transfers reads enriched transfers with both sides labelled, filtered by entity, address, token, value and time. Counterparties lists who an address or entity sends to and receives from, by USD volume. Balances lists token holdings with USD value. Fund flow gives daily USD inflow, outflow and cumulative totals per chain.

## `addresses` (type: `array`):

Blockchain addresses for the address modes: EVM, Bitcoin, Solana, Tron and the other supported chains. One per line; each is its own lookup.

## `entities` (type: `array`):

Arkham entity IDs for the entity modes, such as binance, coinbase, wintermute, jump-trading or vitalik-buterin. IDs are lower case; the search mode finds the ID for a name. One per line.

## `searchQueries` (type: `array`):

Search mode only. Names, addresses, ENS names or tokens to search for, one per line.

## `searchLimit` (type: `integer`):

Search mode only. How many entities, labelled addresses, exchange entities, tokens and ENS names to return for each query (the API allows up to 50 per category).

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

Limit transfers, counterparties, balances and fund flow to these chains. Leave empty for every supported chain. Address labels uses the first chain only (empty auto-detects the best chain).

## `baseFilter` (type: `array`):

Transfers only. Entities or addresses on either side, or filter forms such as type:cex, deposit:binance, prefix:0x28c6 or contract:true. Prefix with ! to exclude (type:cex and !binance is every exchange except Binance).

## `fromFilter` (type: `array`):

Transfers only. Sending entities or addresses, or forms such as type:fund, deposit:coinbase or service:all. Prefix with ! to exclude.

## `toFilter` (type: `array`):

Transfers only. Receiving entities or addresses, or forms such as type:cex, deposit:binance or service:binance. Prefix with ! to exclude.

## `tokens` (type: `array`):

Transfers and counterparties. Token IDs (CoinGecko pricing IDs such as tether, usd-coin, ethereum, bitcoin) or token contract addresses. Ticker symbols such as USDT match nothing. Prefix with ! to exclude.

## `direction` (type: `string`):

Transfers and counterparties. Incoming or outgoing relative to the filtered entity or address. Counterparties accept incoming or outgoing only.

## `timeWindow` (type: `string`):

Transfers and counterparties. A relative window ending now. Use either this or the dates below, not both.

## `timeFrom` (type: `string`):

Transfers and counterparties. Start of the range: a date (2026-01-31), an RFC 3339 time (2026-01-31T12:00:00Z) or a Unix timestamp. UTC.

## `timeTo` (type: `string`):

Transfers and counterparties. End of the range, in the same formats as time from.

## `usdMin` (type: `number`):

Transfers: minimum historical USD value per transfer. Counterparties: minimum aggregated USD volume per counterparty.

## `usdMax` (type: `number`):

Transfers only. Maximum historical USD value per transfer.

## `sortBy` (type: `string`):

Transfers only. Custom sorting needs the transfers.filter capability on your Arkham plan.

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

Transfers only.

## `counterpartyTags` (type: `array`):

Counterparties only. Keep counterparties carrying these Arkham tags, such as whale or kol.

## `cheapBalances` (type: `boolean`):

Entity balances only. Uses Arkham's faster balance query, which can be up to 24 hours behind.

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

The most rows this run returns and charges for, across all lookups. Arkham bills transfers per row (2 credits each), so this also caps your Arkham credit spend.

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

Pacing. Heavy endpoints (transfers, search, flow, counterparties) are always spaced at least 1.1 seconds apart, as Arkham allows 1 request a second on them; a 429 is waited out and retried.

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

Your own Arkham Intel API key, from the API Keys tab of your Arkham API dashboard (arkm.com/api-dashboard). Stored as a secret and sent only in the API-Key header; it is never logged. You can instead set the DATA_API_KEY environment secret.

## Actor input object example

```json
{
  "mode": "addressLabels",
  "addresses": [
    "0x28C6c06298d514Db089934071355E5743bf21d60"
  ],
  "searchLimit": 10,
  "direction": "all",
  "timeWindow": "any",
  "sortBy": "time",
  "sortDirection": "desc",
  "cheapBalances": false,
  "maxResults": 100,
  "requestsPerMinute": 120
}
```

# Actor output Schema

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

One row per address label, entity, search hit, transfer, counterparty, balance or flow point.

# 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 = {
    "addresses": [
        "0x28C6c06298d514Db089934071355E5743bf21d60"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("nabeelbaghoor/crypto-wallet-tracker-entity-labels-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 = { "addresses": ["0x28C6c06298d514Db089934071355E5743bf21d60"] }

# Run the Actor and wait for it to finish
run = client.actor("nabeelbaghoor/crypto-wallet-tracker-entity-labels-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 '{
  "addresses": [
    "0x28C6c06298d514Db089934071355E5743bf21d60"
  ]
}' |
apify call nabeelbaghoor/crypto-wallet-tracker-entity-labels-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,nabeelbaghoor/crypto-wallet-tracker-entity-labels-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/vh9P7FWMwW9D3gFI4/builds/dm5oQVySSaFdrTlc3/openapi.json