Whale Alert API vs Free Whale Data APIs: Pricing, Limits & Alternatives (2026)

What kind of whale data do these APIs actually return?

The single most important distinction in whale data APIs is rarely stated on pricing pages: the difference between transfer data and trade data. This distinction determines whether the API tells you that cryptocurrency moved between addresses or that a whale bought or sold a specific token on a decentralized exchange. Most developers discover this gap after they have already committed to a plan.

Transfer APIs report when large amounts of cryptocurrency move from one address to another. Whale Alert is the canonical example. When a wallet sends 1,000 ETH to a Coinbase deposit address, Whale Alert fires an alert with the amount, sender, receiver, and USD value. What it does not tell you: whether that transfer was preceded by a DEX swap, whether the wallet is accumulating or distributing, or what token the whale is actually interested in. Transfer data answers "something moved" but not "which direction is the trade."

Trade APIs decode smart contract interactions on decentralized exchanges. When a whale swaps 500 ETH for LINK on Uniswap V3, a trade-level API classifies that as a LINK buy and an ETH sell, computes the USD value, and attributes it to a specific wallet. Deep Blue Alpha's public API endpoints and Nansen's API operate in this category. Trade data answers "what are whales buying and selling" rather than just "something moved."

Raw blockchain APIs return unprocessed transaction data. Etherscan's API provides the raw inputs, outputs, and contract calls for any transaction. The data contains everything needed to reconstruct both transfers and trades, but the burden of classification, labeling, and interpretation falls entirely on the developer. This is the most flexible and the most labor-intensive option.

Whale Alert API: every tier, every limit

Whale Alert operates two separate API products as of July 2026. Both require a dedicated developer account (separate from the whale-alert.io dashboard subscription) and are billed independently.

Alerts API — $29.95/month

The Alerts API provides a WebSocket connection that streams transfer alerts in real time. Key specifications:

• Rate limit: Maximum 2 concurrent WebSocket connections per API key
• Alert cap: Up to 100 alerts received per hour
• Minimum transaction threshold: $100,000 USD — transfers below this value are not reported
• Blockchain coverage: 13 blockchains, 100+ assets
• Use restriction: Personal use only
• Trial: 7-day free trial available

Enterprise API — $699/month

The Enterprise API provides a REST endpoint for programmatic access to transaction data. Key specifications:

• Rate limit: 1,000 requests per minute
• Historical data: 30-day transaction history
• Alert cap: Up to 500 alerts per hour (includes the Alerts API)
• Pricing data: Included with transaction responses
• Blockchain coverage: 13 blockchains, 100+ assets
• Commercial use: Permitted
• Support: Email and Telegram

What Whale Alert does not offer

There is no free API tier. The free whale-alert.io dashboard shows recent BTC and USDT alerts with limited analytics, but no programmatic access is available without a paid subscription. There is no mid-range option between $29.95 and $699 — the jump from WebSocket alerts to REST API access is a 23x price increase. Historical data is capped at 30 days even on Enterprise; there is no way to query transaction data older than one month through the API.

Free whale data APIs: what exists and what each one returns

Four platforms offer genuinely free API access to whale-relevant data as of July 2026. The word "free" requires scrutiny — free tiers vary from fully open public endpoints to rate-limited access behind an API key registration. Here is what each one actually delivers.

Deep Blue Alpha — 2 free public endpoints, no auth required

Deep Blue Alpha provides two public API endpoints that require no authentication, no API key, and no signup. Both are CORS-enabled for browser-side applications and cached with 60-second TTL.

These endpoints return Ethereum-specific whale intelligence — aggregate buy/sell volume, tracked wallet universe size, and a computed sentiment index that synthesizes directional whale behavior into a single daily score with 30 days of historical context. The data is derived from the same pipeline that powers the live whale feed on deepbluealpha.io.

What the /api/v1/public/stats endpoint returns

The stats endpoint provides a structured JSON payload with product metadata and live whale tracking statistics. The response includes the total number of tracked wallets, how many distinct tokens those wallets have traded, the cumulative transaction count, and a window_24h object with buy volume, sell volume, and distinct buyer count for the rolling 24-hour window. The as_of_utc timestamp confirms when the data was computed.

The notes field in the response is worth reading. It documents the volume methodology: buy_volume_usd and sell_volume_usd sum all directional transactions (BUY, SWAP_BUY, DEX_BUY and SELL, SWAP_SELL, DEX_SELL) including stablecoins and wrapped assets. The dashboard on deepbluealpha.io displays lower figures because it filters high-volume non-signal tokens and uses sentiment-based classification rather than raw direction. This means the API returns raw aggregate numbers, while the dashboard applies additional intelligence layers on top. The license field confirms CC-BY-4.0 with attribution.

What the /api/v1/public/whale-index endpoint returns

The whale-index endpoint returns the Whale Sentiment Index — a daily composite score from 0 to 100 that synthesizes whale buying and selling pressure into a single readable signal. The payload includes the numeric score, a human-readable label (ranging from "Extreme Fear" through "Neutral" to "Extreme Greed"), a color hex code for UI rendering, and component breakdowns: trade_sentiment and volume_sentiment as separate float scores. It also reports total_trades, total_volume_usd, and active_wallets for the current scoring window.

The history array contains up to 30 entries, each with a date (YYYY-MM-DD) and an integer score. This enables rendering a 30-day sparkline or trend chart directly from a single API call. A stale boolean flag indicates whether the score is from a live window or from the most recent stored day — if the block listener has a processing lag, the API surfaces this honestly rather than fabricating a current reading.

Full programmatic API access (individual wallet queries, token-level flow breakdowns, historical transaction data) is planned for the Leviathan tier ($99/month) but is not yet available. The two public endpoints are the current free API surface.

Etherscan — free API key with 3 calls/second

Etherscan provides a free API tier that requires registering for an API key (free, instant). As of July 2026, the free tier allows 3 calls per second and 100,000 calls per day. Recent changes reduced the maximum records per request from 10,000 to 1,000 and removed the Internal Transactions by Block Range endpoint from the free plan.

What Etherscan's API returns is raw blockchain data: transaction details, token transfers, contract interactions, event logs, and account balances. It does not classify transactions as whale activity, does not label wallets, and does not provide buy/sell sentiment. Building a whale tracker on top of Etherscan's API requires writing custom classification logic, maintaining an exchange address database, and computing USD values from DEX pool states at the time of each transaction.

Paid tiers: Lite at $49/month (5 calls/sec), Standard at $199/month (10 calls/sec, 200K daily calls). Etherscan V2 charges per account rather than per chain, so multi-chain queries do not multiply the cost.

Arkham Intelligence — free API with rate limits

Arkham Intelligence provides API access on its free tier. Standard endpoints allow 20 requests per second. Heavy endpoints — including /transfers, /swaps, /counterparties, and /token/top_flow — are restricted to 1 request per second. A free account registration is required.

Arkham's API returns entity-level intelligence: wallet-to-entity attribution, portfolio compositions, counterparty analysis, and transfer histories with entity labels attached. This is the strongest free API for answering "who owns this wallet?" but it does not provide aggregate buy/sell sentiment or conviction scoring on trades.

CoinGecko — free market data API

CoinGecko offers a free crypto market data API that is widely used as a supplementary data source for whale tracking applications. The free tier provides price data, market cap, volume, and basic token information. It does not provide whale-specific intelligence (wallet tracking, flow data, or sentiment), but it is the standard source for enriching whale transaction data with current token prices and market context.

Code examples: making your first API calls

Every free whale data API can be tested from a terminal in under 60 seconds. The following curl commands are copy-paste ready — no API keys, no SDKs, no account setup required for the first two.

Deep Blue Alpha — whale stats (no auth)

# Get live whale tracking statistics — no API key needed
curl -s https://deepbluealpha.io/api/v1/public/stats | python3 -m json.tool

This returns a response with the following structure:

{
    "product": "Deep Blue Alpha",
    "description": "Real-time Ethereum whale intelligence...",
    "homepage": "https://deepbluealpha.io",
    "version": 1,
    "as_of_utc": "2026-07-09T14:23:41.892000+00:00",
    "data": {
        "tracked_wallets": 4872,
        "tracked_tokens": 1643,
        "transactions_total": 1893241,
        "latest_transaction_utc": "2026-07-09T14:22:18",
        "window_24h": {
            "buy_volume_usd": 187432891,
            "sell_volume_usd": 164219304,
            "distinct_buyers": 412
        }
    },
    "notes": "Observational on-chain data. Not financial advice...",
    "license": "CC-BY-4.0 (attribution: Deep Blue Alpha, deepbluealpha.io)",
    "rate_limit": "No formal rate limit. Responses are cached for 60s..."
}

Key fields for integration: data.tracked_wallets is the current whale universe size. data.window_24h.buy_volume_usd and sell_volume_usd are the aggregate directional volumes. data.window_24h.distinct_buyers tells you how many unique wallets were on the buy side. All values are integers (USD rounded to whole dollars). The as_of_utc timestamp confirms freshness.

Deep Blue Alpha — Whale Sentiment Index (no auth)

# Get the Whale Sentiment Index with 30-day history
curl -s https://deepbluealpha.io/api/v1/public/whale-index | python3 -m json.tool

Response structure:

{
    "name": "Whale Sentiment Index",
    "date": "2026-07-09",
    "score": 62,
    "label": "Greed",
    "color": "#00e676",
    "stale": false,
    "trade_sentiment": 0.64,
    "volume_sentiment": 0.58,
    "total_trades": 847,
    "total_volume_usd": 351652195,
    "active_wallets": 623,
    "history": [
        {"date": "2026-06-09", "score": 45},
        {"date": "2026-06-10", "score": 51},
        {"date": "2026-06-11", "score": 48},
        ...
        {"date": "2026-07-09", "score": 62}
    ],
    "updated_at": "2026-07-09T14:23:42+00:00",
    "source": "https://deepbluealpha.io/whale-index"
}

The score ranges from 0 (Extreme Fear — heavy whale selling) to 100 (Extreme Greed — heavy whale buying). The label and color fields map scores to human-readable bands and hex colors for direct use in UI components. The trade_sentiment and volume_sentiment are the two component signals (floats between 0 and 1) that combine into the composite score. The history array provides the raw data for a 30-day sparkline without any additional API calls.

Etherscan — token transfers for a wallet (free API key required)

# Get ERC-20 token transfers for a specific wallet
# Replace YOUR_API_KEY with your free Etherscan API key
curl -s "https://api.etherscan.io/v2/api\
?chainid=1\
&module=account\
&action=tokentx\
&address=0xAb5801a7D398351b8bE11C439e05C5B3259aeC9B\
&page=1\
&offset=10\
&sort=desc\
&apikey=YOUR_API_KEY" | python3 -m json.tool

Etherscan V2 response structure:

{
    "status": "1",
    "message": "OK",
    "result": [
        {
            "blockNumber": "20483192",
            "timeStamp": "1720534847",
            "hash": "0x9f3e...",
            "from": "0xab5801a7d398351b8be11c439e05c5b3259aec9b",
            "to": "0x7a250d5630b4cf539739df2c5dacb4c659f2488d",
            "value": "1500000000000000000000",
            "tokenName": "ChainLink Token",
            "tokenSymbol": "LINK",
            "tokenDecimal": "18",
            "contractAddress": "0x514910771af9ca656af840dff83e8264ecf986ca",
            "gas": "300000",
            "gasUsed": "187234"
        }
    ]
}

Note what Etherscan returns and what it omits. The response includes the raw token transfer details: amount in wei (requires division by 10^tokenDecimal), sender, receiver, and the contract address. It does not include: USD value at the time of transfer, whether this was a buy or sell, what DEX was used, the counterparty token in a swap, or any label for who owns the wallet. Converting this raw data into whale intelligence requires: (1) maintaining a table of known exchange deposit addresses, (2) fetching historical token prices for USD conversion, (3) decoding the transaction input data to determine if this was a DEX swap, and (4) building classification logic for buy vs sell direction. This is the work that pre-processed APIs like Whale Alert and Deep Blue Alpha handle upstream.

CoinGecko — token price data (no auth for demo tier)

# Get current price data for a token by contract address
curl -s "https://api.coingecko.com/api/v3/simple/token_price/ethereum\
?contract_addresses=0x514910771af9ca656af840dff83e8264ecf986ca\
&vs_currencies=usd\
&include_24hr_vol=true\
&include_24hr_change=true\
&include_market_cap=true" | python3 -m json.tool

CoinGecko response:

{
    "0x514910771af9ca656af840dff83e8264ecf986ca": {
        "usd": 18.42,
        "usd_market_cap": 11483291647,
        "usd_24h_vol": 892341567,
        "usd_24h_change": 3.21
    }
}

CoinGecko is the standard enrichment layer for whale tracking pipelines. When Etherscan returns a raw LINK transfer of 1500000000000000000000 wei, CoinGecko provides the price to compute 1500 LINK * $18.42 = $27,630 USD. The free tier (Demo plan) allows 30 calls per minute with no API key. The Pro plan ($129/month for individuals) increases this to 500 calls per minute. For whale tracking bots that need to price every transaction in real time, the free tier's 30 calls/minute is the first bottleneck — batch price lookups or cache aggressively.

Combining two free APIs in a script

A minimal whale sentiment dashboard can be built with two API calls and zero authentication:

#!/bin/bash
# Minimal whale dashboard — $0/month, no API keys
echo "=== WHALE INTELLIGENCE ==="
echo ""
echo "--- Live Stats ---"
curl -s https://deepbluealpha.io/api/v1/public/stats \
  | python3 -c "
import sys, json
d = json.load(sys.stdin)['data']
w = d['window_24h']
print(f\"Tracked wallets:  {d['tracked_wallets']:,}\")
print(f\"24h buy volume:   \${w['buy_volume_usd']:,.0f}\")
print(f\"24h sell volume:  \${w['sell_volume_usd']:,.0f}\")
print(f\"24h net flow:     \${w['buy_volume_usd'] - w['sell_volume_usd']:+,.0f}\")
print(f\"Distinct buyers:  {w['distinct_buyers']}\")
"
echo ""
echo "--- Whale Sentiment Index ---"
curl -s https://deepbluealpha.io/api/v1/public/whale-index \
  | python3 -c "
import sys, json
d = json.load(sys.stdin)
print(f\"Score: {d['score']}/100 ({d['label']})\")
print(f\"Trade sentiment:  {d['trade_sentiment']:.2f}\")
print(f\"Volume sentiment: {d['volume_sentiment']:.2f}\")
print(f\"Active wallets:   {d['active_wallets']}\")
print(f\"30-day range:     {min(h['score'] for h in d['history'])} - {max(h['score'] for h in d['history'])}\")
"

This produces a terminal readout of whale activity with zero cost, zero setup, and zero vendor lock-in. The data refreshes every 60 seconds. For a browser-based version, both endpoints support CORS, so the same calls work from client-side JavaScript without a proxy server.

Response format comparison: what the JSON actually looks like

Pricing pages advertise features. JSON response shapes reveal what you actually get. The structure of the API response determines how much parsing logic a developer needs to write, whether the data is integration-ready or requires transformation, and what information is genuinely present versus implied by marketing copy.

Three patterns stand out in the response format comparison. First, Etherscan is the only major whale-adjacent API that returns token amounts as raw wei strings rather than human-readable floats — every integration needs a decimal conversion step (value / 10^tokenDecimal). Second, Etherscan wraps all responses in a status/message/result envelope where errors return HTTP 200 with "status": "0" rather than a 4xx/5xx status code — error handling must check the JSON body, not just the HTTP status. Third, Deep Blue Alpha and Arkham return ISO 8601 timestamps while Etherscan and Whale Alert use Unix epochs, which affects how date-range queries are constructed.

For developers building a multi-API integration, the timestamp and value format differences are the primary sources of integration bugs. A normalization layer that converts all timestamps to ISO 8601 and all token amounts to human-readable floats at the ingestion boundary prevents these mismatches from propagating through application logic.

Rate limit reality: what happens when you hit the wall

Rate limit documentation tells you the ceiling. What actually happens when you reach it — the error response, the cooldown behavior, and the consequences for your application — is rarely documented. This section covers the observed behavior for each API as of July 2026.

Deep Blue Alpha — cached, not throttled

The public endpoints use a different rate-limiting architecture than per-request throttling. Responses are cached for 60 seconds server-side. Calling the endpoint 100 times per second returns the same cached JSON 100 times — there is no 429 error, no backoff, no blocked request. The rate limit documentation states: "No formal rate limit. Responses are cached for 60s server-side. Abuse may trigger IP throttling." In practice, this means the API is effectively uncapped for reasonable usage but returns stale data within each 60-second window. For dashboard and widget use cases, this is ideal. For applications that need sub-minute data freshness, the 60-second floor is the constraint.

Etherscan — silent rate limiting with 200 responses

Etherscan's free tier enforces 3 calls per second. When the limit is exceeded, Etherscan does not return a 429 status code. Instead, it returns HTTP 200 with a JSON body containing "status": "0" and "message": "NOTOK" with a "result" string that reads "Max rate limit reached." This silent failure is the single most common source of bugs in Etherscan integrations: standard HTTP client retry logic (which checks for 4xx/5xx status codes) does not catch the error. Applications must parse the JSON status field on every response, not just the HTTP status.

The daily cap of 100,000 calls is enforced separately. Exceeding it returns the same "status": "0" pattern but with a message indicating the daily limit. There is no sliding window or gradual degradation — once the daily cap is hit, all calls return errors until the counter resets at midnight UTC.

Whale Alert — HTTP 429 with Retry-After

The Whale Alert Enterprise API returns a standard HTTP 429 (Too Many Requests) when the 1,000 requests/minute limit is exceeded. The Retry-After header indicates how many seconds to wait before the next request. On the Alerts API (WebSocket), exceeding the 100 alerts/hour cap does not disconnect the WebSocket — it silently stops delivering alerts until the hourly counter resets. This silent alert suppression is more dangerous than a hard error because the application continues to function but misses whale movements without any error signal.

Arkham — HTTP 429 with rate limit headers

Arkham returns HTTP 429 when rate limits are exceeded, with X-RateLimit-Limit, X-RateLimit-Remaining, and X-RateLimit-Reset headers. The heavy endpoint limit (1 request/second for /transfers, /swaps, /counterparties) is enforced independently from the standard endpoint limit (20 requests/second). Hitting the heavy endpoint limit does not affect standard endpoint availability. The 429 response includes a JSON body with an error message specifying which limit was hit. This is the best-documented rate limit behavior among the whale data APIs.

CoinGecko — HTTP 429 with escalating cooldowns

CoinGecko's free tier enforces 30 calls per minute. Exceeding this returns HTTP 429. Repeated 429 responses within a short window trigger escalating cooldown periods — the initial cooldown is 60 seconds, but persistent abuse can extend the block to several minutes. CoinGecko's rate limiting is IP-based, not key-based on the free tier, which means multiple applications on the same server share the same rate limit pool. For production deployments, the Pro API key ($129/month) provides separate rate limiting per key.

Rate limits compared: every API, every tier

Rate limits determine what you can build. A dashboard that refreshes every 60 seconds has different requirements than a bot that monitors 100 wallets in real time. The table below maps rate limits across every API tier that was publicly documented as of July 2026.

Two patterns stand out. First, Arkham's free tier has the highest raw rate limit of any free whale data API — 20 requests per second on standard endpoints — but the heavy endpoints most relevant to whale tracking (/transfers, /swaps) are throttled to 1 per second. Second, Deep Blue Alpha's public endpoints take a different architectural approach: instead of per-request rate limits, the data is cached at 60-second intervals. This means every caller receives the same fresh data without per-key throttling, which suits dashboard and widget integrations but does not support per-wallet or per-transaction queries.

Historical data access: how far back can each API query?

Historical data depth is the feature most often gated behind paid tiers. For backtesting whale behavior patterns, training models, or building historical analytics dashboards, the depth of accessible data determines whether the API is viable for the use case.

Etherscan stands alone in providing full blockchain history on its free tier — every transaction since Ethereum's genesis block is queryable at 3 calls per second. The tradeoff is that raw transaction data requires significant processing to extract whale signals. Whale Alert's 30-day cap on Enterprise is the most restrictive historical limit among the paid APIs, which is surprising given the $699/month price point. For applications requiring deep historical whale activity data, Arkham and Etherscan are the strongest starting points — both offer multi-year access on their free tiers.

The practical implication for developers: historical depth matters most during the initial build phase (backtesting logic against past data) and least during steady-state operation (where most applications only need the last 24-48 hours). A cost-effective pattern is to use Etherscan's free tier for a one-time historical data backfill, then switch to a higher-level API (Whale Alert, Arkham, or Deep Blue Alpha) for ongoing real-time data where the pre-processing saves development time. This way the historical depth constraint of the real-time API never binds because the historical data already lives in a local database.

Historical data gotchas by platform

Several APIs have undocumented or poorly documented historical data constraints that only become apparent during implementation:

• Etherscan recently reduced the maximum records per paginated request from 10,000 to 1,000 on the free tier. A historical backfill that previously required 100 pages now requires 1,000 pages for the same wallet, hitting the daily call cap faster. On the Lite tier ($49/month), the 10,000 record limit is preserved.
• Whale Alert does not offer any way to access data older than 30 days, even on Enterprise. There is no archival API, no data export feature, and no extended-history add-on. If a whale moved $50M of ETH 45 days ago, the Enterprise API cannot retrieve that transaction.
• CoinGecko free tier limits historical price queries to 365 days. The /coins/{id}/market_chart/range endpoint will return an error for date ranges exceeding one year on the Demo plan. Paid plans unlock full historical price data back to each token's CoinGecko listing date.
• Arkham entity labels are applied retroactively — when Arkham identifies a new entity, historical transactions involving that entity are backfilled with the label. This means the quality of historical data improves over time as the entity database grows, but historical queries from months ago may return different (better) results today than when they were first queryable.

What each API endpoint actually returns

Pricing and rate limits tell you how much data you can pull. The endpoint specifications tell you what that data contains. The following comparison examines the actual response payloads to identify what intelligence each API provides out of the box versus what requires additional processing.

The response-level comparison reveals why "whale data API" is an ambiguous category. Whale Alert's payload contains transfer metadata (amount, from, to, blockchain, USD value) with exchange labels where applicable — but no directional classification and no sentiment. Deep Blue Alpha's public endpoints return pre-computed intelligence (aggregate buy/sell volume, wallet count, sentiment index with historical scores) but not individual transaction details. Etherscan returns the most raw data but zero whale-specific intelligence. Arkham's payloads include entity attribution — the identity layer that no other API provides at scale.

Build vs buy: raw blockchain RPC vs paid whale APIs

Every developer evaluating whale data APIs faces a foundational question: should the application consume a pre-built API, or build a custom whale tracking pipeline from raw blockchain data? The answer depends on four variables: budget horizon, team size, data specificity requirements, and tolerance for vendor dependency.

What "building from scratch" actually requires

A custom Ethereum whale tracking pipeline has five layers, each with its own cost and complexity:

Layer 1: Block data ingestion. An Ethereum archive node or a managed RPC provider (Alchemy, Infura, QuickNode) that can query historical block data. A managed archive node costs $50–$300/month depending on the provider and throughput requirements. Self-hosting an Ethereum archive node requires 2TB+ SSD storage and costs $100–$500/month in hardware and bandwidth. The Alchemy free tier supports alchemy_getAssetTransfers with 90-day lookback windows, which is sufficient for bootstrapping but not for full historical indexing.

Layer 2: Event decoding. Raw transaction data contains ABI-encoded function calls and event logs. Decoding a Uniswap V3 swap requires parsing the Swap event from the pool contract, extracting the amount0 and amount1 fields, determining which token is which, and computing the execution price. Each DEX has its own contract interface — Uniswap V2, V3, and V4 use different event signatures, SushiSwap forks the V2 interface but with different router addresses, Curve uses custom pool logic, and 1inch aggregates across all of them. Supporting the top 10 DEXes requires maintaining ABI definitions and router addresses for ~50 contracts.

Layer 3: Wallet classification. Raw blockchain data does not distinguish between whales, bots, market makers, exchange hot wallets, and contract deployers. Building a classification layer requires: (a) maintaining a database of known exchange deposit and withdrawal addresses (Coinbase, Binance, Kraken, etc. — these change over time), (b) implementing heuristics to distinguish whale wallets from automated trading bots (transaction frequency, trade size distribution, time-of-day patterns), (c) checking eth_getCode to filter out smart contracts, and (d) computing per-wallet volume and balance metrics to determine which wallets qualify as whales.

Layer 4: USD price resolution. Every whale trade needs a USD value at the time of execution, not the current price. This requires either storing historical price snapshots at block granularity (expensive in storage) or querying a price API like CoinGecko with timestamp parameters (expensive in API calls). For backtesting, this is the most storage-intensive component — millions of trades times dozens of tokens times per-block price snapshots adds up to tens of gigabytes of price data.

Layer 5: Storage and query infrastructure. The Ethereum blockchain has produced billions of transactions since genesis. A whale tracking pipeline that indexes all DEX trades needs a database capable of handling billions of rows with fast time-range queries. PostgreSQL with proper indexing handles this at the ~$50–$200/month hosting tier (500GB+ SSD). Specialized time-series databases (TimescaleDB, ClickHouse) perform better at scale but add operational complexity.

When building makes sense

• Whale data is the core product. If the application's primary value proposition depends on proprietary whale analytics, owning the data pipeline eliminates vendor dependency risk. A competitor using the same API gets the same data.
• Custom classification logic is required. Paid APIs use their own whale definitions, entity labels, and classification heuristics. If the application needs a different definition of "whale" (e.g., based on unrealized PnL rather than wallet balance, or based on trade frequency rather than trade size), the classification layer must be custom.
• Historical depth exceeds 30 days. Whale Alert caps history at 30 days. Etherscan provides full history but as raw data. For applications that need years of classified whale trade data, building a historical index is the only option.
• Multi-DEX coverage with unified taxonomy. Each API covers a different set of DEXes with different labeling conventions. A custom pipeline can unify Uniswap, SushiSwap, Curve, Balancer, and aggregator trades into a single consistent schema.

When buying makes sense

• Whale data is a feature, not the product. A portfolio tracker that shows "whale activity on your tokens" as one of many features does not need to own the data pipeline. An API subscription delivers the feature in days rather than months.
• The team is small or non-technical. Building and maintaining a blockchain indexer is infrastructure engineering. If the team's strengths are product design, content, or trading strategy, the engineering time is better spent elsewhere.
• Budget is constrained and time-to-market matters. The $0/year API stack (DBA Public + Etherscan Free + Arkham Free) delivers a functional whale data layer in a single day of integration work. A custom pipeline takes months.
• Multi-chain coverage is needed immediately. Etherscan V2 covers 60+ chains. Whale Alert covers 13. Building custom indexers for each chain multiplies the engineering cost linearly.

The hidden costs of building: what the first estimate always misses

First-time indexer builders consistently underestimate three cost categories. The first is DEX router address maintenance. Uniswap deploys new router contracts with each major version (V2, V3, V4). Aggregators like 1inch and CoW Protocol update their settlement contracts periodically. Each new deployment requires updating the indexer's contract address list, re-deploying, and potentially re-indexing historical data that transited through the new router. This is not a one-time cost — it recurs every few months.

The second is chain reorganization handling. Ethereum reorganizations (reorgs) occur when the canonical chain tip changes, invalidating recently indexed blocks. A whale tracker that treats indexed data as final can double-count or miss transactions during reorgs. Handling this correctly requires tracking block confirmations, maintaining a "pending" state for recent transactions, and implementing rollback logic. Most API providers handle reorgs internally; custom builders must implement it themselves.

The third is exchange address database maintenance. Centralized exchanges rotate deposit and withdrawal addresses. A custom whale tracker that labels "exchange inflow" and "exchange outflow" events needs a continuously updated mapping of which addresses belong to which exchange. Etherscan provides some of this labeling for free (via their address label pages), but maintaining a comprehensive and current mapping across dozens of exchanges is a recurring research task with no API solution.

Annual cost analysis: from free to enterprise

The annual cost of API access depends on which combination of data types your application needs. The table below maps realistic annual costs for four common use cases: a basic whale dashboard, a mid-range trading bot, a production analytics product, and an institutional data pipeline.

The $0/year baseline is worth emphasizing: a functional whale dashboard can be built entirely on free APIs. Deep Blue Alpha's public endpoints provide the whale intelligence layer (sentiment score, aggregate buy/sell volume, tracked wallet count). Etherscan's free tier provides raw transaction verification. CoinGecko adds price and market context. The limitations are rate limits (3 calls/sec on Etherscan) and data granularity (aggregate whale data from DBA, not per-wallet or per-token breakdowns) — but for a widget, embedded dashboard, or personal monitoring tool, this combination covers the core data needs at zero cost.

When to upgrade: a developer's decision tree

Most whale data projects start on free tiers and upgrade only when a specific constraint blocks progress. The following decision tree identifies the upgrade triggers — the moments when paying for an API saves more time or unlocks more value than working around the free tier's limitations.

The decision tree has a common through-line: stay on free tiers until a specific, measurable constraint blocks a feature or degrades user experience. "The free tier might not be enough eventually" is not an upgrade trigger. "Users are seeing 3-second-old data because the polling interval is limited by Etherscan's rate limit" is.

How to test free whale APIs before committing budget

Every free API listed in this article can be tested with a single curl command or browser request. Start here before evaluating paid tiers.

Deep Blue Alpha — instant, no setup

Open a browser or terminal and call either endpoint directly. No API key, no account, no headers required:

• curl https://deepbluealpha.io/api/v1/public/stats — returns tracked wallet count, 24h buy volume, 24h sell volume, and latest block
• curl https://deepbluealpha.io/api/v1/public/whale-index — returns today's whale sentiment score, component breakdown, and 30-day history

Both endpoints support CORS, making them usable directly from browser-side JavaScript without a proxy server. The 60-second cache means repeated calls within a minute return the same data — by design, since the underlying whale pipeline processes data block-by-block rather than sub-second.

Etherscan — register for API key (free, instant)

Register at etherscan.io for a free API key. Then test with a large-holder balance query or recent transactions for a known whale address. The free tier allows 3 calls per second — enough for manual testing and small-scale monitoring. Watch for the July 2026 change: maximum records per request dropped from 10,000 to 1,000 on the free tier.

Arkham — sign up for free account

Create a free account at arkm.com and access the API documentation. Test entity lookup and transfer endpoints. Standard endpoints allow 20 requests per second on the free tier. Heavy endpoints (transfers, swaps, counterparties) are throttled to 1 per second — test these specifically to see if the rate is sufficient for your use case.

Spend at least a few days testing the free APIs in parallel. The differences in response format, data freshness, and actual usability are not visible on pricing pages — they only become clear when you parse the JSON responses and compare what each one tells you about the same on-chain activity.

Building a whale data API stack at every budget

No single API covers all whale data needs. The practical approach is to layer two or three APIs that cover each other's gaps. The following stacks have been tested against the specifications documented in this article.

The $0/month stack is worth building first even if budget is not a constraint. It establishes the baseline: what data quality and granularity are available for free, and where exactly the gaps are that justify paid API spend. Developers who start with a paid tier often discover they are paying for data they could get for free elsewhere in the stack.

Ethereum L2 coverage: the gap most pricing pages ignore

Ethereum L2 networks (Arbitrum, Optimism, Base, Scroll, Blast, Linea) now process significant DEX volume. Whale tracking that covers only Ethereum mainnet misses an increasing share of on-chain activity. API coverage of L2s is inconsistent and rarely highlighted on pricing pages.

Etherscan V2 has the broadest L2 coverage: 60+ chains under a single API key, including Arbitrum, Optimism, Base, and most other EVM-compatible L2s. Queries specify the chain via a chainid parameter. Rate limits are shared across chains — the 3 calls/sec free limit applies to the aggregate of all chains queried, not per chain.

Arkham covers 12 chains including Arbitrum and Base, with entity labels applied across chains. A wallet identified as "Jump Trading" on Ethereum mainnet retains that label when queried on Arbitrum. Cross-chain entity consistency is Arkham's structural advantage for multi-chain whale tracking.

Nansen covers 30+ chains with Smart Money labels. L2 coverage has expanded steadily, though label density is lower on newer L2s (fewer wallets are classified) compared to Ethereum mainnet.

Whale Alert does not separately index Ethereum L2s. Transfers on Arbitrum, Optimism, and Base are not reported. This is a significant coverage gap for applications monitoring whale activity across the Ethereum ecosystem broadly.

Deep Blue Alpha public API endpoints currently cover Ethereum mainnet only. Whale stats and the sentiment index reflect mainnet DEX activity. L2 whale activity is not included in the aggregate statistics.

For developers building multi-chain whale tracking applications, the practical path is Etherscan V2 for raw data coverage (60+ chains on free tier) combined with Arkham for entity intelligence (12 chains, cross-chain labels). Adding DBA for Ethereum mainnet sentiment context and CoinGecko for multi-chain price data produces a stack that covers the major L2s without any paid subscriptions.

Frequently asked questions

How much does the Whale Alert API cost?

Whale Alert offers two API tiers as of July 2026. The Alerts API costs $29.95 per month and provides WebSocket transfer alerts across 13 blockchains with up to 100 alerts per hour. The Enterprise API costs $699 per month and provides a REST endpoint with 1,000 requests per minute, 30 days of historical transaction data, and up to 500 alerts per hour. There is no free API tier.

Is there a free alternative to the Whale Alert API?

Yes. Deep Blue Alpha offers two free public API endpoints that return Ethereum whale data with no authentication required: /api/v1/public/stats for live whale statistics and /api/v1/public/whale-index for the Whale Sentiment Index with 30-day history. Etherscan offers a free API tier with 3 calls per second for raw blockchain data. Arkham Intelligence provides free API access with 20 requests per second on standard endpoints. The tradeoff is that free tiers provide either aggregate data or raw data — not the pre-processed per-transaction transfer alerts that Whale Alert's paid API delivers.

What are the rate limits on the Whale Alert API?

The Alerts API ($29.95/month) allows a maximum of 2 concurrent WebSocket connections and caps alerts at 100 per hour. The Enterprise API ($699/month) allows up to 1,000 REST requests per minute and 500 alerts per hour. Both tiers cover 13 blockchains and 100+ assets. There is no free API access.

Which whale data APIs offer free access without authentication?

Deep Blue Alpha is the only whale-focused platform offering free public API endpoints with no authentication or API key required as of July 2026. The two CORS-enabled endpoints return live Ethereum whale statistics and a sentiment index with 30-day history. Etherscan requires a free API key registration. Arkham requires a free account signup. CoinGecko offers unauthenticated access for market data but does not provide whale-specific intelligence.

Does the Whale Alert API track DEX trades or only transfers?

The Whale Alert API tracks transfers exclusively — large movements of cryptocurrency between wallet addresses and exchanges. It does not decode DEX swap events, does not classify transactions as buys or sells, and does not provide directional sentiment. DEX trade-level whale data is available through Deep Blue Alpha's public endpoints (aggregate sentiment), Nansen's API (Smart Money trade labels), and Arkham's API (swap history with entity attribution).

Can a whale alert bot be built using only free APIs?

A basic whale monitoring bot can be built using Etherscan's free API (3 calls/sec) to monitor large ERC-20 transfers, Deep Blue Alpha's free public API for whale sentiment context, and CoinGecko's free API for price data. The limitations are Etherscan's rate limits and the lack of pre-classified whale data — custom logic is needed to identify which transactions represent whale activity and to compute USD values. For pre-classified transfer alerts without building classification logic, Whale Alert's API ($29.95/month) is the entry point.

What is the cheapest API for tracking crypto whale transactions?

Deep Blue Alpha's two public endpoints are the cheapest whale-specific API option at $0 — no cost, no signup, no key. Etherscan's free API tier provides raw blockchain data at no cost but requires a free API key. For pre-processed whale transfer alerts specifically, Whale Alert's Alerts API at $29.95/month is the cheapest paid option. CoinGlass starts at $29/month for derivatives-focused whale data. Nansen's Pro plan at $49/month (annual) provides Smart Money intelligence with API credits included.

How does Whale Alert's API compare to Etherscan's API for whale tracking?

They serve fundamentally different purposes. Whale Alert's API returns pre-processed transfer alerts — large movements between addresses with USD values and exchange labels — across 13 blockchains. Etherscan's API returns raw blockchain data — transaction hashes, input data, gas used, token transfers — that requires manual interpretation. Whale Alert costs $29.95–$699/month with no free tier; Etherscan's free tier provides 3 calls/sec. Neither decodes DEX swaps as buys or sells. Whale Alert is the faster path to transfer notifications; Etherscan is the more flexible foundation for custom whale analytics.

What JSON response format do whale data APIs use?

Response formats vary significantly across APIs. Deep Blue Alpha returns flat JSON objects with structured nested data (a data object containing window_24h sub-objects) and ISO 8601 timestamps. Etherscan wraps all responses in a status/message/result envelope and uses Unix epoch timestamps as strings. Whale Alert uses cursor-based pagination with Unix epoch integers. Arkham returns flat JSON objects or arrays with ISO 8601 timestamps and includes X-RateLimit-* headers. The timestamp and value format differences are the most common source of cross-API integration bugs — normalize at the ingestion boundary.

How do whale data APIs handle Ethereum L2 transactions?

Coverage is inconsistent. Etherscan V2 covers 60+ chains including most Ethereum L2s under a single API key. Arkham covers 12 chains including Arbitrum and Base, with cross-chain entity labels. Nansen covers 30+ chains. Whale Alert does not index Ethereum L2s — whale transfers on Arbitrum, Optimism, and Base are not reported. Deep Blue Alpha's public endpoints currently cover Ethereum mainnet only. For multi-chain whale tracking, the practical stack is Etherscan V2 for raw data coverage plus Arkham for entity intelligence.

What is the difference between whale data APIs and running a blockchain RPC node?

An RPC node (self-hosted or via Alchemy/Infura/QuickNode) provides raw block and transaction data — the foundation layer. It does not classify whale activity, label wallets, compute USD values, or provide sentiment. Whale data APIs sit on top of raw blockchain data and add intelligence: wallet identification, trade classification, entity labeling, and directional analysis. Running a managed RPC node costs $50–$300/month; building the classification layer on top requires 400–800 hours of engineering. APIs bundle the intelligence layer into the subscription cost with significantly faster time-to-value.

How much does it cost to build a custom whale tracking indexer from scratch?

A custom whale tracking indexer requires five layers: block ingestion (RPC provider, $50–$300/month), event decoding (ABI management for 50+ DEX contracts), wallet classification (exchange address database + bot filtering heuristics), USD price resolution (CoinGecko or historical price snapshots), and storage infrastructure (PostgreSQL with 500GB+ SSD, $50–$200/month). First-year total: roughly $3,000–$8,000 in infrastructure plus 400–800 hours of engineering time plus 10–20 hours/month ongoing maintenance. Cost-effective only when whale data is the core product and vendor independence is non-negotiable.

Bottom line

Whale Alert's API is the most established name in crypto transfer notifications, but its pricing creates a sharp tradeoff. The Alerts API at $29.95/month provides real-time WebSocket transfer alerts — effective for "something large just moved" monitoring across 13 blockchains. The Enterprise API at $699/month adds REST access and 30 days of historical data but represents a 23x price jump with no mid-range option in between. Neither tier decodes DEX trades, classifies buys versus sells, or provides sentiment scoring.

Free alternatives exist and are genuinely useful. Deep Blue Alpha's two public endpoints provide aggregate whale intelligence (tracked wallet statistics, 24-hour directional volumes, and a daily sentiment index with 30-day history) with no authentication required — the only whale-focused API where a curl command returns pre-computed whale data without any account setup. Etherscan's free API provides raw blockchain data with full historical depth. Arkham's free tier provides entity-level intelligence at 20 requests per second. Combined, these three free APIs cover whale sentiment, raw transaction verification, and entity identification — a functional baseline at zero cost.

The build-vs-buy decision comes down to whether whale data is the product or a feature. Building a custom pipeline from raw RPC data costs $3,000–$8,000 in first-year infrastructure plus months of engineering time, but eliminates vendor dependency and enables unlimited customization. Consuming APIs delivers data in days but constrains the application to the vendor's data definitions, rate limits, and pricing changes. The hybrid path — free APIs for the baseline, custom indexing for the differentiated layer — is the most common production architecture.

The right API depends on the data type your application needs. Transfer alerts (Whale Alert) tell you something large moved. Aggregate whale intelligence (Deep Blue Alpha public endpoints) tells you the current direction of whale sentiment. Raw blockchain data (Etherscan) gives you maximum flexibility with maximum development effort. Entity attribution (Arkham) tells you who controls a wallet. Smart Money analytics (Nansen) combines entity labels with trade-level classification. No single API covers all of these — the most reliable approach is layering two or three APIs that complement each other, starting from the free tiers and adding paid access only where the free data proves insufficient for a specific, measurable need.

Related reading

Whale Tracker Platforms Compared (2026)

9 platforms compared across pricing, features, chain coverage, and data architecture.

Deep Blue Alpha vs Whale Alert

DEX trade tracking vs transfer alerts: a head-to-head platform breakdown.

Deep Blue Alpha vs Arkham Intelligence

Trade-level conviction tracking vs entity identification: features, pricing, and use cases.

Deep Blue Alpha vs Nansen

Ethereum depth vs multi-chain breadth: comparing trade tracking, pricing, and Smart Money labels.

How to Track Ethereum Smart Money Wallets

Step-by-step guide to identifying and interpreting whale wallet on-chain behavior.

What Is a Crypto Whale?

Defining whale wallets by behavior and balance, and why the threshold matters for tracking.

Free whale tracker → Live whale feed → Whale Sentiment Index → Token whale tracker → Whale wallet leaderboard → Sentiment trends → DBA vs Whale Alert → DBA vs Arkham → DBA vs Nansen →