# Ethereum Address Monitor & Alert - New Transactions & Tokens (`centorprat/ethereum-address-monitor-alert`) Actor

Watch Ethereum addresses. Each run reads the public chain (keyless) and reports only NEW ETH transactions and ERC-20 token transfers since the last run - optionally only large USD moves or one direction. Schedule it + set a webhook for alerts. Read-only, agent-callable.

- **URL**: https://apify.com/centorprat/ethereum-address-monitor-alert.md
- **Developed by:** [Centor Prat](https://apify.com/centorprat) (community)
- **Categories:** Developer tools
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $8.50 / 1,000 watch runs

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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 Address Monitor & Alert — New Transactions & Tokens

Watch any set of Ethereum addresses and get told the moment they move. Each run reads the **public** chain (keyless) for recent **ETH transactions and ERC-20 token transfers** and, because it remembers what it saw last time, reports **only the NEW events** since the previous run — optionally only large **USD** moves, or one direction. Schedule it + set a webhook and it becomes a standing alarm. Read-only, public chain only — agent-callable.

For on-chain analysts, treasury/ops watching company wallets, researchers tracking known addresses, and AI agents that need a change-trigger on an Ethereum wallet.

### What it does

- Reads each watched address's recent ETH transactions and token transfers via the keyless Ethplorer API.
- **Diffs** against the previous run (state in a named key-value store, stable per watch) and surfaces only what's **new**.
- Values each event in **USD**, classifies **direction** (in/out) and counterparty, and filters out spam-token noise.
- Optional **whale filter** (`minValueUsd`) and **direction** filter.
- First run records a **silent baseline**; later runs report (and with a webhook, alert) only on new activity.

| Output field | Meaning |
|---|---|
| `signal` | baseline-established / new-activity / whale-move / no-new-matching-activity |
| `balanceEth` | current ETH balance |
| `newEvents[]` | each new event: `kind` (eth/token), `asset`, `amount`, `usdValue`, `direction`, `counterparty`, `time`, `txHash` |
| `newCount` / `largestMoveUsd` | how many new + the biggest move in USD |

### Why not just ask an AI agent?

An agent has no memory between runs and no scheduler. This actor keeps **durable state** per watch, so it distinguishes *new* from *already-seen* across days of scheduled runs and fires a webhook exactly when a wallet moves — covering both ETH and token transfers, valued and de-spammed. A standing monitor an agent can't be.

### Input

| Field | Type | Required | Description |
|---|---|---|---|
| `addresses` | array of strings | ✅ | Ethereum addresses to watch. |
| `minValueUsd` | integer | | Only alert on moves ≥ this many USD (0 = all). |
| `direction` | string | | `both` / `in` / `out`. |
| `webhookUrl` | string | | POST new events here when found. |

**Example input**

```json
{
  "addresses": ["0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045"],
  "minValueUsd": 100000,
  "direction": "both"
}
```

### Output

One record per watched address. **Example** (a run that found new activity):

```json
{
  "address": "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045",
  "signal": "new-activity",
  "balanceEth": 5.7697,
  "newCount": 2,
  "largestMoveUsd": 125000.0,
  "newEvents": [
    {"kind": "token", "asset": "USDC", "amount": 125000.0, "usdValue": 125000.0, "direction": "in", "counterparty": "0x...", "txHash": "0x...", "time": "2026-10-17T01:20:00+00:00"}
  ]
}
```

The **first** run instead returns `signal: "baseline-established"` and alerts on nothing.

### Use cases

- **Whale watching** — alert when a known wallet moves ≥ $N in ETH or tokens.
- **Treasury / ops** — get pinged the moment funds leave or arrive at a company wallet.
- **Investigations** — standing watch on an address of interest (ETH + tokens).
- **AI agents** — a scheduled change-trigger that acts only when the wallet moves.

### Alerts / scheduling

1. Set `addresses` (+ optional `minValueUsd` / `direction`) and `webhookUrl`.
2. Schedule the actor in Apify (e.g. every 10–30 min).
3. First run = silent baseline; after that, runs that find new events POST them to your webhook (Slack/Discord/email via Make/Zapier).

### Ready-made tasks

- [Ethereum Whale Alert - Large Transfers from Watched Wallets](https://apify.com/centorprat/ethereum-address-monitor-alert/examples/ethereum-whale-alert)

### For AI agents / MCP

```
https://mcp.apify.com/?tools=actors,docs,centorprat/ethereum-address-monitor-alert
```

Loads as `centorprat--ethereum-address-monitor-alert`. Claude Code:

```
claude mcp add apify -- npx -y @apify/actors-mcp-server --actors centorprat/ethereum-address-monitor-alert
```

### FAQ

**Which chain?** Ethereum mainnet — both native ETH transactions and ERC-20 token transfers.

**Does it need a key?** No — keyless public API.

**How does it know what's new?** It stores the event ids it has seen (per watch) in a named key-value store, so it survives between scheduled runs and diffs against them.

**What's a "whale-move"?** A new event at or above your `minValueUsd` (or ≥ $100k if you leave the threshold at 0).

**Does it spam me with spam tokens?** No — scam/airdrop token transfers are filtered; only real tokens (priced or well-held) count.

**Cost?** Pay-per-event: a small base per run + a premium per new event alerted — quiet runs cost only the base.

**Is it legal?** It reads the public Ethereum ledger only. Alerts are factual on-chain events, never accusations.

### Data & attribution

Public Ethereum chain data via the keyless Ethplorer API; USD values are indicative. No keys, no personal data. Signals, not advice.

### Related actors

- [Crypto Address Risk & AML Screener](https://apify.com/centorprat/crypto-address-risk-aml-screener)
- [Ethereum Wallet & Token Tracer](https://apify.com/centorprat/ethereum-wallet-token-tracer)
- [Bitcoin Address Monitor & Whale Alert](https://apify.com/centorprat/bitcoin-address-monitor-whale-alert)

# Actor input Schema

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

Ethereum addresses to monitor (0x...).

## `minValueUsd` (type: `integer`):

Only alert on new events worth at least this many USD (0 = every new event). Set e.g. 100000 for a whale alert.

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

Which events to alert on.

## `webhookUrl` (type: `string`):

If set, new events are POSTed here as JSON when a run finds them (Slack/Discord/email via Make/Zapier).

## Actor input object example

```json
{
  "addresses": [
    "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045"
  ],
  "minValueUsd": 0,
  "direction": "both"
}
```

# Actor output Schema

## `monitor` (type: `string`):

Per watched address: ETH balance, the NEW events since the previous run (ETH transactions and ERC-20 token transfers, with USD value, direction, counterparty, time), and a signal. First run records a silent baseline.

# 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": [
        "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045"
    ],
    "minValueUsd": 0
};

// Run the Actor and wait for it to finish
const run = await client.actor("centorprat/ethereum-address-monitor-alert").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": ["0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045"],
    "minValueUsd": 0,
}

# Run the Actor and wait for it to finish
run = client.actor("centorprat/ethereum-address-monitor-alert").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": [
    "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045"
  ],
  "minValueUsd": 0
}' |
apify call centorprat/ethereum-address-monitor-alert --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,centorprat/ethereum-address-monitor-alert"
        }
    }
}
```

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/FhUv8cH1vneIrIrwf/builds/qqT9pdwIOpI1mNerB/openapi.json