How to buy Fast Feed access

This guide is for searchers, propAMM operators, market makers, and anyone else who wants to read onchain data faster. It shows you how to subscribe to the Fast Feed on Arbitrum One and keep your access across rounds.

It covers the full purchase path: hash your API key, deposit USDG, read the round state, call purchaseTickets, and automate the purchase with the reference bot. To open the connection and read the messages, see how to consume the Fast Feed.

The Fast Feed admits one WebSocket connection per ticket, and a ticket is valid for one round. To keep a connection open, you buy a new ticket every round from the Tickets contract on Arbitrum One.

PrerequisitesCopy Anchor Link

• You know how Fast Feed rounds and prices work. If not, read the introduction to the Fast Feed and the introduction to PGA, which sets the round cadence.
• An account on Arbitrum One that holds USDG to pay for tickets and ETH to pay for gas.
• An Arbitrum One JSON-RPC endpoint.
• Foundry's cast, or any EVM client, to send transactions. The examples use cast and leave out --rpc-url $RPC_URL --private-key $PRIVATE_KEY to stay short.

Addresses and endpointsCopy Anchor Link

USDG has 6 decimals, so the 17 USD minimum price is 17000000 in the token's smallest unit. The first round started on September 23, 2026 at 17:00 UTC.

The examples below use $FEED_URL, $TICKETS, and $USDG for these values:

export FEED_URL=wss://arb1-txfeed.arbitrum.io/
export TICKETS=0x451DD62C26b753d07d6104aaC6865AaE73a6A598
export USDG=0x004B506865409877C9fA29bfb1ebA929984B9bbC

To test on Arbitrum Sepolia, export the Sepolia values instead. $USDG then holds the TestToken (TEST) address, so the commands in this guide work without changes:

export FEED_URL=wss://sepolia-rollup-txfeed.arbitrum.io
export TICKETS=0x6f940179448e0a1C7BD8cfCB787555eb85cFC879
export USDG=0xca202b90454Db321256Cd84531Dd4929561d1e00

On Arbitrum Sepolia, a round lasts 10 minutes. TEST has 6 decimals and the minimum price is 17000000, as on Arbitrum One. Only Offchain Labs can mint TEST. To get some, post your Arbitrum Sepolia address in the Arbitrum Discord.

Step 1: Generate an API key and its hashCopy Anchor Link

Your API key never goes onchain. You register its Keccak-256 hash with the ticket purchase, and you present the raw key when you connect to the Fast Feed. Anyone who holds the key can use your tickets, so treat it like a password.

1. Generate a random key and keep it private:

   Copy Text

   openssl rand -hex 32

2. Hash it:

   Copy Text

   cast keccak "<your-api-key>"

   Save the 32-byte output. You pass it as apiKeyHash in every purchase.

The hash covers the UTF-8 bytes of the key string exactly as you send it in the Authorization header when you connect. Hash the exact string you send, with no 0x prefix and no surrounding whitespace.

You can bind several tickets to one key, in the same round or across rounds. The Fast Feed allows as many open connections per key as that key has active tickets.

Step 2: Deposit USDGCopy Anchor Link

The contract debits ticket purchases from an internal balance, not from your wallet. Fund that balance before you buy.

1. Approve the contract to pull USDG. amount is in the token's smallest unit, so 100 USDG is 100000000, enough for five tickets at the 17 USDG minimum price:

   Copy Text

   cast send $USDG "approve(address,uint256)" $TICKETS <amount>

2. Move the tokens into your internal balance:

   Copy Text

   cast send $TICKETS "depositToken(uint256)" <amount>

3. Confirm the balance:

   Copy Text

   cast call $TICKETS "tokenBalance(address)(uint256)" <your-address>

Deposit enough for several rounds. The price can rise by up to about two times between rounds, as the rounds and pricing section explains. You can withdraw an unused balance at any time with withdrawToken(amount).

Step 3: Read the round stateCopy Anchor Link

A purchase must name the round and the price you expect. The contract reverts if either value has changed, so you never pay a new round's higher price by accident. Read the live values right before you buy:

cast call $TICKETS "roundNumber()(uint256)"
cast call $TICKETS "currentPrice()(uint256)"
cast call $TICKETS "roundEnd()(uint256)"
cast call $TICKETS "grandfatherPeriodEnd()(uint256)"
cast call $TICKETS "grandfatherCount(address)(uint256)" <your-address>

Round state updates lazily: the first state-changing call in a new round rolls it forward. View functions compute the rolled-forward values on the fly, so the values you read are current.

Step 4: Buy ticketsCopy Anchor Link

Call purchaseTickets with the values from step 3:

cast send $TICKETS \
  "purchaseTickets(uint256,uint256,uint256,bytes32)" \
  <expectedRound> <expectedPrice> <numTicketsDesired> <apiKeyHash>

The contract fills up to numTicketsDesired, capped by the room left in the round, and debits expectedPrice × filled from your internal balance. If the round is close to its cap, you receive and pay for fewer tickets than you asked for. The call reverts only if the round is already sold out.

Each purchase emits a TicketsPurchased(buyer, round, apiKeyHash, price, numTickets, numTicketsDesired) event. Read numTickets from the receipt to learn how many tickets you got.

Your tickets become active when the round ends. Until then, tickets from the previous round stay active. If you hold tickets in both rounds under the same key, your connection stays open across the round boundary.

Step 5: Keep the connection across roundsCopy Anchor Link

Tickets bought in round N are active for round N+1 only, so an uninterrupted connection needs a purchase in every round:

1. Buy the next round's ticket before roundEnd, with the same apiKeyHash. During the grandfather period you can renew up to the number of tickets you held.
2. Shortly after a round ends, the endpoint closes every connection whose key holds no ticket in the new round. A key with a ticket in both rounds keeps its connection.

If your connection closes, reconnect and continue from the current head.

To make the purchase step automatic, run the reference bot described in the next section.

Automate the purchase with the reference botCopy Anchor Link

Buying by hand every round does not scale. Offchain Labs publishes a TypeScript purchase bot in the feed-ticket-contracts repository. Each round, the bot:

1. Reads the price, round boundaries, and your grandfather count.
2. Skips the round if the price exceeds MAX_PRICE_PER_TICKET.
3. Buys up to your grandfather count during the grandfather period, then buys the rest after the period ends.
4. Before each transaction, estimates gas and waits until gas × maxFeePerGas fits within MAX_TRANSACTION_FEE.
5. Sleeps past the round boundary, with random jitter so that bots do not all act at once.

Configure it with environment variables:

Run it with Docker:

git clone https://github.com/OffchainLabs/feed-ticket-contracts.git
cd feed-ticket-contracts/bot
docker build -t purchase-bot .
docker run --rm \
  -e RPC_URL=$RPC_URL \
  -e PRIVATE_KEY=$PRIVATE_KEY \
  -e TICKETS_ADDRESS=$TICKETS \
  -e TICKETS_PER_ROUND=1 \
  -e MAX_PRICE_PER_TICKET=<amount> \
  -e MAX_TRANSACTION_FEE=<wei> \
  -e API_KEY_HASH=<apiKeyHash> \
  purchase-bot

Two behaviors to plan for:

• The bot does not deposit funds. Keep the internal balance topped up with depositToken, as in step 2. A purchase that finds an empty balance reverts, and the bot skips that round.
• The bot exits on RPC or network errors. It treats a contract revert as a skipped round and continues, but any transport failure ends the process. Run it under a supervisor that restarts it, such as Docker --restart=always, Kubernetes, or systemd.

TroubleshootCopy Anchor Link

Purchase revertsCopy Anchor Link

FAQCopy Anchor Link

Which token pays for tickets? USDG on Arbitrum One. The token is fixed when the contract is deployed and cannot change. On Arbitrum Sepolia, tickets cost TEST, a test token that only Offchain Labs can mint. Ask for it in the Arbitrum Discord.

When does my ticket start working? At the end of the round in which you buy it. It stays active until the end of the next round.

What happens to money I do not spend? It stays in your internal balance. Withdraw it at any time with withdrawToken(amount).

Next stepCopy Anchor Link

Once your ticket is active, consume the Fast Feed: open the WebSocket connection, read each message, and handle rejected or closed connections.