Build on Robinhood Chain with the Blockscout Pro API

Robinhood Chain is live, and Blockscout is its official block explorer, powering the chain from block one. Robinhood, one of the world's largest fintech companies, is bringing tokenized stocks, ETPs, and RWAs onchain, and Blockscout provides the transparency layer to track all of it: transactions, batches, addresses, and gas, in real time at robinhoodchain.blockscout.com.

The chain itself is an Ethereum Layer 2 built on Arbitrum Orbit, settling to Ethereum with blob data availability. It runs ~0.1 second block times with sub-cent gas paid in ETH, and trading actions on the chain are gas-free for users for the first 90 days.

The Blockscout Pro API is fully integrated with Robinhood Chain, giving you higher-throughput access through the same endpoints, key, and account you use for 100+ other EVM chains.

This guide takes you from zero to a working project: get a key, make your first calls, set up a Node.js project, then deploy and verify a contract and read it back through the API.

Chain facts

Step 1: Get a Pro API key

1. Go to dev.blockscout.com and create an account (email, Google, or GitHub).
2. Open the Keys section and click Create API Key. Keys start with proapi_ and are shown once, so store yours safely.
3. That's it. The free tier gives you 100K credits per day at 5 RPS. Most endpoints cost 20 credits per call, so that's roughly 5,000 requests a day for building and testing.

Export the key so the examples below work as written:

export BLOCKSCOUT_API_KEY=proapi_your_key_here

Step 2: Make your first calls

The Pro API scopes every request by chain ID. For Robinhood Chain, that's 4663 in the path. Same key works on Ethereum (1), Base (8453), Arbitrum One (42161), and every other supported chain.

REST API

Network stats for Robinhood Chain:

curl "https://api.blockscout.com/4663/api/v2/stats?apikey=$BLOCKSCOUT_API_KEY"

Latest blocks:

curl "https://api.blockscout.com/4663/api/v2/blocks?apikey=$BLOCKSCOUT_API_KEY"

Transactions for any address:

curl "https://api.blockscout.com/4663/api/v2/addresses/0xYourAddress/transactions?apikey=$BLOCKSCOUT_API_KEY"

You can also pass the key as a header instead of a query parameter:

curl -H "authorization: Bearer $BLOCKSCOUT_API_KEY" \
  "https://api.blockscout.com/4663/api/v2/stats"

Etherscan endpoints

Etherscan doesn't currently support Robinhood Chain, but you can use the same call structure with Blockscout if you are familiar with the Etherscan APIs.

To migrating a script that uses Etherscan V2's unified API? simpy swap the base URL and key. Etherscan uses api.etherscan.io/v2/api?chainid=, Blockscout uses api.blockscout.com/v2/api?chain_id=.

curl "https://api.blockscout.com/v2/api?chain_id=4663&module=account&action=balance&address=0xYourAddress&apikey=$BLOCKSCOUT_API_KEY"

ETH JSON-RPC

Standard eth_ methods work through the same gateway:

curl -X POST "https://api.blockscout.com/4663/json-rpc" \
  -H "content-type: application/json" \
  -H "authorization: Bearer $BLOCKSCOUT_API_KEY" \
  -d '{"id":1,"jsonrpc":"2.0","method":"eth_blockNumber","params":[]}'

Every response includes usage headers: x-credits-remaining shows your daily balance, x-ratelimit-remaining your RPS headroom. Watch these while you build to see exactly what your app consumes.

Step 3: Set up a project

Node 18+ ships with fetch, so no dependencies are needed. Every command below runs in your terminal; follow along exactly.

1. Check your Node version. You need 18 or higher:

node --version

If the command isn't found or shows a version below 18, install the current LTS from nodejs.org first.

2. Create a project folder and move into it:

mkdir robinhood-blockscout
cd robinhood-blockscout

3. Initialize the project:

npm init -y

4. Create the script file and open it in an editor. nano works everywhere; use vim or code index.js if you prefer:

touch index.js
nano index.js

5. Paste in the following, then save and exit (in nano: Ctrl+O, Enter, Ctrl+X):

const API_KEY = process.env.BLOCKSCOUT_API_KEY;
const BASE = "https://api.blockscout.com/4663/api/v2";

async function get(path) {
  const res = await fetch(`${BASE}${path}`, {
    headers: { authorization: `Bearer ${API_KEY}` },
  });
  if (!res.ok) throw new Error(`${res.status} ${res.statusText}`);
  console.log("Credits remaining:", res.headers.get("x-credits-remaining"));
  return res.json();
}

async function main() {
  const stats = await get("/stats");
  console.log("Total blocks:", stats.total_blocks);
  console.log("Total transactions:", stats.total_transactions);
  console.log("Average block time (ms):", stats.average_block_time);

  const blocks = await get("/blocks");
  const latest = blocks.items[0];
  console.log(`Latest block #${latest.height}: ${latest.transaction_count} txns`);
}

main().catch(console.error);

6. Make sure your API key is set in this terminal session (skip if you already exported it in Step 1):

export BLOCKSCOUT_API_KEY=proapi_your_key_here

7. Run the script:

node index.js

You should see output like:

Credits remaining: 99960
Total blocks: 1284503
Total transactions: 8421977
Average block time (ms): 100
Credits remaining: 99940
Latest block #1284503: 14 txns

You're now reading live Robinhood Chain data. To point the same code at another chain, change 4663 in the base URL. That's the entire multichain integration.

Pagination

List endpoints return 50 items per page. Each response ends with a next_page_params object; append its fields to your next request to get the following 50:

curl "https://api.blockscout.com/4663/api/v2/transactions?apikey=$BLOCKSCOUT_API_KEY&block_number=123456&index=12&items_count=50"

Step 4: Deploy and verify a contract

Explorer verification on Robinhood Chain runs on Blockscout, and Foundry supports it natively. Start on testnet: get free testnet ETH from the faucet, then follow along.

1. Install Foundry if you haven't, load it into your current shell, and run the installer:

curl -L https://foundry.paradigm.xyz | bash
source ~/.bashrc
foundryup

Confirm it works:

forge --version

2. Create a new Foundry project:

mkdir rh-deploy
cd rh-deploy
forge init

This scaffolds src/, test/, and script/ directories with an example Counter contract. You can leave those in place.

3. Create your contract file and open it:

touch src/LaunchGuestbook.sol
nano src/LaunchGuestbook.sol

4. Paste in the contract, then save and exit (Ctrl+O, Enter, Ctrl+X). The example is a small onchain guestbook: anyone can sign it with a note, entries are stored, and each signature emits an event, which gives us decoded logs to look at through the API later:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;

contract LaunchGuestbook {
    // Change this to your own message before deploying
    string public constant GREETING = "gm from block one on Robinhood Chain";

    struct Entry {
        address visitor;
        string note;
        uint256 timestamp;
    }

    Entry[] public entries;

    event Signed(address indexed visitor, string note, uint256 timestamp);

    function sign(string calldata note) external {
        entries.push(Entry(msg.sender, note, block.timestamp));
        emit Signed(msg.sender, note, block.timestamp);
    }

    function totalEntries() external view returns (uint256) {
        return entries.length;
    }
}

Edit the GREETING string to your own message. This will change your compiled bytecode. If you deploy bytecode identical to a contract Blockscout has already seen, its verification database auto-verifies it on deploy through bytecode matching, and you'd skip the verification step entirely. A unique greeting will allow you to verify via Blockscout.

5. Compile it:

forge build

6. Set your deployment variables. Use a throwaway key funded with testnet ETH only. Never commit or reuse a real private key:

export PRIVATE_KEY=0x<your_private_key>
export RH_RPC_URL=https://rpc.testnet.chain.robinhood.com

7. Deploy to testnet:

forge create LaunchGuestbook \
  --rpc-url $RH_RPC_URL \
  --private-key $PRIVATE_KEY \
  --broadcast

The output includes a Deployed to: line. Copy that address and export it for the next step:

export CONTRACT_ADDRESS=0x<deployed_to_address>

8. Verify on the Blockscout explorer:

forge verify-contract $CONTRACT_ADDRESS \
  src/LaunchGuestbook.sol:LaunchGuestbook \
  --chain-id 46630 \
  --rpc-url $RH_RPC_URL \
  --verifier blockscout \
  --verifier-url https://explorer.testnet.chain.robinhood.com/api/

9. Open your verified contract in the browser:

echo "https://explorer.testnet.chain.robinhood.com/address/$CONTRACT_ADDRESS"

Source code and ABI are live on the explorer, with a green verification check on the Contract tab.

10. Sign your own guestbook. This sends a real transaction that calls sign():

cast send $CONTRACT_ADDRESS "sign(string)" "first entry" \
  --rpc-url $RH_RPC_URL \
  --private-key $PRIVATE_KEY

On the explorer, that transaction shows a decoded Signed event in the Logs tab, because your contract is verified.

Step 5: Read your verified contract through the Pro API

Once verified on mainnet, your contract's source, ABI, and metadata are queryable programmatically (reusing the CONTRACT_ADDRESS variable from the mainnet run):

curl "https://api.blockscout.com/4663/api/v2/smart-contracts/$CONTRACT_ADDRESS?apikey=$BLOCKSCOUT_API_KEY"

The response includes the full source code, compiler settings, decoded ABI, and proxy implementation details where relevant. This is explorer-enriched data, not raw RPC: token metadata, internal transactions, and decoded logs come out of the same endpoints with no extra indexing work on your side.

Digging into transactions

The complete decoded transaction object lives at the base endpoint: status, from/to, value, gas used, fee, method, and decoded input when the contract is verified:

curl "https://api.blockscout.com/4663/api/v2/transactions/<tx_hash>?apikey=$BLOCKSCOUT_API_KEY"

Sub-endpoints follow the same pattern for the rest of the data: /logs for decoded event logs, /token-transfers, /internal-transactions for contract-to-contract calls, /state-changes for balance diffs, and /raw-trace for the full execution trace.

On top of that, the /summary endpoint runs Blockscout's transaction interpreter, which returns a plain-English explanation for recognized transaction types like swaps, mints, and bridge deposits:

curl "https://api.blockscout.com/4663/api/v2/transactions/<tx_hash>/summary?apikey=$BLOCKSCOUT_API_KEY"

If you get back {"data":{"summaries":[]},"success":true}, that's normal: simple transfers and unrecognized contract calls have no interpretation to give. The full data is always available at the base endpoint above.

Costs and limits

Credits are consumed per call. The default is 20 credits; heavier endpoints like /transactions/:hash/summary and /transactions/:hash/raw-trace cost 50. The free tier resets 100K credits daily. When you outgrow it, the Builder plan ($49/mo) gives 100M credits at 15 RPS and the Pro plan ($199/mo) gives 500M at 30 RPS. Track live usage, top endpoints, and remaining credits in the dev portal dashboard.

Start building

Robinhood Chain is a new network with familiar tooling: Arbitrum Orbit, standard Solidity, and Blockscout as the official explorer and data layer. One Pro API key covers it plus every other chain Blockscout indexes.

• Get a free key: dev.blockscout.com
• Full endpoint reference: docs.blockscout.com/devs/apis
• Robinhood developer docs: docs.robinhood.com/chain
• Explore the chain: robinhoodchain.blockscout.com