# TRON Active Address Checker (`quankai/tron-address-checker`) Actor

Check tens of thousands of TRON addresses in seconds. Returns whether each address is valid, and whether it appears in the set of 23.1M addresses that were active on TRON in the last 30 days. Fully offline lookup against a built-in index — no API keys, no rate limits.

- **URL**: https://apify.com/quankai/tron-address-checker.md
- **Developed by:** [Kai Quan](https://apify.com/quankai) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-usage

## 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

### What does TRON Active Address Checker do?

**Check tens of thousands of TRON addresses in seconds** and find out two things about each one: whether it is a **valid** TRON address, and whether it appeared among the **23.1 million addresses that were active on the TRON network in the last 30 days**.

Every lookup runs **fully offline against an index built into the Actor** — the whole 30-day active-address set is compressed into a ~40 MB read-only structure inside the container. That means **no third-party API, no API key, no rate limits, and no per-address request cost** — the constraint that makes bulk checks impossible with the usual approach.

### Why use TRON Active Address Checker?

Public TRON endpoints allow roughly **15 requests per second** on their free tier. Checking 100,000 addresses that way takes about **two hours** and will almost certainly get you throttled or blocked partway through. This Actor processes the same 100,000 addresses in **under half a second**.

Use it for:

- **Airdrop and quest eligibility** — many campaigns require the wallet to have been active recently. Screen an entire holder list in one run.
- **Sybil and cluster analysis** — filter large address sets into "recently active" and "dormant" before deeper review.
- **Address list hygiene** — validate and normalize mixed-format address dumps (base58 and hex) and drop malformed entries before they break downstream pipelines.
- **On-chain research** — quantify how much of a given address set is actually alive on TRON right now.
- **Compliance and due diligence** — bulk-verify address format correctness with proper base58 checksum validation, not a regular expression.

Because it runs on Apify, you also get **API access, scheduling, monitoring, webhooks and integrations with 5,000+ apps** without writing any infrastructure code.

### How to use TRON Active Address Checker

1. Sign up for a free Apify account — you get free monthly usage credits.
2. Open the Actor and go to the **Input** tab.
3. Paste your addresses into **addressesText** (one per line), or use the **addresses** array field for short lists.
4. Optionally set **maxItems** as a safety ceiling on how many addresses are processed.
5. Click **Start** and wait a few seconds.
6. Open the **Output** tab and download results as JSON, CSV, Excel or HTML.

### Input

Free-form addresses are accepted in three notations, mixed within one run:

- **base58** — 34 characters, starts with `T` (the normal TRON address form)
- **hex with prefix** — 42 characters starting with `0x41`
- **hex without prefix** — 40 characters

For large batches always use the **addressesText** textarea rather than the array field: it transfers far more cheaply and comfortably handles hundreds of thousands of lines.

```json
{
  "addressesText": "TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t\nTLa2f6VPqDgRE67v1736s7bJ8Ray5wYjU7",
  "maxItems": 0
}
```

### Output

One row per input address. Duplicates are removed before processing, and the order of your input is preserved.

```json
{
  "address": "TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t",
  "valid": true,
  "inputFormat": "base58",
  "addressHex": "0x41a614f803b6fd780986a42c78ec9c7f77e6ded13c",
  "active_last_30d": true,
  "error": null
}
```

You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

### Data fields

| Field | Type | Description |
|---|---|---|
| `address` | string | The address exactly as you supplied it |
| `active_last_30d` | boolean | null | `true` if the address appears in the 30-day active set. `null` when the address is invalid |
| `valid` | boolean | Whether the address parsed successfully, including base58 checksum verification |
| `inputFormat` | string | Which notation was detected: `base58`, `hex41` or `hex` |
| `addressHex` | string | Normalized 42-character hex form (`0x41` + 20-byte body) |
| `error` | string | null | Reason the address was rejected, when `valid` is `false` |

### How much does it cost to check TRON addresses?

This Actor uses **pay-per-event pricing**: you pay per address checked, with no separate compute charge for the lookup itself. Because the index is baked into the image, there is **no per-request cost paid to any third-party API** — the price you see is the whole cost.

Set **maxItems** whenever you are experimenting so a typo in a pasted list cannot turn into an unexpectedly large run.

### Advanced options and tips

- **Feed it a file.** Point the Actor at a dataset from another run, or paste from a spreadsheet column — one address per line.
- **Combine with a balance or transaction Actor.** Use this Actor first to strip out dormant addresses; the expensive per-address API calls then only run against addresses that are actually alive.
- **Schedule it.** Refresh your "active address" lists on a cadence and always work from a current snapshot.
- **Invalid addresses are still reported**, with the reason, so a single bad row never fails your whole run.

### FAQ, limitations and support

**How current is the activity data?**
The index is a snapshot of TRON mainnet activity for the 30 days ending **2026-09-19**, containing **23,143,779 unique addresses** (including TRC-20 transfer recipients). A later snapshot may be published as a new version.

**Is the active/inactive answer exact?**
A `false` answer is **exact** — the address is definitively not in the active set. A `true` answer is a probabilistic membership test with a **0.1% false-positive rate**, so roughly one in a thousand inactive addresses may be reported as active. This is designed for bulk screening, where that margin is well inside the noise of any real workflow. If you need bit-exact membership for a short list, contact us.

**Does this return balances?**
No. Balances are account state rather than chain events and are not part of this index. This Actor answers validity and recent activity only.

**Which addresses count as "active"?**
Any address that either sent or received a transaction on TRON mainnet in the window, plus recipients of TRC-20 transfers.

**Is address validation real?**
Yes — base58 addresses are fully decoded and the **4-byte double-SHA256 checksum is verified**, so a mistyped address is reported as invalid rather than silently treated as active-in-false.

Found a bug or need a different chain, a longer activity window, or exact membership? Open an issue on the **Issues** tab — custom solutions are available.

# Actor input Schema

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

Addresses to check. Accepts base58 (34 chars, starts with T) or hex (40/42 chars, with or without the 0x41 prefix). Good for up to a few thousand entries.

## `addressesText` (type: `string`):

Newline- or comma-separated list. Use this field for large batches — it is far cheaper than the array field and handles hundreds of thousands of addresses.

## `maxItems` (type: `integer`):

Safety ceiling on how many of the supplied addresses are processed. 0 means no limit. Use it to cap the cost of a run.

## Actor input object example

```json
{
  "addresses": [
    "TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t",
    "TLa2f6VPqDgRE67v1736s7bJ8Ray5wYjU7"
  ],
  "maxItems": 0
}
```

# Actor output Schema

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

No description

## `summary` (type: `string`):

No description

# 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": [
        "TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t",
        "TLa2f6VPqDgRE67v1736s7bJ8Ray5wYjU7"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("quankai/tron-address-checker").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": [
        "TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t",
        "TLa2f6VPqDgRE67v1736s7bJ8Ray5wYjU7",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("quankai/tron-address-checker").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": [
    "TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t",
    "TLa2f6VPqDgRE67v1736s7bJ8Ray5wYjU7"
  ]
}' |
apify call quankai/tron-address-checker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,quankai/tron-address-checker"
        }
    }
}
```

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/yGXZJdtYA5wfu9wFf/builds/IjFkFNCIxYu2Zqv7b/openapi.json