TRON Wallet Monitor for Incoming USDT: Polling, Events or Webhooks
Four ways a system learns about incoming USDT on TRON, one real transfer timed from block to confirmation, and three traps that credit money you never got.
- Category
- For business
- Published
- Reading time
- 8 min

A system learns about incoming USDT on TRON in one of four ways: it polls an address through TronGrid, reads the Transfer events of the USDT contract, runs its own node with event subscription, or receives webhooks from an outside service. TronGrid and your own node see a transfer within seconds of its block, but you should credit it only after the block is irreversible, which took 50 to 56 seconds for the transfer we timed on Nov 20, 2026. Whatever the method, check the token contract, the record type and the recipient first.
All calls below went to the public TronGrid API on Nov 20, 2026.
Four ways compared
| Method | Delay after the block | What you need | Risks |
|---|---|---|---|
Polling /v1/accounts/{address}/transactions/trc20 |
your poll interval, plus about 1 minute if you ask for confirmed records only | one HTTP call per address per poll | requests grow with the number of addresses; rate limits; gaps if the time window is wrong |
Reading /v1/contracts/{USDT}/events |
seconds for unconfirmed, about 1 minute for confirmed | one stream for all addresses, your own filter | the stream is heavy: every USDT transfer on the network |
| Own java-tron node with event subscription | as soon as your node processes the block; solidity triggers after finality | a synced full node, Kafka, MongoDB or the built-in ZeroMQ queue | node upkeep; a full queue drops messages |
| Webhooks from an outside service | set by the service | an HTTPS endpoint on your side | you depend on someone else’s delivery and retries |
TronGrid: polling an address or reading contract events
Polling an address
The TRC-20 transfers by account call takes the parameters a monitor needs:
only_confirmed=truereturns confirmed records only;only_unconfirmed=truethe opposite; omit both to get both. They cannot be combined.contract_address=TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6tkeeps only real USDT.only_to=truekeeps only incoming records.min_timestampis a block timestamp in milliseconds;order_by=block_timestamp,ascreturns the oldest first.limitgoes up to 200 per page, andfingerprintfrommetagives the next page with the other parameters unchanged.
Confirmed records arrive about a minute after their block, so a window like “the last 30 seconds by my clock” skips them. Store the block_timestamp of the last processed record, request from it inclusive, and drop duplicates by transaction_id.
Illustrative example, check the exact format in the TronGrid reference:
// illustrative example: one poll of a deposit address for confirmed USDT
const USDT = 'TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t';
const url = `https://api.trongrid.io/v1/accounts/${addr}/transactions/trc20` +
`?only_confirmed=true&only_to=true&contract_address=${USDT}` +
`&order_by=block_timestamp,asc&min_timestamp=${lastTs}&limit=200`;
const { data } = await (await fetch(url)).json();
for (const r of data) {
if (r.type !== 'Transfer' || r.token_info.address !== USDT || r.to !== addr) continue;
if (seen.has(r.transaction_id)) continue;
credit(r.transaction_id, BigInt(r.value)); // value in units of 0.000001 USDT
seen.add(r.transaction_id); lastTs = r.block_timestamp;
}
The r.type check is there for a reason. On Nov 20, 2026, the same list for contract TXJgMdjVX5dKiQaUi9QobwNxtSQaFqccvd mixed Transfer and Approval records under the same USDT filter, for example an Approval of 99.88 USDT with that contract in the to field. An approval is permission to spend, not money received (see revoking a USDT approval), yet a monitor that sums value credits it.
Reading the USDT contract’s events
The events by contract call /v1/contracts/TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t/events?event_name=Transfer returns every USDT transfer on the network, with the same only_confirmed, only_unconfirmed, min_timestamp, order_by, limit and fingerprint options. Two details from real answers:
fromandtocome as hex without the41prefix, for example0xaa5e817b..., not base58. Convert your addresses once and compare in hex.- Unconfirmed items carry
"_unconfirmed": true.
The catch is volume. 200 events covered only three blocks: blocks 88,159,852 and 88,159,853 held 76 and 68 USDT transfers.
Model calculation, request count only (the rate limits themselves are in TronGrid’s terms): at a block every 3 seconds there are 28,800 blocks a day. At about 70 transfers a block that is roughly 2 million events, or about 10,000 pages of 200 a day, however many addresses you watch. Polling 500 addresses every 30 seconds is 500 × 2,880 = 1,440,000 calls a day. With many addresses, the stream wins.
Your own node, or someone else’s webhooks
A java-tron full node can push events itself (event subscription documentation): set event.subscribe.enable = true in config.conf, pick a plugin (Kafka or MongoDB) or the built-in ZeroMQ queue, and choose triggers. contractevent and contractlog fire as blocks are processed; solidityevent and soliditylog fire only on solidified blocks, the finality the documentation names for exchanges and bridges. The ZeroMQ page warns that messages are dropped when the queue set by sendqueuelength fills, so plan a backfill by block height.
With webhooks a provider watches the chain and calls your URL; your endpoint still has to tolerate repeats and check the contract, type and amount. UsdtPull offers wallet tracking with notifications about USDT transfers (For business); its price is shown in the app, see the pricing page.

Unconfirmed vs confirmed: one transfer timed
TRON produces a block every 3 seconds, and a block becomes irreversible once 19 of the 27 producers have built on it; background is in how long a USDT TRC-20 transfer takes. On Nov 20, 2026, we followed one fresh transfer, 105.84 USDT in block 88,159,861, with a call every 6 seconds or more:
| Time, UTC | Call | Result | After the block |
|---|---|---|---|
| 05:47:48 | block timestamp | 0 s | |
| 05:47:52.6 | contract events, only_unconfirmed=true |
our transfer is the newest | 4.6 s |
| 05:47:58.9 | contract events, only_confirmed=true |
newest confirmed is in block 88,159,844 | 17 blocks behind ours |
| 05:48:06.3 | account list, only_confirmed=true |
not there | 18 s |
| 05:48:12.7 | account list, only_unconfirmed=true |
there | 25 s |
| 05:48:37.6 | walletsolidity/gettransactioninfobyid |
not found | 50 s |
| 05:48:43.8 | same | found, SUCCESS | 56 s |
| 05:48:50.2 | account list, only_confirmed=true |
there | 62 s |
Worst-case crediting delay = poll interval + time to solidification + indexing. With a 30-second poll that is roughly 30 + 56 + a few seconds, about 1.5 minutes (model calculation). Unconfirmed data is fine for a “payment detected” message, not for crediting.
Three traps that credit money you never got
- A token that only looks like USDT. Without
contract_address, the account list returns every TRC-20 token. In the last 200 incoming TRC-20 records of one long-used address we read on Nov 20, 2026, 174 were USDT and 26 were 21 other tokens, several named after Telegram accounts and websites. Name and symbol are chosen by whoever deploys a token, so matchtoken_info.addressor the emitting contract, never the symbol. More on look-alikes in address poisoning on TRON. - Zero-value transfers from your address. The USDT contract lets anyone call
transferFromfor 0 units from any address. We simulated it withtriggerconstantcontract: an unrelated caller moving 0 USDT out of contractTXJg...ccvdgottrueand one Transfer log with value 0 (89,039 energy in the simulation); the same call for 1 unit reverted. None of the 600 USDT events we read had value 0, but skip zero amounts and never copy an address from such a record. - USDT that arrives through another contract. In this transaction (block 88,159,581) the signer called
minton contractTXJgMdjVX5dKiQaUi9QobwNxtSQaFqccvd, not the USDT contract. That contract pulled 171,318.621147 USDT through an internaltransferFrom, and the USDT contract logged the Transfer. Scanning blocks fortransfercalls toTR7NH...Lj6tmisses it; event-based methods see it. The transaction also logged a second Transfer with the same signature, emitted byTXJg...for its own token, so filter by the emitting contract too.

Setting it up, step by step
- List the addresses to watch and store them in base58 and hex.
- Pick a method: polling for a few addresses, the contract stream for many, a node or webhooks.
- Show “detected” from unconfirmed data; credit only confirmed records, or from
walletsolidityor solidity triggers. - Filter every record: contract
TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t, type Transfer, recipient is yours, amount above zero. - Keep a cursor (last block timestamp or height) and deduplicate by transaction ID and event index.
- Once a day, compare the balance from
balanceOfwith the sum you credited.
What to do after the money arrives, from address schemes to sweeps, is in accepting USDT TRC-20 payments and sweeping deposit addresses.
FAQ
Does watching an address cost energy or TRX? No. Reading TronGrid or your own node does not touch the chain. Only signed transactions use resources.
Is an unconfirmed transfer safe to credit? No. Credit after the block is solidified, about a minute later.
Why does my monitor show a USDT transfer the wallet does not? Usually a token with the USDT name from another contract, an Approval record, or a zero-value transfer.