# Base Wallet Tracker – Tokens & Transactions (`renzomacar/base-wallet-tracker`) Actor

Track any wallet on Coinbase's Base L2: ERC-20 holdings, recent transactions, or token transfers — straight from the public Blockscout Base API. No API key.

- **URL**: https://apify.com/renzomacar/base-wallet-tracker.md
- **Developed by:** [Renzo Madueno](https://apify.com/renzomacar) (community)
- **Categories:** Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$3.00 / 1,000 wallet records

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Base Wallet Tracker

Follow any address on **Base**, Coinbase's Ethereum L2, and get its on-chain life in clean JSON. Drop in one or many wallets, pick what you want to see — **what it holds**, **what it's been doing**, or **what tokens have moved through it** — and this Actor hands you back a flat, schema-stable dataset you can store, diff, alert on, or feed straight into an agent. No API key, no RPC node, no archive-node bill, no web scraping.

It reads from **[Blockscout](https://base.blockscout.com)**, the open-source explorer that indexes Base. Blockscout is the same data you see when you paste an address into a block explorer — except here it arrives as machine-readable records with raw and human-readable balances already worked out for you, ready for a spreadsheet, a database, or a model's context window.

### Why Base, and why an explorer instead of an RPC node

If you only have an RPC endpoint, "what ERC-20s does this wallet hold?" is a genuinely annoying question. There's no single call for it — you'd have to know every token contract in advance and poll each `balanceOf`. Transaction history over RPC means walking blocks. An indexer like Blockscout has already done that work: holdings, history, and transfers are one HTTP GET each. This Actor wraps those calls, normalizes the messy nested JSON into flat rows, converts every raw integer balance into a real decimal using the token's own `decimals`, and stops cleanly at your `maxResults`.

Base specifically because it's where a huge slice of new on-chain activity now lives — low fees, fast blocks, a direct Coinbase on-ramp — which makes wallet-level tracking (whales, treasuries, your own positions) actually worth doing here.

### The three modes

You choose one `mode` per run. Every wallet in `addresses` is fetched in that mode.

| Mode | Endpoint | One record = |
|------|----------|--------------|
| `holdings` *(default)* | `/addresses/{addr}/tokens?type=ERC-20` | One ERC-20 the wallet currently holds, with a human-readable `balance`. |
| `transactions` | `/addresses/{addr}/transactions` | One on-chain transaction (native ETH transfer or contract call), with value, fee, method, and status. |
| `token-transfers` | `/addresses/{addr}/token-transfers` | One ERC-20 transfer in or out of the wallet, with the human-readable `amount` and counterparties. |

Pagination is handled for you: the Actor follows Blockscout's `next_page_params` cursor and keeps pulling pages only until the combined `maxResults` cap is reached.

### Input

```json
{
  "addresses": ["0xd8da6bf26964af9d7eed9e03e53415d37aa96045"],
  "mode": "holdings",
  "maxResults": 15
}
```

| Field | Required | Default | Notes |
|-------|----------|---------|-------|
| `addresses` | yes | — | Array of Base wallet addresses (`0x…`). EOAs or contracts. The prefill is `vitalik.eth` on Base. |
| `mode` | no | `holdings` | `holdings`, `transactions`, or `token-transfers`. |
| `maxResults` | no | `50` | Hard cap on total records across all wallets (1–1000). Prefilled at `15` for a quick QA run. |

### Output by mode

**`holdings`** — one row per token:

```json
{
  "address": "0xd8da6bf26964af9d7eed9e03e53415d37aa96045",
  "tokenSymbol": "USDC",
  "tokenName": "USD Coin",
  "tokenAddress": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
  "balance": 1532.94,
  "rawBalance": "1532940000",
  "decimals": 6,
  "tokenType": "ERC-20"
}
```

**`transactions`** — one row per transaction:

```json
{
  "address": "0xd8da6bf26964af9d7eed9e03e53415d37aa96045",
  "hash": "0x6f047c2ea51bffe8684ba17e50f9220f42a209bac5823b924275dd3281a4865c",
  "from": "0x704C6b7C67E2da327f566cfd9085F9bBd9e1be31",
  "to": "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045",
  "valueEth": 0,
  "method": "transfer",
  "status": "ok",
  "timestamp": "2026-06-30T14:24:51.000Z",
  "blockNumber": 48020072,
  "feeEth": 0.000000132414297468
}
```

**`token-transfers`** — one row per ERC-20 movement:

```json
{
  "address": "0xd8da6bf26964af9d7eed9e03e53415d37aa96045",
  "hash": "0x398c3bc85d4153f582b448d7f64a78b215320a558230245663bf4ba6203dd9ec",
  "tokenSymbol": "USDC",
  "tokenAddress": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
  "from": "0xFFA170101E057a878A75531EC194feB350500cC4",
  "to": "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045",
  "amount": 0.15,
  "timestamp": "2026-06-30T14:01:37.000Z"
}
```

#### Field reference

| Field | Appears in | Meaning |
|-------|-----------|---------|
| `address` | all | The wallet you tracked (echoed on every row so multi-wallet datasets stay groupable). |
| `tokenSymbol` / `tokenName` / `tokenAddress` | holdings, transfers | The ERC-20 in question and its Base contract. |
| `balance` / `rawBalance` / `decimals` | holdings | `balance` is human-readable (`rawBalance ÷ 10^decimals`); `rawBalance` is the on-chain integer; `decimals` is the token's precision. |
| `tokenType` | holdings | Token standard (always `ERC-20` here). |
| `hash` | transactions, transfers | Transaction hash — paste into any Base explorer to inspect. |
| `from` / `to` | transactions, transfers | Counterparties. In transfers, compare against `address` to tell inflow from outflow. |
| `valueEth` | transactions | Native ETH moved, already in ETH (not wei). |
| `method` | transactions | Decoded function name when Blockscout knows it (e.g. `transfer`, `swap`), else `null`. |
| `status` | transactions | `ok` for success, `error` for a reverted/failed tx. |
| `feeEth` | transactions | Gas fee actually paid, in ETH. |
| `amount` | transfers | Tokens moved, human-readable. |
| `timestamp` / `blockNumber` | varies | ISO-8601 time and block height. |

A **table view** ships with the Actor, so the dataset is readable at a glance and trivially consumable by an LLM.

### Real use cases

- **Whale & smart-money tracking.** Feed a list of known whale or fund addresses, run `token-transfers` on a schedule, and watch what they accumulate or dump on Base before it shows up elsewhere.
- **Portfolio & treasury monitoring.** Run `holdings` over your own or a DAO's wallets to snapshot balances into a sheet or database — a poor-man's portfolio tracker with zero third-party custody.
- **Forensics & flow tracing.** Pull `transactions` + `token-transfers` for a suspicious address and follow the `from`/`to` graph to map where funds came from and went.
- **A wallet tool for AI agents.** The flat output makes this a clean "look up this Base wallet" function for an LLM or autonomous agent — ask it "what does 0x… hold and what did it just move?" and the agent calls this Actor instead of parsing explorer HTML.
- **Accounting & tax exports.** Export `transactions`/`token-transfers` to CSV and hand them to your bookkeeping flow as a dated activity log.

### FAQ

**Do I need a Blockscout or Base API key?**
No. The public Blockscout Base API is keyless. You just need an Apify account to run the Actor.

**Why a real browser User-Agent under the hood?**
Blockscout's edge rejects requests that look like bots with HTTP 403. The Actor always sends a genuine desktop Chrome `User-Agent` plus `Accept: application/json`, so every call goes through — you never have to think about it.

**What about rate limits?**
Calls are spaced ~250 ms apart and the Actor automatically backs off and retries on HTTP 429 / 5xx. Keep `maxResults` modest if you run very frequently.

**Does it handle balances with weird decimals correctly?**
Yes. Each balance is divided by the token's own `decimals` using big-integer math, so a 6-decimal USDC and an 18-decimal memecoin both come out as correct human-readable numbers — and the untouched `rawBalance` is kept for precision-critical work.

**Can I track several wallets at once?**
Yes — pass as many addresses as you like. `maxResults` is a global cap across all of them, filled wallet by wallet.

**Is it agent / x402 friendly?**
Very. No auth, no browser step, no login — just deterministic structured output with a table view. That makes it an ideal tool to expose to an autonomous agent or wire into a pay-per-call (x402-style) workflow.

### Automate it

Set a **schedule** in Apify — hourly, every few minutes, daily — and point the dataset at a **webhook**, Google Sheet, or your own service. Run `holdings` nightly for portfolio snapshots, or `token-transfers` on a tight loop for live whale alerts, and you've got a self-maintaining Base wallet-intelligence feed with no node and no infrastructure to babysit.

***

*Data sourced from the public Blockscout Base API. This Actor is not affiliated with Blockscout, Coinbase, or Base. Nothing here is financial advice — on-chain data is informational only.*

# Actor input Schema

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

One or more Base wallet addresses (0x…) to track. Every wallet is fetched in the selected mode. EOAs and contracts both work.

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

What to pull for each wallet. holdings = current ERC-20 token balances on Base. transactions = recent on-chain transactions (native ETH transfers, contract calls). token-transfers = recent ERC-20 token transfers in/out of the wallet.

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

Maximum number of records pushed to the dataset across all wallets combined. Pagination follows Blockscout's next\_page\_params until this cap is hit. Keep low for a fast run; raise for a full history sweep.

## Actor input object example

```json
{
  "addresses": [
    "0xd8da6bf26964af9d7eed9e03e53415d37aa96045"
  ],
  "mode": "holdings",
  "maxResults": 15
}
```

# Actor output Schema

## `results` (type: `string`):

Rows produced by Base Wallet Tracker, one item per result in the default dataset.

# 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"
    ],
    "maxResults": 15
};

// Run the Actor and wait for it to finish
const run = await client.actor("renzomacar/base-wallet-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 = {
    "addresses": ["0xd8da6bf26964af9d7eed9e03e53415d37aa96045"],
    "maxResults": 15,
}

# Run the Actor and wait for it to finish
run = client.actor("renzomacar/base-wallet-tracker").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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"
  ],
  "maxResults": 15
}' |
apify call renzomacar/base-wallet-tracker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=renzomacar/base-wallet-tracker",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/3k4hQM6vLzYvS5juj/builds/MaNht2H7de4HBYfjj/openapi.json