Ethereum Hoodi Beacon Chain API Guide (2026)

Hoodi is Ethereum’s current long-term testnet for validator and staking infrastructure. It replaced Holesky after Holesky’s validator set encountered stability issues that made it unsuitable for production-grade testing. If you are building liquid staking protocols, restaking systems, or validator client software, Hoodi’s Beacon Chain API is where you test before mainnet.

This guide covers the Hoodi Beacon REST API: what it exposes, how to authenticate, which endpoints matter for validator and staking workflows, and practical examples. For endpoint details and network specs, see the Ethereum Hoodi Beacon Chain endpoint page.

---

Why Hoodi Beacon API, Not Holesky

Holesky was deprecated because its validator set size caused instability under load. Hoodi was purpose-built to support production-grade infrastructure testing with a stable validator set designed for the long term.

The Beacon Chain API is what makes Hoodi useful for staking teams. You cannot test the full validator lifecycle using only the execution layer. Deposit tracking, activation queue monitoring, validator status transitions, withdrawal flows and slashing event detection all require Beacon API access.

Use the Hoodi Beacon API when you are building:

• Ethereum validator client software (testing deposit, activation, voluntary exit flows)
• Liquid staking protocols (deposit contract interaction, withdrawal credential management, share accounting)
• Restaking systems that need validator status data as input
• Node operator tooling that monitors validator performance across clients
• Any protocol that uses Ethereum finality checkpoints as a security primitive

For general dApp and smart contract testing, use Ethereum Sepolia instead. Hoodi is specifically for consensus layer and staking infrastructure work.

---

Authentication

The Hoodi Beacon API uses header-based authentication. This differs from the Hoodi execution layer endpoint.

Correct: Authorization: Bearer YOUR_KEY in the HTTP header Wrong: ?auth=YOUR_KEY as a query parameter (returns 401 on Beacon endpoints)

Both the execution layer (/rpc/ethereum-hoodi?auth=YOUR_KEY) and the Beacon layer use the same API key from your BoltRPC account. Only the authentication method and base URL differ.

---

Key Beacon API Endpoints

Base URL for the Hoodi Beacon API:

https://eu.endpoints.matrixed.link/rpc/ethereum-hoodi-beacon

All requests use HTTP GET unless noted.

Node sync status

GET /eth/v1/node/syncing

Verify connectivity and confirm the node is at the chain head before sending queries.

Finality checkpoints

GET /eth/v1/beacon/states/{state_id}/finality_checkpoints

Returns the latest justified and finalized epochs. Use finalized for settled state. Use head only when you need the latest unconfirmed slot.

Validator status

GET /eth/v1/beacon/states/head/validators/{validator_index}

Returns status, balance, effective balance, exit epoch and withdrawal credentials for a validator. Status values: pending_queued, pending_initialized, active_ongoing, active_exiting, active_slashed, exited_unslashed, exited_slashed, withdrawal_possible, withdrawal_done.

Validator set (filtered)

GET /eth/v1/beacon/states/head/validators?status=active_ongoing

Returns all validators matching a status filter. Useful for monitoring active set size and tracking queue changes. Avoid querying the full unfiltered set unless necessary.

Block headers

GET /eth/v1/beacon/headers/head

Returns the latest beacon block header with slot, proposer index and parent root. Lighter than fetching a full block when you only need slot position.

Full beacon block

GET /eth/v2/beacon/blocks/{block_id}

Returns the full block including execution payload. Use v2 (not v1) for post-Merge blocks.

---

Connecting Step by Step

curl

Check sync status:

curl "https://eu.endpoints.matrixed.link/rpc/ethereum-hoodi-beacon/eth/v1/node/syncing" \
  -H "Authorization: Bearer YOUR_KEY"

Get finality checkpoints:

curl "https://eu.endpoints.matrixed.link/rpc/ethereum-hoodi-beacon/eth/v1/beacon/states/finalized/finality_checkpoints" \
  -H "Authorization: Bearer YOUR_KEY"

Get validator status:

curl "https://eu.endpoints.matrixed.link/rpc/ethereum-hoodi-beacon/eth/v1/beacon/states/head/validators/5678" \
  -H "Authorization: Bearer YOUR_KEY"

Get current block header:

curl "https://eu.endpoints.matrixed.link/rpc/ethereum-hoodi-beacon/eth/v1/beacon/headers/head" \
  -H "Authorization: Bearer YOUR_KEY"

JavaScript (fetch)

const BASE = "https://eu.endpoints.matrixed.link/rpc/ethereum-hoodi-beacon";
const KEY = "YOUR_KEY";

async function beaconGet(path) {
  const res = await fetch(`${BASE}${path}`, {
    headers: { "Authorization": `Bearer ${KEY}` }
  });
  if (!res.ok) throw new Error(`Beacon API error: ${res.status}`);
  return res.json();
}

// Check node sync status
const sync = await beaconGet("/eth/v1/node/syncing");
console.log("Head slot:", sync.data.head_slot);

// Get finality checkpoint
const checkpoints = await beaconGet(
  "/eth/v1/beacon/states/finalized/finality_checkpoints"
);
console.log("Finalized epoch:", checkpoints.data.finalized.epoch);

// Monitor validator status
const validator = await beaconGet(
  "/eth/v1/beacon/states/head/validators/5678"
);
console.log("Status:", validator.data.status);
console.log("Effective balance:", validator.data.validator.effective_balance, "Gwei");

Python (requests)

import requests

BASE = "https://eu.endpoints.matrixed.link/rpc/ethereum-hoodi-beacon"
HEADERS = {"Authorization": "Bearer YOUR_KEY"}

def beacon_get(path):
    resp = requests.get(f"{BASE}{path}", headers=HEADERS, timeout=10)
    resp.raise_for_status()
    return resp.json()

# Get current slot
header = beacon_get("/eth/v1/beacon/headers/head")
slot = header["data"]["header"]["message"]["slot"]
print(f"Current Hoodi slot: {slot}")

# Track finality
checkpoints = beacon_get(
    "/eth/v1/beacon/states/finalized/finality_checkpoints"
)
finalized_epoch = checkpoints["data"]["finalized"]["epoch"]
print(f"Finalized epoch: {finalized_epoch}")

---

Validator Lifecycle Testing on Hoodi

Hoodi’s deposit contract mirrors the Ethereum mainnet deposit contract. This lets you test the full validator lifecycle end to end: deposit submission through the execution layer, activation tracking through the Beacon API, voluntary exit and final withdrawal.

Track validator activation after deposit:

// Poll at epoch boundaries (every ~6.4 minutes) until status becomes active_ongoing
async function waitForActivation(validatorIndex) {
  while (true) {
    const data = await beaconGet(
      `/eth/v1/beacon/states/head/validators/${validatorIndex}`
    );
    const status = data.data.status;
    console.log(`Validator ${validatorIndex} status: ${status}`);

    if (status === "active_ongoing") {
      console.log("Validator is active");
      break;
    }

    // Wait approximately one epoch (6.4 minutes) before polling again
    await new Promise(resolve => setTimeout(resolve, 384000));
  }
}

Monitor voluntary exit progression:

async function trackExit(validatorIndex) {
  const data = await beaconGet(
    `/eth/v1/beacon/states/head/validators/${validatorIndex}`
  );

  const validator = data.data.validator;
  const currentSlot = parseInt(
    (await beaconGet("/eth/v1/beacon/headers/head"))
      .data.header.message.slot
  );
  const slotsPerEpoch = 32;
  const currentEpoch = Math.floor(currentSlot / slotsPerEpoch);

  console.log(`Status: ${data.data.status}`);
  console.log(`Exit epoch: ${validator.exit_epoch}`);
  console.log(`Withdrawable epoch: ${validator.withdrawable_epoch}`);
  console.log(`Epochs until withdrawable: ${validator.withdrawable_epoch - currentEpoch}`);
}

---

Liquid Staking Protocol Testing

Liquid staking protocols need Beacon API data to track the validators they manage. On Hoodi, you can test the full protocol lifecycle with a manageable validator set.

Key data points liquid staking protocols read from the Beacon API:

• Activation queue depth: GET /eth/v1/beacon/states/head/validators?status=pending_queued returns the queue. Queue length determines when deposited ETH becomes active.
• Effective balance: Used to calculate staking rewards. Returned in validator.effective_balance (in Gwei).
• Exit queue: Active validators with exit_epoch set are exiting. withdrawal_possible and withdrawal_done statuses indicate completed exits.
• Slashing events: active_slashed and exited_slashed statuses identify slashed validators for protocol-level handling.

---

Common Issues

401 on every request Beacon endpoints require Authorization: Bearer YOUR_KEY in the HTTP header. Using ?auth=YOUR_KEY in the query string returns a 401. This is the most common issue when connecting for the first time.

v1 block endpoint missing execution payload /eth/v1/beacon/blocks/{id} does not include the execution payload on post-Merge blocks. Use /eth/v2/beacon/blocks/{id} to get the full block.

Large response from full validator set query Querying /eth/v1/beacon/states/head/validators without a filter returns every validator. On Hoodi this is manageable, but always use the ?status= filter in production patterns. For monitoring specific validators, query by index directly.

Using head for bridge finality gates When using finality checkpoints as a security signal (such as in bridge contracts), always query finalized state. The head state can include slots that are later reorganized during missed attestation periods.

---

FAQ

What is the Hoodi Beacon Chain API URL? The BoltRPC endpoint is https://eu.endpoints.matrixed.link/rpc/ethereum-hoodi-beacon. Authenticate with Authorization: Bearer YOUR_KEY in the request header. The same API key works for both the Hoodi execution layer and the Hoodi Beacon API.

Does the Hoodi Beacon API support WebSocket? No. The Ethereum Beacon Chain API is a REST API only. All queries use standard HTTP GET requests. There is no WebSocket interface on the consensus layer.

Why is Hoodi better than Holesky for validator testing? Holesky was deprecated after its validator set caused instability. Hoodi was designed from the start for long-term stability with a validator set sized for production-grade infrastructure testing. The Hoodi deposit contract mirrors mainnet, so the full deposit-to-withdrawal cycle can be tested end to end.

Can I test restaking protocols on Hoodi? Yes. Restaking protocols that use Ethereum validator data as input can test against Hoodi’s Beacon API. Validator status, effective balance and withdrawal credential data needed for restaking protocol logic are all available through the standard Beacon API endpoints documented in this guide.

---

---

Ready to test staking infrastructure on Hoodi? Start your free 2-week trial at trial.boltrpc.io. Same API key as your Hoodi execution endpoint. No credit card required.