# Robinhood Chain Feed and Transaction Benchmark: BlockRazor vs bloXroute

> BlockRazor Package Node-required Feed vs bloXroute Enterprise Sequencer Feed, plus same- and distinct-nonce Robinhood Chain submission tests.

Source: https://blockrazor.io/blog/robinhood-feed-blockrazor-vs-bloxroute-benchmark/  
Updated: 2026-10-22  
Author: BlockRazor  
Language: en

---

![Robinhood Chain Feed and transaction-sending benchmark: BlockRazor vs bloXroute](/blogs/images/robinhood_blockrazor_vs_bloxroute.png)

To measure Robinhood Chain infrastructure across a complete latency-sensitive workflow, we benchmarked BlockRazor against bloXroute on both block reception and transaction submission. The Feed comparison used the Robinhood Chain Node-required Sequencer Feed included with BlockRazor Package and the Robinhood Chain Sequencer Feed available in bloXroute Enterprise. BlockRazor Feed arrived first on all 2,919 consecutive matched blocks from `94,990,680` through `94,993,598`, leading by `8.264 ms` at P50 and `24.520 ms` at P99. In two one-to-one, 100-round submission tests, BlockRazor won 99 same-nonce races and 98 distinct-nonce onchain-position comparisons.

> **Key results**
>
> - Feed comparison: BlockRazor Package Node-required Sequencer Feed vs bloXroute Enterprise Sequencer Feed.
> - Feed result: BlockRazor arrived first on 2,919/2,919 matched blocks, leading by `8.264 ms` at P50 and `24.520 ms` at P99.
> - Same nonce: BlockRazor won 99/100 rounds; bloXroute won 1/100.
> - Distinct nonces: BlockRazor won 98/100 rounds; bloXroute won 2/100.
> - RPC response: In the same-nonce test, BlockRazor and bloXroute averaged `0.504 ms` and `13.769 ms` in `sendDuration`. In the distinct-nonce test, they averaged `0.447 ms` and `12.797 ms`.
> - Scope: RPC response speed and final onchain ordering are different metrics and should not be used interchangeably.

## Test scope and interpretation

The Feed test matched the two Robinhood Chain Sequencer Feeds by block height. The BlockRazor side used the Node-required Feed included with BlockRazor Package; the bloXroute side used the Sequencer Feed available in bloXroute Enterprise. For each matched block, the feed that became client-ready first was represented as `0.000 ms`; the other value is the difference between the two arrival timestamps, not absolute end-to-end latency.

We ran the transaction-submission tests on Robinhood Mainnet (Chain ID `4663`). Each test covered 100 rounds with a two-second cooldown in a one-to-one configuration: the BlockRazor Ohio relay against the bloXroute Robinhood API (`https://api.blxrbdn.com`, method `robinhood_tx`). The same-nonce rounds started across blocks `95,095,809–95,097,852`; the distinct-nonce rounds started across blocks `95,098,135–95,100,229`.

The same-nonce winner was the only transaction successfully included for that nonce. The distinct-nonce test allowed both transactions to be included, comparing block height first and then the lower Transaction Index when they landed in the same block.

Client hardware, network routes, endpoint deployment, concurrent load, and timestamp implementation can all affect the measurements. We therefore scope these findings to this test window and configuration, and recommend repeating the A/B test from your own production region and transaction path.

## Node-required Feed vs Enterprise Sequencer Feed: BlockRazor arrived first

| Source | Samples | First-arrival rate | P50 | P90 | P95 | P99 | Max |
| --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: |
| BlockRazor Node-required Feed (Package) | 2,919 | 100.00% | 0.000 ms | 0.000 ms | 0.000 ms | 0.000 ms | 0.000 ms |
| bloXroute Sequencer Feed (Enterprise) | 2,919 | 0.00% | 8.264 ms | 17.151 ms | 20.526 ms | 24.520 ms | 46.577 ms |

Across this continuous sample, our relative lead increased from `8.264 ms` at P50 to `24.520 ms` at P99, with a maximum observed difference of `46.577 ms`. These values are paired arrival gaps between the feeds; they do not mean that BlockRazor's full delivery path took zero time.

[BlockRazor Robinhood Chain Node-required Sequencer Feed](https://docs.blockrazor.io/streams/node-stream/robinhood-chain/sequencer-feed) is included with BlockRazor Package and delivers sequential ordered blocks through a compatible local node. This benchmark compares it with the Robinhood Chain Sequencer Feed in bloXroute Enterprise and focuses on when data became client-ready; it does not compare every feature, quota, or commercial term in the two plans.

## Transaction benchmark 1: Same-nonce races

For the same-nonce test, we used one sender and the same nonce while submitting distinguishable transactions through BlockRazor and bloXroute. At most one transaction per round could consume that nonce, making this a test of which route entered Sequencer ordering first.

| Submission route | Winning rounds | Win rate | Average RPC response |
| --- | ---: | ---: | ---: |
| **BlockRazor Ohio relay** | **99** | **99%** | **0.504 ms** |
| bloXroute Robinhood API | 1 | 1% | 13.769 ms |

BlockRazor won 99 of 100 rounds for a `99%` win rate; bloXroute won one round for a `1%` win rate.

BlockRazor's average RPC response was `0.504 ms`, compared with `13.769 ms` for bloXroute, making the latter about 27.3 times higher. The onchain receipt still determines the same-nonce winner; API response time alone does not establish which transaction was ultimately included.

## Transaction benchmark 2: Onchain position with distinct nonces

For the distinct-nonce test, we assigned independent accounts and nonces to the two routes, allowing every transaction to be included. Each round first compared block height; when transactions landed in the same block, it then compared Transaction Index. This is closer to the final onchain position than RPC response time alone.

| Result type | Rounds |
| --- | ---: |
| **BlockRazor landed in an earlier block** | **17** |
| **Same block, BlockRazor had the earlier Index** | **81** |
| bloXroute landed in an earlier block | 1 |
| Same block, bloXroute had the earlier Index | 1 |

Across the 81 same-block rounds in which BlockRazor had the earlier Index:

| Index difference | Rounds |
| --- | ---: |
| **BlockRazor ahead by 1 position** | **47** |
| **BlockRazor ahead by 2 positions** | **18** |
| **BlockRazor ahead by 3 positions** | **12** |
| **BlockRazor ahead by 4 positions** | **3** |
| **BlockRazor ahead by 5 positions** | **1** |

Final onchain position is evaluated in two stages. An earlier block takes precedence over the transaction's Index within that block; Transaction Index is compared only when both transactions land in the same block. Of the 18 cross-block rounds, BlockRazor landed earlier in 17 and bloXroute landed earlier in one.

Of the remaining 82 same-block rounds, BlockRazor had the earlier Index in 81, a same-block Index win rate of `98.78%`. Across these 81 winning samples, the most common result was a one-position lead, recorded in 47 rounds. The median Index advantage was one position, both P90 and P95 were three positions, and the average advantage was `1.68` positions.

Combining block height and same-block Index, BlockRazor achieved the better onchain position in 98 of 100 rounds, compared with two for bloXroute. BlockRazor's average RPC response was `0.447 ms`, versus `12.797 ms` for bloXroute; API response speed and final onchain position remain separate measurements.

## How Feed and Transaction Sending form a complete path

A latency-sensitive trading workflow commonly follows this sequence:

**receive a block → decode and update state → evaluate a strategy → construct a transaction → submit → enter Sequencer ordering**

This benchmark shows a clear BlockRazor lead on both sides of the workflow. Our Feed delivered all 2,919 matched blocks first, while Transaction Sending achieved a `99%` same-nonce win rate and a `98%` distinct-nonce onchain-position win rate. BlockRazor's average RPC response remained below `0.6 ms` in both submission tests, while bloXroute averaged more than `12 ms`.

Earlier data and faster submission can preserve more reaction time, but they do not guarantee a fixed onchain position, transaction success, or strategy profitability. Outcomes still depend on transaction construction, network conditions, endpoint routing, competing traffic, and Sequencer ordering.

### Frequently asked questions

#### Why is BlockRazor shown as 0.000 ms in the Feed table?

This is a relative first-arrival test. The earlier feed for each matched block is assigned `0.000 ms`; it does not mean that the absolute Sequencer-to-client delivery path took zero time.

#### Which products were included in the Feed benchmark?

The BlockRazor side used the Robinhood Chain Node-required Sequencer Feed included with BlockRazor Package, which connects through a compatible local node. The bloXroute side used the Robinhood Chain Sequencer Feed available in bloXroute Enterprise.

#### Was the transaction-submission test one-to-one?

Yes. Each round in this benchmark had two routes: the BlockRazor Ohio relay and the bloXroute Robinhood API. Both tests contained 100 rounds and did not combine multiple bloXroute endpoints.

#### What do the same-nonce and distinct-nonce tests measure?

The same-nonce test makes several transactions compete for one executable nonce and indicates which route entered ordering first. The distinct-nonce test allows all transactions to be included, then compares their final block heights and Transaction Indexes.

## Test BlockRazor in your environment

The results point in the same direction on both sides of the workflow: BlockRazor arrived first on all 2,919 Feed samples, won `99%` of the one-to-one same-nonce races, and achieved the better onchain position in `98%` of the distinct-nonce rounds. BlockRazor averaged `0.504 ms` and `0.447 ms` in RPC response time.

Review our [Node-required Sequencer Feed documentation](https://docs.blockrazor.io/streams/node-stream/robinhood-chain/sequencer-feed) and [Robinhood Chain Transaction Sending documentation](https://docs.blockrazor.io/transaction-submission/transaction-sending/robinhood-chain/eth_sendrawtransaction), then run a simultaneous A/B test against bloXroute from your production region. For teams with stricter latency requirements, we also offer the faster [Node-required Sequencer Feed Ultra](https://docs.blockrazor.io/streams/node-stream/robinhood-chain/sequencer-feed-ultra). For integration support, [contact us](https://discord.com/invite/qqJuwRb8Nh).