# Ethereum Stablecoin Whale Tracker — USDT & USDC (`thescrapelab/ethereum-stablecoin-whale-tracker`) Actor

Find large finalized Ethereum USDT and USDC transfers. Filter by amount, period and wallets; export exact event data, wallet inflows/outflows and transparent search coverage. Supports private incremental checkpoints for scheduled monitoring.

- **URL**: https://apify.com/thescrapelab/ethereum-stablecoin-whale-tracker.md
- **Developed by:** [Inus Grobler](https://apify.com/thescrapelab) (community)
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 matching stablecoin transfers

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

## Ethereum Stablecoin Whale Tracker — USDT & USDC

Find large **finalized Ethereum USDT and USDC transfers**, filter them by amount or wallet, and export transaction evidence with wallet inflow/outflow summaries and explicit search coverage.

**Release status:** privately deployed and tested with live Ethereum USDT/USDC events, including explorer comparisons. Not published. Public release is pending; the Pricing tab shows the effective private-run prices. API examples show the intended name after publication.

### What you get

- One dataset row per matching ERC-20 Transfer event, with actual event identifiers, addresses, block details and timestamps.
- Exact six-decimal token amounts, alongside convenient numeric display amounts.
- Optional transaction sender, destination, nonce, type and native value.
- Per-token totals, distinct transaction counts and largest transfers.
- Optional per-wallet incoming, outgoing and net flow summaries.
- Private incremental checkpoints for customer-configured Apify schedules.
- A coverage report explaining whether the requested search finished and how to continue it.

Use this Ethereum Whale Tracker for treasury reporting, stablecoin movement research, wallet activity pipelines and reproducible blockchain transaction data exports.

### Use cases

- **Treasury reporting:** monitor large incoming and outgoing stablecoin transfers across selected wallets, with separate token totals and exact amounts.
- **Stablecoin research:** use the USDT Transfer Tracker and USDC Transaction Tracker to compare large movements over a bounded historical period.
- **Data pipelines:** run an Ethereum Wallet Monitor on an Apify schedule and join stable event identifiers to your own legally sourced analysis.

### What a large transfer means

A large Transfer event establishes a token movement. It does **not** establish a whale purchase, sale, exchange deposit, wallet owner, profitability, or trading signal. USD values assume a $1 stablecoin peg; they are not market prices or depeg measurements. Zero-address transfers are returned as Transfer events without claiming minting or burning analysis.

### Quick start

Select USDT, USDC or both, enter a minimum amount, choose a period and run. No Ethereum developer credentials are required from customers: provider access is configured by the operator.

For transfers of at least 500,000 token units during the last finalized hour:

```json
{
  "tokens": ["USDT", "USDC"],
  "minimumTransfer": "500000",
  "timeRange": "last_hour",
  "maxResults": 1000,
  "includeTransactionDetails": true
}
```

Relative periods end at the latest finalized block, which trails the current chain head. This is periodic finalized-data retrieval, not real-time Stablecoin Whale Alerts. Review `finality_lag_seconds` and the exact effective timestamps in the coverage report.

### Inputs

| Input | Default | Description |
|---|---|---|
| Blockchain | Ethereum | Ethereum mainnet only |
| Tokens | USDT, USDC | Issuer-verified native token contracts |
| Minimum transfer | `"100000"` | Inclusive minimum per event, as a decimal string with up to six places |
| Time range | Last finalized hour | Also six hours, 24 hours or a custom UTC interval |
| Custom start/end | Empty | UTC timestamps; end exclusive, whole seconds, at most 24 hours within the previous 30 days |
| Wallet addresses | Empty | Up to 20 public Ethereum addresses |
| Wallet direction | Both | Incoming, outgoing or both for specified wallets |
| Maximum results | 10 | Raise up to 1,000 events when needed; a cap may leave incomplete coverage |
| Include transaction details | True | Additional reads for matching transactions |
| Incremental monitoring | False | Continue a private stream from its last committed position |
| Monitor name | `default` | Separate stream name; use a new name when changing filters |
| Historical continuation token | Empty | Continue an incomplete snapshot with the same filters |

See the Input tab for descriptions and validation. An amount threshold applies to each Transfer event, not the sum of every transfer within one transaction.

### Output and exports

Export the default dataset as JSON, CSV, Excel or other Apify dataset formats. `amount_exact` and `amount_raw` are authoritative; numeric `amount` is a convenient floating-point representation.

Abridged example from a verified real Ethereum transfer (shown for the output format; this small transfer is below the default threshold):

```json
{
  "blockchain": "ethereum",
  "token": "USDT",
  "amount_exact": "100.000000",
  "amount_raw": "100000000",
  "estimated_usd_value": 100,
  "valuation_method": "assumed_usd_peg",
  "transaction_hash": "0xe7290f444909e22b9057847dca871d87cd5ce1e79e615b72df4a062114aa8f9e",
  "log_index": 1,
  "block_number": 26210884,
  "timestamp": "2026-10-17T07:48:59Z",
  "transfer_type": "token_transfer",
  "finality": "finalized"
}
```

| Field | Type | Meaning |
|---|---|---|
| `event_id` | string | Chain ID, transaction hash and log index |
| `blockchain`, `chain_id` | string, integer | Ethereum and chain 1 |
| `token`, `token_contract` | string | USDT/USDC and verified contract |
| `amount`, `amount_exact`, `amount_raw` | number, string, string | Display amount, exact six-place amount and uint256 base units |
| `estimated_usd_value` | number | Estimated value at an assumed $1 peg |
| `valuation_method`, `assumed_usd_price` | string, number | `assumed_usd_peg`, `1` |
| `from_address`, `to_address` | string | Actual token event sender and recipient |
| `transaction_hash`, `log_index` | string, integer | Actual event identity |
| `block_number`, `block_hash`, `transaction_index` | integer, string, integer | Actual canonical block/event position |
| `timestamp` | string | Block timestamp in UTC |
| `transaction_url` | string | Etherscan transaction link |
| `transfer_type`, `finality` | string | `token_transfer`, `finalized` |
| `transaction_details` | object or null | Actual transaction-level fields when requested; transaction sender may differ from token sender |

The accompanying `OUTPUT` report includes `complete`, `failed`, `stop_reason`, `processing_limit_seconds`, effective time range, next position, continuation token, provider work counters, token summaries and wallet summaries. **Always inspect this report before treating a search as exhaustive.** Summaries describe returned matching records, not every activity or the balance of a wallet. Selected tokens and watched wallets have explicit zero totals when no matching event is returned; check coverage before interpreting those zeroes. Self-transfers contribute to both incoming and outgoing volume, once to the event count, and zero to net flow.

For continuation or monitoring executions, `complete` means the remaining range after `starting_position` finished. Earlier pages remain in their original datasets. A continuation token is validated pagination data, not proof that earlier pages were retrieved; combine and deduplicate your retained pages when analyzing the original complete period.

Different Transfer events in the same transaction are separate records. Deduplicate downstream using `event_id`, not transaction hash alone.

### Wallet monitoring and schedules

Add wallet addresses and enable incremental monitoring. Save the configuration as your own Apify task and configure an hourly schedule in Apify. Keep the same monitor name and filters. The Actor resumes from its checkpoint, including positions within a block, and does not create schedules or send notifications itself.

Monitoring storage belongs to the account running the Actor. Independent callers and monitor names do not share state. State and result stores created by the Actor are restricted. Account owners can still deliberately share their own data through Apify; treat exported files and shared run links accordingly.

After interruptions, confirmed dataset deliveries can be recovered without emitting them again. An unresolved append or charge outcome pauses the stream for review rather than risking duplicates or charging twice. There is no transactional exactly-once guarantee across arbitrary crashes. Preserve earlier run datasets until pending recovery is resolved.

Backlogs larger than 24 hours require bounded historical backfills before continuing the stream. Do not delete or reset a checkpoint to skip missing coverage unless that is your deliberate intention. Named monitoring storage persists until you delete it and incurs retention costs.

### Introductory pricing

The introductory model is **$0.005 per run + $0.075 per started hour searched + $1 per 1,000 delivered transfer events**, including platform usage. Both tokens, wallet filters and optional transaction details are included. Check the Pricing tab for the effective prices before starting.

A one-hour search returning 10 events costs $0.09; 1,000 events cost $1.08. A zero-match one-hour search costs $0.08 if coverage is searched. The minimum allowed spending limit is $0.081; it is a budget floor, not a flat charge. A 24-hour search can cost up to $1.805 for coverage and startup, plus delivered events, but resource limits may require multiple executions. Each continuation is billed as a new execution for the coverage it searches.

Zero-match searches still perform work. The platform charges startup automatically, including runs that fail validation or cannot reach the provider. Coverage is charged after the first successful log response for each started hour; a later failure may leave a charged partial search. Transfer charges follow confirmed delivery. Retries and duplicate matches are not additional transfer events.

Set Apify's maximum total charge to control spending. The Actor stops when the next charge cannot fit and reports incomplete coverage. Stored datasets and named checkpoints persist under Apify's retention rules; customer exports and storage outside the execution may carry separate Apify costs. Prices can change under Apify's pricing notice rules.

### API example

After publication, use the Apify Python client with **your Apify token**, not an Ethereum key:

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("thescrapelab/ethereum-stablecoin-whale-tracker").call(
    run_input={"minimumTransfer": "500000", "timeRange": "last_hour", "maxResults": 100},
    max_total_charge_usd=1,
)
summary = client.key_value_store(run.default_key_value_store_id).get_record("OUTPUT")["value"]
for row in client.dataset(run.default_dataset_id).iterate_items():
    print(row["token"], row["amount_exact"], row["event_id"])
print("Exhaustive:", summary["complete"], "Reason:", summary["stop_reason"])
```

### Limitations and FAQ

**Why is recent activity missing?** Only finalized blocks are searched. The report exposes lag; unsupported or stale finality fails clearly instead of silently using the chain head.

**Why did the search stop?** Maximum results, raw events, response bytes, block count, RPC budget, runtime or charge limits can stop it. An incomplete historical search supplies a continuation token; monitoring uses its checkpoint. Provider and recovery errors require inspection before retrying.

**Why does a high threshold still take work?** ERC-20 amounts are not indexed. Global searches inspect raw Transfer events before filtering. Wallet filters usually reduce data retrieval.

**Can I identify an exchange or wallet owner?** No attribution data is supplied. Crypto Whale Movement Data is factual event evidence, not ownership intelligence.

**Does it support Base, Bitcoin, other tokens or alerts?** Not in v1. Additional EVM networks, notifications, mint/burn analysis and historical wallet intelligence are possible future extensions.

**Can results be empty?** Yes. A successfully completed empty search produces an empty dataset and an honest coverage report; it never fabricates a transaction to satisfy a health check.

**How do I request support?** Use this Actor's Issues tab in Apify and include the run ID and stop reason. Keep credentials and private wallet watchlists out of public issues.

### Development and release evidence

See [feasibility](docs/FEASIBILITY.md), [validation results](docs/VALIDATION.md), [live verification](docs/LIVE_VERIFICATION_2026-10-17.md), and [cost and profitability estimates](docs/COST_AND_PROFITABILITY.md). The [example provenance](examples/PROVENANCE.md) distinguishes generated fixtures from verified live samples.

# Actor input Schema

## `blockchain` (type: `string`):

Ethereum mainnet only. Finalized block data is used. No pending or live trading signals.

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

Native Ethereum USDT and USDC only.

## `minimumTransfer` (type: `string`):

Inclusive threshold per transfer event. Enter a decimal amount with up to six decimal places; no commas. USD values assume a $1 peg.

## `timeRange` (type: `string`):

Relative periods end at the latest finalized block, not the wall clock. A custom interval must be at most 24 hours and within 30 days.

## `startTime` (type: `string`):

Only for custom searches. Whole-second UTC ISO timestamp, for example 2026-10-16T15:00:00Z.

## `endTime` (type: `string`):

Only for custom searches. Whole-second UTC ISO timestamp, for example 2026-10-16T15:00:00Z.

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

Optional public Ethereum addresses, maximum 20. No wallet owner identity is inferred.

## `walletDirection` (type: `string`):

Applies only to the specified wallets. A transfer between watched wallets appears once in the dataset.

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

Maximum matching transfer events. Reaching this limit may leave incomplete coverage; inspect OUTPUT and use continuation or the next monitoring execution.

## `includeTransactionDetails` (type: `boolean`):

Fetch transaction sender, destination, nonce, type and native value for matching events. This adds RPC calls. No trade classification or executed gas fee is inferred.

## `monitoringMode` (type: `boolean`):

Persist a private per-caller checkpoint. Reuse the same saved task/input and monitor name on customer-created schedules. Custom historical ranges cannot use this mode.

## `monitorName` (type: `string`):

Independent stream name for this account. Changing tokens, threshold, wallets or direction requires a new name. Checkpoints are retained until you delete the named storage.

## `continuationToken` (type: `string`):

Optional token from OUTPUT for an incomplete snapshot. Keep the same token, threshold and wallet filters. Cannot be combined with incremental monitoring.

## Actor input object example

```json
{
  "blockchain": "ethereum",
  "tokens": [
    "USDT",
    "USDC"
  ],
  "minimumTransfer": "100000",
  "timeRange": "last_hour",
  "walletAddresses": [],
  "walletDirection": "both",
  "maxResults": 10,
  "includeTransactionDetails": true,
  "monitoringMode": false,
  "monitorName": "default"
}
```

# Actor output Schema

## `transfers` (type: `string`):

Export finalized token Transfer events, with stable IDs and exact decimal amounts.

## `coverageAndSummaries` (type: `string`):

Always inspect complete and stop_reason before treating the search as exhaustive. Access requires your Apify credentials.

# 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("thescrapelab/ethereum-stablecoin-whale-tracker").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("thescrapelab/ethereum-stablecoin-whale-tracker").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 thescrapelab/ethereum-stablecoin-whale-tracker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,thescrapelab/ethereum-stablecoin-whale-tracker"
        }
    }
}
```

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/QXYVYwXcrLUhdHNJq/builds/MvJGjD4oldTjbMbdt/openapi.json