Recurring card billing is here. Subscribe once and you're covered every month

Get started
Spectrum Nodes

How to Track Robinhood Stock Token Transfers Onchain

Featured image for: How to Track Robinhood Stock Token Transfers Onchain
Share

By Daniel Chayra, Spectrum Nodes · Updated November 4, 2026 · Contract details checked November 4, 2026

Short answer: Robinhood's Stock Tokens are standard ERC20 contracts with 18 decimals on Robinhood Chain, chain ID 4663. Every mint, transfer, and burn emits an ERC20 Transfer event. Mints come from the zero address and burns go to it. Each one also emits TransferWithScaledUI, which adds the amount in underlying shares. Take the contract list from Robinhood's Token Contracts page or its /rhj/assets API, backfill history with eth_getLogs, then point Spectrum's Custom Contract Webhooks at those contracts. Each new event then arrives at your HTTPS endpoint signed, at least once, with a rollback delivery if a reorg removes it.

EventWhat it tells youHow to spot it
Transfer(from, to, value)A mintfrom is the zero address
Transfer(from, to, value)A burnto is the zero address
Transfer(from, to, value)A transfer between holdersNeither side is the zero address
TransferWithScaledUI(from, to, value, uiValue)The same movement, with uiValue in underlying sharesEmitted right after each Transfer
UIMultiplierUpdated(oldMultiplier, newMultiplier, effectiveAtTimestamp)A dividend or split changes shares per tokenEmitted when the change is scheduled
Paused() and Unpaused()The token stops or resumes movingEmitted by the token contract

Event names from Robinhood's Building with Stock Tokens docs and the Stock Token contract source verified on Sourcify, both read November 4, 2026. The same day we read two Stock Token contracts onchain. Both returned 18 decimals and a multiplier of 1.0, and every transfer we sampled wrote a Transfer log followed by a TransferWithScaledUI log.

Spectrum Nodes publishes this guide and runs the webhooks it describes. The guide covers reading public chain data. It is not investment advice.

Where Do Robinhood Stock Tokens Live Today?

On Robinhood Chain. Robinhood launched its current Stock Tokens with the chain's public mainnet on July 1, 2026, and its Stock Token API lists each token's deployment with chain ID 4663.

The first generation, now called Classic Stock Tokens, launched on Arbitrum One in June 2025 and remains available in the Robinhood Europe app, per the ArbitrumDAO launch factsheet. Robinhood describes Classic Stock Tokens as derivative contracts between the customer and Robinhood Europe. This guide covers the Stock Tokens on Robinhood Chain.

What Robinhood's docs say about the tokens:

  • Issuer: Robinhood Assets (Jersey) Limited issues them as tokenized debt securities that give economic exposure to US shares and ETFs.
  • Supply: Only Authorized Participants mint and burn with the issuer, after KYB onboarding. Everyone else buys and sells on secondary venues.
  • Timing: Minting and burning run from Monday 02:00 to Saturday 02:00 Central European Time. Outside that window there are no mints or burns, while onchain trading continues.
  • Eligibility: Robinhood's page states that Stock Tokens are not available in the US or to US persons, and that other jurisdictions are restricted.

For a tracker, that means mint and burn events land inside the weekly tokenization window, while transfers run around the clock.

Why Is Polling eth_getLogs for Stock Tokens Hard Work?

Robinhood Chain makes about ten blocks a second. On November 4, 2026, 36,000 blocks took 3,695 seconds, which comes to about 840,000 blocks a day.

  • Request volume. Poll eth_getLogs once per block and you send about 840,000 requests a day for one filter. At 50 credits a call on our plans, that's about 42M credits a day. Polling once a second still means 86,400 requests a day.
  • Gaps. A restart, a deploy, or a provider timeout leaves a hole in a polling loop. You have to notice it and backfill it.
  • Decoding. Every transfer writes two logs. You decode both if you want token units and share units.
  • Lookalikes. Robinhood's docs warn that a token with a matching name or ticker at another address is not a Robinhood Stock Token, so your filter needs the canonical list.
  • Reorgs. Robinhood's docs say a soft confirmed transaction can still change order until its batch posts to Ethereum. A poller that already stored that block has to notice and undo it.

How Do You Find Every Stock Token Contract?

Start from Robinhood's list, then check each contract onchain.

  1. Read Robinhood's Token Contracts page, which Robinhood generates from its onchain asset registry, or call GET https://api.robinhood.com/rhj/assets. Each asset has tokenSymbol, tokenName, and deployments[] with contractAddress and chainId. Keep the deployments where chainId is 4663. The API allows 60 requests a second.
  2. Check each address onchain. A Stock Token returns 18 from decimals() and answers uiMultiplier().
  3. Refresh the list daily. New listings appear in the API, and a contract that isn't on Robinhood's list isn't a Robinhood Stock Token.

How Do You Backfill Stock Token History With eth_getLogs?

Query Transfer logs across your Stock Token contracts in fixed block windows, sort each log by its zero address side, and save a checkpoint after every window.

A single request for mints on one token over 2,000 blocks looks like this:

curl -s "$ROBINHOOD_RPC_URL" \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0", "id": 1, "method": "eth_getLogs",
    "params": [{
      "address": "'"$STOCK_TOKEN"'",
      "fromBlock": "0x64e0000",
      "toBlock": "0x64e07cf",
      "topics": [
        "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
        "0x0000000000000000000000000000000000000000000000000000000000000000"
      ]
    }]
  }'

The first topic is the keccak hash of Transfer(address,address,uint256). The second is from, and 32 zero bytes there returns mints only. Move the zero topic to the third position for burns, or drop it for every transfer. The amount sits in data as a 32 byte integer with 18 decimals.

For the full history across every token, this viem 2 script pulls the contract list from Robinhood's API, reads Transfer logs in windows, and stops at the finalized block:

import { createPublicClient, http, parseAbiItem, zeroAddress } from 'viem'
import { robinhood } from 'viem/chains'

const client = createPublicClient({
  chain: robinhood,
  transport: http(process.env.ROBINHOOD_RPC_URL), // without a URL, viem calls Robinhood's rate limited public endpoint
})

type Asset = { deployments: { contractAddress: `0x${string}`; chainId: number }[] }
const { assets } = (await (await fetch('https://api.robinhood.com/rhj/assets')).json()) as { assets: Asset[] }
const tokens = assets.flatMap((a) => a.deployments.filter((d) => d.chainId === 4663).map((d) => d.contractAddress))

const transfer = parseAbiItem('event Transfer(address indexed from, address indexed to, uint256 value)')
const STEP = 2_000n // set this to your provider's eth_getLogs block range limit

export async function backfill(fromBlock: bigint) {
  const { number: finalized } = await client.getBlock({ blockTag: 'finalized' })
  for (let start = fromBlock; start <= finalized; start += STEP) {
    const end = start + STEP - 1n < finalized ? start + STEP - 1n : finalized
    const logs = await client.getLogs({ address: tokens, event: transfer, fromBlock: start, toBlock: end })
    for (const log of logs) {
      const { from, to, value } = log.args
      const kind = from === zeroAddress ? 'mint' : to === zeroAddress ? 'burn' : 'transfer'
      await save({ kind, token: log.address, from, to, value, block: log.blockNumber, tx: log.transactionHash, logIndex: log.logIndex })
    }
    await saveCheckpoint(end) // resume from here after a restart
  }
}

save and saveCheckpoint are your own storage calls. Providers cap the block range and the number of addresses per eth_getLogs call differently, so set STEP and split the address list to match yours. On our Robinhood Chain endpoint there's no cap on the number of addresses per call, only on the size of the response, at 100 MB, so if a window comes back too large, make STEP smaller. Blocks up to finalized have reached Ethereum finality, which Robinhood's docs describe as irreversible. In our November 4 check, the finalized block trailed the head by about 17 minutes. Webhooks cover everything newer.

How Do You Get Stock Token Events Pushed Instead of Polling?

Create a Custom Contract Webhook for each Stock Token contract in the Spectrum dashboard. Custom Contract Webhooks, listed as Contract Events in the dashboard, are live on Robinhood Chain.

  1. Open Webhooks, click Create webhook, choose Contract Events, pick Robinhood Chain, and enter an HTTPS URL you own.
  2. Enter one Stock Token contract address. Each Contract Events webhook watches one contract, for one event, several, or all of them, so create one webhook per token you track.
  3. Paste the event fragments you want. For transfers, paste the Transfer fragment below. Add TransferWithScaledUI for share amounts and UIMultiplierUpdated for corporate actions.
  4. For mints only, keep Transfer as the only event and add an indexed filter with from set to the zero address. Set to instead for burns.
  5. Review the calculated event signatures and create the webhook.
  6. Send a test delivery from the webhook page to check your receiver.
{
  "type": "event",
  "name": "Transfer",
  "inputs": [
    { "name": "from", "type": "address", "indexed": true },
    { "name": "to", "type": "address", "indexed": true },
    { "name": "value", "type": "uint256", "indexed": false }
  ]
}

Each matched log arrives decoded, with named args, lowercase addresses, and amounts as decimal strings in token base units. This entry is a mint of 1.5 tokens:

{
  "contract": "0x...",
  "event": "Transfer",
  "txHash": "0x...",
  "logIndex": 124,
  "args": {
    "from": "0x0000000000000000000000000000000000000000",
    "to": "0x...",
    "value": "1500000000000000000"
  }
}

Wallet and portfolio apps can watch their users' wallets instead. An address activity webhook delivers each ERC20 transfer in or out of those wallets with category: "token", the token's symbol and decimals, and both the raw and decimal amounts. Restrict it to Stock Token contracts in the activity and tokens step. Its value counts tokens. For shares, multiply by uiMultiplier() and divide by 1e18.

Compliance teams can route a readable summary to a Slack channel or Telegram chat through a bot they set up. Those deliveries aren't signed JSON. For redundancy, register the same webhook in more than one region; regions run independently.

How Do You Handle Webhook Deliveries Safely?

Check each delivery came from Spectrum, dedupe on the delivery ID, and undo a batch when a rollback arrives.

import express from 'express'

const app = express()
const ZERO = '0x0000000000000000000000000000000000000000'

app.post('/hooks/stock-tokens', express.raw({ type: 'application/json' }), async (req, res) => {
  // 1. Check the delivery came from Spectrum, as our webhooks docs describe
  if (!(await verifySpectrumDelivery(req))) return res.sendStatus(401)

  // 2. Deliveries are at least once: skip a delivery you already processed
  const deliveryId = req.header('X-Spectrum-Event-Id')!
  if (await alreadyProcessed(deliveryId)) return res.sendStatus(200)

  const body = JSON.parse(req.body.toString('utf8'))
  if (body.event.removed) {
    // 3. Reorg rollback: undo every row written for this batch id
    await reverseBatch(body.id)
  } else {
    for (const log of body.event.logs) {
      if (log.event !== 'Transfer') continue
      const { from, to, value } = log.args
      const kind = from === ZERO ? 'mint' : to === ZERO ? 'burn' : 'transfer'
      await record(body.id, { kind, token: log.contract, from, to, value, tx: log.txHash, logIndex: log.logIndex, block: body.event.blockNumber })
    }
  }
  await markProcessed(deliveryId)
  res.sendStatus(200)
})

verifySpectrumDelivery follows our webhooks docs, and alreadyProcessed, markProcessed, record, and reverseBatch are your own storage calls.

  • At least once. The same delivery can arrive twice. Dedupe on the X-Spectrum-Event-Id header, which stays the same across retries. Don't dedupe on the body id.
  • Reorgs. If a delivered block is orphaned, we send a rollback with event.removed: true, the same body id, and the same logs. The rollback has a new X-Spectrum-Event-Id, so match it to the original by body id.
  • Retries. A non 2xx response or a timeout is retried, 5 attempts by default with a 60 second base interval, then the delivery moves to a dead letter queue you can replay from the dashboard.
  • Busy blocks. More than 100 matching events in one block split across several POSTs that share the block hash.
  • Depth. Live reorg detection covers reorgs up to 64 blocks deep, about 6 seconds of Robinhood Chain blocks. Deeper reorgs are handled on a best effort basis when the listener recovers. For a ledger, run a daily reconciliation with eth_getLogs up to the finalized block.

How Do You Track Corporate Actions and Compliance Events?

Beyond transfers, watch the multiplier and the access list, and know what the sequencer screens out.

  • Dividends and splits. UIMultiplierUpdated(oldMultiplier, newMultiplier, effectiveAtTimestamp) fires when a change is scheduled. In the verified contract source, uiMultiplier() switches to the new value at effectiveAtTimestamp without another event, so store the timestamp and apply it yourself. Robinhood's /rhj/corporate-actions API names the action behind each change, such as a forward split.
  • Shares. Raw balances never change for a corporate action. Shares equal the raw amount times uiMultiplier() divided by 1e18, or call balanceOfUI(account).
  • Prices. Robinhood publishes a Chainlink price feed per Stock Token, and that price already includes the multiplier. The REST /prices endpoint returns the raw underlying bid and ask, so apply the multiplier yourself if you mix the two.
  • Blocked addresses. Stock Token transfers, mints, and standard burns check a shared access controls contract and revert if an address involved is blocked. That contract emits Blocked(address) and Unblocked(address). Read its address from any Stock Token with ACCESS_CONTROLLED_REGISTRY(). On November 4, 2026, both tokens we checked returned 0xe10b6f6b275de231345c20d14ab812db62151b00. A Custom Contract Webhook on that contract alerts your compliance team when the list changes.
  • Screening. Robinhood's sequencer also excludes transactions tied to sanctioned addresses. A screened transfer never lands onchain, so there is no event to track.

What Does Spectrum Run on Robinhood Chain?

RPC on Robinhood Chain mainnet with tracing and archive data, plus address activity and Custom Contract Webhooks, from one account.

  • Launch: Live on Robinhood Chain since July 2, 2026, the day after mainnet launched.
  • Reliability: From September 29 to October 14, 2026, our RPC monitor recorded a success rate of 99.97% or higher on our Robinhood Chain endpoint.
  • Archive data: Read balances and contract state at any past block, which a backfill and an audit both need.
  • Price: Robinhood Chain mainnet is on our Free plan, 10M credits a month at 25 requests per second. eth_getLogs costs 50 credits a call. Webhooks come on paid plans and bill per event delivered.
  • Security: SOC 2 Type II attested, and we have never had a breach.
  • Hardware: Our own servers in Tier III data centers in Malta, the Netherlands, and Canada, plus a bare metal deployment in Singapore, serving over a billion requests a day at 99.99% uptime.

For providers, prices, and our ranking on Robinhood Chain, see Best Robinhood Chain RPC Providers in 2027. Signing, retries, and payloads are covered in Spectrum Webhooks and our webhooks docs.

Tracking the full Stock Token list, or want help planning the pipeline? Book a call with our team: https://calendly.com/spectrumnodes-sales/30min

FAQ

Where are Robinhood Stock Tokens deployed? On Robinhood Chain, chain ID 4663. Robinhood's Stock Token API lists each token's contract with that chain ID. The earlier Classic Stock Tokens launched on Arbitrum One in June 2025 and remain available in the Robinhood Europe app, per the ArbitrumDAO factsheet.

How do I tell a Stock Token mint from a transfer? Read the Transfer event. A mint has from set to the zero address, a burn has to set to the zero address, and anything else is a transfer between holders.

Where do I find Stock Token contract addresses? On Robinhood's Token Contracts page, or from GET https://api.robinhood.com/rhj/assets, keeping deployments with chainId 4663. Robinhood's docs say a token with the same name or ticker at another address is not a Robinhood Stock Token.

How many decimals do Robinhood Stock Tokens use? 18. Each token is a standard ERC20 contract.

What is TransferWithScaledUI? An event from ERC8056, the Scaled UI Amount extension. Stock Tokens emit it right after each Transfer, with uiValue giving the amount in underlying shares after dividends and splits.

Can I get webhooks for Stock Token transfers on Robinhood Chain? Yes. Spectrum's Custom Contract Webhooks deliver Transfer and the other Stock Token events from the contracts you name, and address activity webhooks deliver the token transfers in and out of wallets you watch. Both are live on Robinhood Chain.

Are Spectrum Webhooks delivered exactly once? No, at least once. Dedupe on X-Spectrum-Event-Id and repeats become no ops.

What happens to a webhook during a reorg on Robinhood Chain? We send a follow up POST with removed: true, the same body id, and the same events, so you can reverse what you stored. Live detection covers reorgs up to 64 blocks deep.

References

All checked November 4, 2026.

Start Now: https://dashboard.spectrumnodes.com/auth/signup