# Robinhood Chain stock tokens: reading the multiplier, holders and daily activity with one API key > Original page: https://docs.blockvectra.com/en/guides/stock-token-multiplier/ > Data is derived from public on-chain records and smart contract state. It is for informational purposes only and does not constitute investment advice. Stock tokens carry jurisdictional restrictions. Robinhood Chain supports tokenized real-world assets (RWAs), including tokenized US equities and exchange-traded funds (ETFs). While standard ERC-20 tokens map balances 1:1, tokenized stocks introduce a corporate-action multiplier to accommodate stock splits and dividend adjustments without changing wallet balances. This guide explains how the stock token multiplier operates, how to convert raw token balances into underlying share counts, how to query `uiMultiplier` on-chain using JSON-RPC `eth_call`, and how to retrieve daily holders and transfer activity through the BlockVectra Data API. For broad network parameters, method policies, and RPC setup, see the [Robinhood Chain guide](https://docs.blockvectra.com/en/guides/robinhood-chain/). For comprehensive field references and Compute Unit (CU) usage models for the dataset, see the [Tokenized stocks guide](https://docs.blockvectra.com/en/guides/stocks/). ## What is the stock token multiplier Robinhood stock tokens are standard ERC-20 tokens (with 18 decimals) issued by Robinhood Assets (Jersey) Limited (RHJ). To handle corporate actions such as stock splits and reinvested dividends, these contracts implement **ERC-8056 (Scaled UI Amount Extension)**. The multiplier (`uiMultiplier`) defines the `shares-per-token` ratio: * **Precision**: `uiMultiplier()` is represented as an 18-decimal fixed-point number, where `1e18` equals `1.0`. * **Initial value**: At token issuance, the multiplier is initialized to `1e18` (one token represents one underlying share). * **Corporate actions**: When a corporate event takes place (such as a forward stock split or a reinvested dividend), the token contract updates `uiMultiplier` and emits the `UIMultiplierUpdated(uint256 oldMultiplier, uint256 newMultiplier, uint256 effectiveAtTimestamp)` event. ### Fixed token balances during splits Stock tokens are **not rebasing tokens**. During corporate actions: * Wallet balances (`balanceOf(account)`) and total token issuance (`totalSupply()`) **remain unchanged**. * Only the scaling multiplier changes. For example, if an underlying stock executes a 2-for-1 forward split: * A holder who owns 10 tokens continues to hold 10 tokens in `balanceOf`. * The contract updates `uiMultiplier` from `1.0` (`1e18`) to `2.0` (`2e18`). * Each token now represents 2 underlying shares, giving the holder an effective exposure of 20 shares. ### Converting balances to share count To compute the number of underlying shares represented by a token balance, use the formula specified in official Robinhood documentation: ```text underlying shares = raw token amount × uiMultiplier ÷ 1e18 ``` ERC-8056 token contracts also expose read-only helper functions on-chain: * `balanceOfUI(address account)`: Directly returns the account's balance expressed in underlying shares (scaled by `uiMultiplier`, 18 decimals). * `totalSupplyUI()`: Directly returns the total token supply expressed in underlying shares. In addition, token transfers emit the `TransferWithScaledUI(address indexed from, address indexed to, uint256 value, uint256 uiValue)` event, recording both the raw token amount and the scaled underlying-share count. ### Multiplier and oracle price feeds Robinhood Chain deploys a dedicated Chainlink price feed (`AggregatorV3Interface`) for each stock token: * The Chainlink price feed (`latestRoundData()`) **already incorporates the multiplier**. It reflects the full market price of one token (underlying share price multiplied by the multiplier). * Applications reading the on-chain Chainlink oracle receive the multiplier-adjusted price directly and **must not** apply the multiplier a second time. * Off-chain metadata can also be checked via Robinhood's REST endpoint `GET https://api.robinhood.com/rhj/assets`, which provides `currentMultiplier`, `pendingMultiplier`, and `pendingMultiplierEffectiveTime`. ## Reading the multiplier with JSON-RPC eth\_call You can inspect the multiplier of any tokenized stock directly via BlockVectra's JSON-RPC endpoint for Robinhood Chain using `eth_call`. * **Function**: `uiMultiplier()` * **4-byte function selector**: `0xa60bf13d` (`bytes4(keccak256("uiMultiplier()"))`) * **Return format**: 32-byte hex-encoded `uint256` (18-decimal fixed-point value) BlockVectra serves Robinhood Chain JSON-RPC requests under `https://api.blockvectra.com/v1/robinhood_mainnet`. Pass your API key via the `x-api-key` header or append it to the path (`https://api.blockvectra.com/v1/robinhood_mainnet/{api_key}`). ### Code examples The examples below query `uiMultiplier()` on the Everpure stock token contract (`0x1Cdad396DB64BDa184d5182A97Dd9B3C62100b7D`): **cURL** ```bash curl -s "https://api.blockvectra.com/v1/robinhood_mainnet" \ -H "Content-Type: application/json" \ -H "x-api-key: $BLOCKVECTRA_API_KEY" \ -d '{ "jsonrpc": "2.0", "id": 1, "method": "eth_call", "params": [ { "to": "0x1Cdad396DB64BDa184d5182A97Dd9B3C62100b7D", "data": "0xa60bf13d" }, "latest" ] }' ``` **viem (TypeScript)** ```ts import { createPublicClient, defineChain, http, parseAbi } from "viem"; const robinhoodMainnet = defineChain({ id: 4663, name: "Robinhood Chain", nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 }, rpcUrls: { default: { http: ["https://api.blockvectra.com/v1/robinhood_mainnet"] }, }, }); const client = createPublicClient({ chain: robinhoodMainnet, transport: http("https://api.blockvectra.com/v1/robinhood_mainnet", { fetchOptions: { headers: { "x-api-key": process.env.BLOCKVECTRA_API_KEY! }, }, }), }); const stockTokenAbi = parseAbi([ "function uiMultiplier() external view returns (uint256)", "function balanceOfUI(address account) external view returns (uint256)", "function balanceOf(address account) external view returns (uint256)", ]); const tokenAddress = "0x1Cdad396DB64BDa184d5182A97Dd9B3C62100b7D"; // 1. Read the corporate-action multiplier (18 decimals, 1e18 = 1.0) const multiplier = await client.readContract({ address: tokenAddress, abi: stockTokenAbi, functionName: "uiMultiplier", }); console.log("uiMultiplier (raw uint256):", multiplier.toString()); // 2. Read raw balance and convert to underlying shares const holderAddress = "0x0000000000000000000000000000000000000001"; const rawBalance = await client.readContract({ address: tokenAddress, abi: stockTokenAbi, functionName: "balanceOf", args: [holderAddress], }); const underlyingShares = (rawBalance * multiplier) / 10n ** 18n; console.log("Calculated underlying shares:", underlyingShares.toString()); // 3. Or read pre-scaled shares directly using balanceOfUI const directShares = await client.readContract({ address: tokenAddress, abi: stockTokenAbi, functionName: "balanceOfUI", args: [holderAddress], }); console.log("Direct balanceOfUI shares:", directShares.toString()); ``` ## Querying holders and daily activity with the Data API While JSON-RPC delivers point-in-time contract state, aggregating historical transfers, net supply changes, and holder distributions across blocks requires indexing. The BlockVectra Data API provides pre-indexed daily summaries for tokenized stocks. ### Available stock endpoints Under `/v1/data/robinhood_mainnet/`, the Data API specification (`data.yaml`) defines two endpoints for stock tokens: 1. **`GET /v1/data/robinhood_mainnet/stocks`**: Daily activity leaderboard of tokenized stocks for a specified UTC calendar date, ordered by transfer activity descending. 2. **`GET /v1/data/robinhood_mainnet/stocks/{token}`**: Token contract metadata and up to 30 days of recent daily metrics for a specific token address. ### Daily leaderboard (`GET /v1/data/robinhood_mainnet/stocks`) This endpoint lists all tokenized stocks active on a given UTC date along with their transfer counts, active participant counts, supply adjustments, and holder distribution metrics. #### Parameters * `chain` (path parameter, required): Network identifier, `robinhood_mainnet`. * `day` (query parameter, optional): UTC date formatted as `YYYY-MM-DD`. Defaults to the latest recorded date when omitted. If no activity is recorded on that date, returns HTTP `200` with `data: []`. Invalid formats return HTTP `400` (`error.code = "bad_request"`). * `limit` (query parameter, optional): Maximum items to return. Defaults to 50; values above 500 are clamped to 500. #### Response fields (`StockDailyListEnvelope`) The response envelope contains `data` (an array of `StockDaily` records) and `meta`: | Field | Type | Description | | ------------------------ | -------------------- | ----------------------------------------------------------------------------- | | `day` | `string` (date) | UTC aggregation date (`YYYY-MM-DD`). | | `token` | `string` (address) | 20-byte token contract address (`0x` + 40 lowercase hex characters). | | `symbol` | `string` | Ticker symbol. | | `name` | `string` | Token display name (empty string `""` when unavailable). | | `transfers` | `integer` (int64) | Total on-chain transfers on this UTC day. | | `unique_senders` | `integer` (int64) | Unique sender addresses initiating transfers on this day. | | `unique_receivers` | `integer` (int64) | Unique recipient addresses receiving transfers on this day. | | `mint_raw_amount` | `string` (decimal) | Total raw token amount minted on this day (UInt256 serialized as string). | | `burn_raw_amount` | `string` (decimal) | Total raw token amount burned on this day (UInt256 serialized as string). | | `net_supply_change` | `string` (decimal) | Net supply change on this day (signed Int256 serialized as string). | | `holder_count` | `integer` (int64) | Total holder address count. | | `top10_holder_share_bps` | `integer` | Combined share of the top 10 holders in basis points (0–10000, 100 bps = 1%). | | `dex_swap_count` | `integer` (int64) | Number of DEX swaps involving this token on this day. | | `dex_raw_volume` | `string` (decimal) | Total DEX raw trading volume on this day (UInt256 serialized as string). | | `refreshed_at` | `string` (timestamp) | ISO-8601 UTC timestamp when this daily record was refreshed. | **cURL** ```bash curl -s "https://api.blockvectra.com/v1/data/robinhood_mainnet/stocks?day=2026-09-30&limit=10" \ -H "x-api-key: $BLOCKVECTRA_API_KEY" ``` **TypeScript** ```ts const res = await fetch( "https://api.blockvectra.com/v1/data/robinhood_mainnet/stocks?day=2026-09-30&limit=10", { headers: { "x-api-key": process.env.BLOCKVECTRA_API_KEY! }, }, ); const body = await res.json(); console.log(body); ``` ### Single token historical metrics (`GET /v1/data/robinhood_mainnet/stocks/{token}`) This endpoint retrieves contract deployment metadata alongside up to 30 days of daily metrics in the `daily` array, ordered by date descending (newest first). #### Parameters * `chain` (path parameter, required): Network identifier, `robinhood_mainnet`. * `token` (path parameter, required): 20-byte token contract address. Case-insensitive; `0x` prefix is optional. Unknown tokens return HTTP `404` (`error.code = "not_found"`). #### Response fields (`StockTokenEnvelope`) The response envelope wraps a `StockToken` object: * **Metadata**: * `address`: Contract address. * `symbol`: Ticker symbol. * `name`: Full token name. * `decimals`: Token decimals (0–255, or `null`). * `created_block`: Block height at which the contract was created. * `created_tx_hash`: Transaction hash of contract deployment. * `factory`: Factory contract address. * `creator`: Deployer address (`null` if unknown). * `mint_address`: Authorized mint address (`null` if unknown). * `burn_address`: Authorized burn address (`null` if unknown). * `refreshed_at`: ISO-8601 timestamp of metadata update. * **`daily`**: Array of `StockDailyMetric` objects (up to 30 days), each containing: * `day`, `transfers`, `unique_senders`, `unique_receivers` * `mint_raw_amount`, `burn_raw_amount`, `net_supply_change` * `holder_count`, `top10_holder_share_bps` * `dex_swap_count`, `dex_raw_volume`, `refreshed_at` **cURL** ```bash curl -s "https://api.blockvectra.com/v1/data/robinhood_mainnet/stocks/0x1Cdad396DB64BDa184d5182A97Dd9B3C62100b7D" \ -H "x-api-key: $BLOCKVECTRA_API_KEY" ``` **TypeScript** ```ts const tokenAddress = "0x1Cdad396DB64BDa184d5182A97Dd9B3C62100b7D"; const res = await fetch( `https://api.blockvectra.com/v1/data/robinhood_mainnet/stocks/${tokenAddress}`, { headers: { "x-api-key": process.env.BLOCKVECTRA_API_KEY! }, }, ); const body = await res.json(); console.log(body); ``` ## Regulatory notes and jurisdictional restrictions * **Public on-chain data**: Metrics surfaced by the Data API and JSON-RPC (`holder_count`, `transfers`, `dex_swap_count`, `uiMultiplier`, etc.) track public on-chain activity and contract state. They do not constitute market equity prices, valuations, or financial advice. * **Not investment advice**: This technical guide does not constitute an offer, solicitation, or recommendation to acquire or trade any asset. * **Jurisdictional restrictions**: Stock tokens are tokenised debt securities issued by Robinhood Assets (Jersey) Limited (RHJ), incorporated in Jersey (registration number 162428). They provide economic exposure to underlying securities but do not grant legal or beneficial ownership rights in those underlying equities. Stock tokens are not registered under the U.S. Securities Act of 1933 and may not be offered, sold, or delivered in the United States or to U.S. Persons. Offers and sales are also subject to restrictions in other jurisdictions, including the United Kingdom, Canada, and Switzerland. For complete prospectuses, final terms, and jurisdictional notices, consult the [Robinhood RHJ documentation](https://docs.robinhood.com/rhj) and the [Robinhood Chain stock tokens overview](https://docs.robinhood.com/chain/stock-tokens/). ## Next steps * [Browse the datasets directory](https://blockvectra.com/en/data/) to see every dataset BlockVectra indexes. * [See the free plan and pricing](https://blockvectra.com/en/pricing/#free) to check what your account includes. * [Log in to the console](https://console.blockvectra.com/en/login/?next=%2Fen%2Fkeys%2F) to create an API key.