How to consume the Fast Feed

This guide shows you how to connect to the Fast Feed on Arbitrum One and read the messages it publishes. To buy the ticket that admits your connection, follow how to buy Fast Feed access first.

PrerequisitesCopy Anchor Link

• An API key bound to an active ticket. How to buy Fast Feed access shows how to generate the key and buy the ticket.
• The Fast Feed endpoint for your network, from addresses and endpoints. The examples read it from $FEED_URL and the raw key from $API_KEY.
• A WebSocket client. The examples use wscat or websocat on the command line, the ws package for Node.js, and the websockets package for Python.

ConnectCopy Anchor Link

Once the round in which you bought has ended, open a WebSocket to the Fast Feed endpoint and send your raw API key, not its hash, as a bearer token in the Authorization header of the upgrade request:

Authorization: Bearer <your-api-key>

The endpoint hashes the key with Keccak-256, compares it against the active tickets, and only then completes the upgrade. Messages start flowing at once. You open one connection per ticket, and each connection receives the full feed. Three rules apply to every client:

• Complete the upgrade within 5 seconds, or the endpoint drops the socket.
• Send only ping and pong frames.
• Read as fast as the feed arrives. The endpoint drops a client that lags behind, so parse and process off the read loop.

Every frame is a binary WebSocket frame that carries one JSON object with one transaction. The what the Fast Feed publishes section lists every field.

wscat -c "$FEED_URL" -H "Authorization: Bearer $API_KEY"

import WebSocket from 'ws';

const ws = new WebSocket(process.env.FEED_URL, {
  headers: { Authorization: `Bearer ${process.env.API_KEY}` },
});

ws.on('unexpected-response', (req, res) => {
  // 401: unknown key or no active ticket. 429: every ticket already has a connection.
  console.error(`Rejected: HTTP ${res.statusCode}`);
  req.destroy(); // with a listener attached, ws leaves the request open
});

ws.on('message', (data) => {
  const msg = JSON.parse(data.toString());
  // msg.pga_round, msg.transaction.tx_hash, msg.transaction.receipt, ...
});

ws.on('close', (code, reason) => {
  console.log('closed', code, reason.toString());
});

import asyncio
import json
import os

import websockets


async def main():
    headers = {"Authorization": f"Bearer {os.environ['API_KEY']}"}
    try:
        async with websockets.connect(os.environ["FEED_URL"], additional_headers=headers) as ws:
            async for frame in ws:
                msg = json.loads(frame)
                # msg["pga_round"], msg["transaction"]["tx_hash"], msg["transaction"]["receipt"], ...
    except websockets.InvalidStatus as e:
        # 401: unknown key or no active ticket. 429: every ticket already has a connection.
        print(f"Rejected: HTTP {e.response.status_code}")
    except websockets.ConnectionClosed as e:
        print(f"closed {e.rcvd.code} {e.rcvd.reason}")


asyncio.run(main())

What the Fast Feed publishesCopy Anchor Link

Each message is a FeedMessage envelope that carries one transaction plus the metadata that you need to place it in time and in order. The Sequencer sends each message as a JSON object inside a binary WebSocket frame, so byte fields arrive as hex-encoded strings.

The transaction object carries the transaction itself:

What the receipt reports:

• status
• gas_used
• gas_used_for_l1
• cumulative_gas_used
• effective_gas_price
• base_fee
• Any contract_address the transaction created
• The event logs emitted by the transaction

Each entry in logs carries three fields:

• address: the hex-encoded address of the contract that emitted the event
• topics: the hex-encoded topics of the event, in order
• data: the hex-encoded event data

Reconnect after a dropCopy Anchor Link

If your connection closes, reconnect and continue from the current head. The Fast Feed keeps no history, so the messages sent while you were away are gone.

To keep a connection open from one round to the next, buy a ticket for every round, as described in keep the connection across rounds.

TroubleshootCopy Anchor Link

Connection rejected or closedCopy Anchor Link

FAQCopy Anchor Link

Do I need a Nitro node? No. The Fast Feed is a stream for your own client. To follow the chain, use the free sequencer feed instead.