Understanding Wallet Classifications from Crypto Whales to Krills

On 5 October 2026, 41 wallets held 98% of all PayPal USD (PYUSD) on Ethereum. Each held over 1,000,000 coins. At the other end, 95% of the coin's holders had 100 PYUSD or less. A plain holder count, about 108,700 here, hides that split. Sorting by balance into tiers, from whales down to krill, shows it.

Key findings

• PYUSD is top-heavy. 41 whales held 98% of its supply on Ethereum, and the top three held 61%. The median holder had less than 2 coins.
• Most PYUSD holders are krill. About 103,800 of them held 100 PYUSD or less, and together they held about 1 million coins of the 1.79 billion.
• Nine wallets held 51% of all UNI. The largest is Uniswap's governance Timelock contract, with 262 million UNI. The second is a burn address that nobody is known to control, with 113 million.
• A wallet is not an owner. Etherscan labels the third- and fifth-largest UNI wallets as belonging to Binance, and an exchange wallet holds coins for many customers.
• Check the biggest balances. In one of our runs, two wallets listed as whales held nothing when we read the token contract.

The six tiers

There is no fixed standard for these names. Glassnode, an analytics firm, sorts Bitcoin owners into eight groups, from shrimp (under 1 BTC) to humpback (over 5,000 BTC). Glassnode first groups the addresses it believes share one owner (Glassnode, 15 March 2023).

The tiers here are simpler. Each wallet counts on its own, and the cut-off is the number of tokens it holds:

Pick the cut-offs to suit the coin. PYUSD is a stablecoin that PayPal says is redeemable 1:1 for US dollars (PayPal), so 1,000,000 PYUSD is about $1,000,000. The same count of a coin priced at one cent is worth $10,000. Set the cut-offs in dollars before you compare two coins.

A whale matters because one large sale on a thin market moves the price. Where a token carries votes, the biggest balances carry the most votes. On 5 October, PYUSD's top three accounts held 61% of its supply, more than every other account put together. Tier counts and the Nakamoto number below put a figure on how top-heavy a token is.

Example 1: count each tier

Which plan runs these. Every query below reads dataset: combined, which covers each wallet's whole balance history. That needs a holders or Ethereum archive add-on (pricing). On the trial or a plan without one, drop the dataset argument, and the query sees only wallets whose balance changed in the last few days: 4,537 PYUSD wallets on 5 October, against about 108,700 in the full set.

The Holders API returns a token's holders ranked by balance. uniq(of: Holder_Address, if: ...) counts the wallets whose balance falls in a range, and each alias in the query is one tier.

{
  EVM(network: eth, dataset: combined) {
    Holders(
      where: {
        Currency: {
          SmartContract: { is: "0x6c3ea9036406852006290770BEdFcAbA0e23A0e8" }
        }
      }
    ) {
      whales: uniq(
        of: Holder_Address
        if: { Balance: { Amount: { gt: "1000000" } } }
      )
      sharks: uniq(
        of: Holder_Address
        if: { Balance: { Amount: { gt: "100000", le: "1000000" } } }
      )
      dolphins: uniq(
        of: Holder_Address
        if: { Balance: { Amount: { gt: "10000", le: "100000" } } }
      )
      seals: uniq(
        of: Holder_Address
        if: { Balance: { Amount: { gt: "1000", le: "10000" } } }
      )
      fish: uniq(
        of: Holder_Address
        if: { Balance: { Amount: { gt: "100", le: "1000" } } }
      )
      krill: uniq(
        of: Holder_Address
        if: { Balance: { Amount: { gt: "0", le: "100" } } }
      )
    }
  }
}

To see how many coins each tier holds, change every uniq(of: Holder_Address, ...) to sum(of: Balance_Amount, ...) and keep the same if ranges. Both queries came back in about a second on 5 October 2026:

Check before you quote. We read each whale's balance from the token contract with balanceOf. On our last run the query listed 41 whales, and all 41 matched. An earlier run that day listed 43, and two of them, at 9.1 million and 2.6 million, held nothing. The whale row above shows the 41 and the coins they hold on chain. The other rows are the query's output and were not checked wallet by wallet. Read the largest balances from the contract before you publish a figure.

The same query timed out after two minutes when we ran it on USDT. Start with a smaller token if you are trying it for the first time.

Example 2: list the top holders

Order by Balance_Amount and take the first ten rows. Amount(selectWhere: { gt: "0" }) skips zero balances.

{
  EVM(network: eth, dataset: combined) {
    Holders(
      where: {
        Currency: {
          SmartContract: { is: "0x1f9840a85d5aF5bf1D1762F925BDADdC4201F984" }
        }
      }
      orderBy: { descending: Balance_Amount }
      limit: { count: 10 }
    ) {
      Holder {
        Address
      }
      Balance {
        Amount(selectWhere: { gt: "0" })
        FirstChangeTime
        LastChangeTime
      }
    }
  }
}

The first five rows on 5 October 2026:

All ten balances matched balanceOf on the UNI contract. The top nine held 509 million UNI, 51% of the 1 billion total supply the contract reported. Two of the nine are not traders. The largest is Uniswap's governance Timelock contract, and nobody is known to hold the key to the burn address in second place. Label both, or leave them out, before you call a token top-heavy.

Example 3: measure how top-heavy a token is

The Holders API also runs summary statistics over balances. Pass the token as a variable to reuse the query.

query ($token: String!) {
  EVM(network: eth, dataset: combined) {
    Holders(
      where: {
        Currency: { SmartContract: { is: $token } }
        Balance: { Amount: { gt: "0" } }
      }
    ) {
      holders: uniq(of: Holder_Address)
      supply: sum(of: Balance_Amount)
      median(of: Balance_Amount)
      gini(of: Balance_Amount)
      nakamoto(of: Balance_Amount, ratio: 0.5)
    }
  }
}

{
  "token": "0x6c3ea9036406852006290770BEdFcAbA0e23A0e8"
}

Gini runs from 0, where every wallet holds the same, to 1, where one wallet holds it all. Nakamoto with ratio: 0.5 is the fewest wallets that together hold half the supply. On 5 October 2026 the query returned:

Both coins scored above 0.99, so Gini alone barely tells them apart. The Nakamoto number does: 3 against 9 or 10. Gini sits so close to 1 because the median account in each coin has less than 2 tokens.

Treat the median and the Nakamoto number as estimates. Across our runs that day the PYUSD median moved between 1.08 and 1.35, and the UNI median between 1.56 and 1.70. The UNI balances in the index added up to 1.02 billion, against the 1 billion the contract reports, and that gap was enough to move the UNI Nakamoto number from 9 to 10. average and theil_index work the same way. gini, nakamoto and theil_index do not accept an if filter (statistics docs).

Example 4: count new holders since a date

FirstChangeTime is the first balance change the index has for a wallet and token. Filter on it to count wallets that arrived in a window.

{
  EVM(network: eth, dataset: combined) {
    Holders(
      where: {
        Currency: {
          SmartContract: { is: "0x6c3ea9036406852006290770BEdFcAbA0e23A0e8" }
        }
        Balance: {
          FirstChangeTime: { since: "2026-09-05T00:00:00Z" }
          Amount: { gt: "0" }
        }
      }
    ) {
      new_holders: uniq(of: Holder_Address)
      new_whales: uniq(
        of: Holder_Address
        if: { Balance: { Amount: { gt: "1000000" } } }
      )
    }
  }
}

About 8,600 wallets got their first PYUSD on Ethereum between 5 September and 5 October 2026 and still held some. Two of them already held over a million each, 28.1 million and 1.6 million PYUSD, and both balances matched the contract.

What a holder count does not tell you

• Who owns the wallet. One person can spread coins over many wallets, and one exchange wallet holds coins for many customers. Glassnode groups addresses into owners before it counts. The Holders API counts wallets.
• Whether a wallet can trade. Burn addresses and contracts, such as Uniswap's Timelock, show up as holders.
• What changed a minute ago. Holders is query-only. A subscription on it is accepted but never pushes a message (Balances and Holders cubes). Poll the query on a schedule, and stream the token's ERC-20 transfers to see when a whale moves. Streaming over WebSocket starts on the Pro plan.

Next steps

1. Read the EVM Token Holders API reference and the Ethereum token holder examples.
2. Start a 7-day free trial from the pricing page. Every paid plan starts with one: no card, real-time data only. After the trial, plans start at $49/mo, or $29/mo billed yearly.
3. Full holder lists and holder history, such as snapshots by date and holder counts over time, read the archive, which is an add-on on top of any plan. The Token Holder API page lists it.
4. Paste the queries above into the GraphQL IDE, and generate an API token when you call the API from code. New to GraphQL? Start with your first query.

Questions? Ask on Telegram or email support@bitquery.io.

Updated on 5 October 2026 by the Bitquery team: every query was rewritten for the current Holders API and run that day, the largest balances were checked against the token contracts, and the trial and plan prices were checked against Bitquery's billing catalogue. The 2024 figures for USDT, MAYC and trending tokens, a query that no longer runs, a "free tier" line that was wrong, and claims about whale trading tactics we could not source were removed. AI tools helped redraft the text.