Beacon API

The Beacon API is a RESTful interface that provides programmatic access to an Ethereum Beacon Node, the software client that participates in the network's proof-of-stake consensus. It allows developers, validators, and analytical tools to query real-time data about the Beacon Chain, including validator statuses, committee assignments, block attestations, and the state of the consensus protocol. This API is distinct from the Execution API (formerly ETH1.0) which handles transaction and smart contract execution.

Key endpoints of the Beacon API include fetching block headers, validator balances, and sync committee data, which are essential for building staking dashboards, block explorers, and network monitoring tools. For example, a staking pool service uses this API to monitor the performance and health of its validator set, checking for attestation effectiveness and slashing conditions. The API follows a specification defined by Ethereum client teams to ensure consistency across different implementations like Prysm, Lighthouse, and Teku.

The Beacon API is fundamental to the post-Merge Ethereum architecture, acting as the primary window into the consensus layer. It enables the separation of concerns between the consensus client (which runs the Beacon API) and the execution client (which runs the Execution API). This design allows for modularity and specialization, where applications can query finalized block hashes from the Beacon API and then fetch transaction details from the Execution API to reconstruct a complete view of the chain.

The Beacon API is a RESTful interface that provides programmatic access to an Ethereum consensus client, enabling applications to query the state of the Beacon Chain and submit new blocks and attestations. It operates on a client-server model where the consensus client (like Prysm or Lighthouse) runs the API server, exposing endpoints for network, node, validator, and beacon state data. This API is the primary mechanism for validator clients to receive their duties—such as when to propose a block or create an attestation—and to broadcast their signed contributions back to the network, forming the backbone of Ethereum's proof-of-stake consensus.

At its core, the API facilitates the validator lifecycle. A validator client queries endpoints like /eth/v1/validator/duties/proposer to learn its assigned slot for block proposal. When the time comes, it requests a new block template from /eth/v1/validator/blocks/{slot}. After constructing and signing the block, it submits it via a POST request to /eth/v1/beacon/blocks. Similarly, for attestation duties, the client queries for assignments and submits signed attestations to the /eth/v1/beacon/pool/attestations endpoint. This request-response cycle occurs continuously, synchronized to the 12-second slot intervals of the Beacon Chain.

The API is defined by a comprehensive OpenAPI specification, ensuring standardization across different client implementations. Key specification versions include the standard Eth Beacon APIs and the Builder APIs used for MEV-Boost and proposer-builder separation. This standardization allows validator software to be client-agnostic. The API uses JSON-RPC over HTTP, with strict adherence to consensus-layer data structures like the BeaconBlock and SignedBeaconBlock. Security is paramount; sensitive endpoints, especially those used for block proposal, often require authentication via Bearer tokens or run on protected localhost ports to prevent unauthorized access and submission.

Developers and node operators interact with the Beacon API for monitoring, debugging, and automation. Common use cases include querying the sync status via /eth/v1/node/syncing, fetching validator performance metrics, or inspecting the chain's finality with /eth/v1/beacon/states/finality_checkpoints. The API also exposes the Weak Subjectivity checkpoint and genesis data, which are critical for initializing a node. For block builders and relays in the MEV supply chain, the dedicated Builder API endpoints (under /eth/v1/builder) enable the submission of execution payloads for inclusion in proposed blocks, decoupling block construction from proposal.

The Beacon API is a standardized JSON-RPC interface defined by the Ethereum Foundation that allows an execution client (like Geth or Nethermind) to communicate with a consensus client (like Lighthouse or Prysm). In a modular client architecture, these two software components run separately, and the Beacon API is the critical communication bridge between them. It enables the execution client to request essential data from the consensus layer, such as the current state of the beacon chain, validator duties, and proposed blocks, which are necessary for validating and executing transactions.

This separation of concerns is fundamental to Ethereum's post-merge architecture. The execution client handles transaction pool management, smart contract execution, and state management, while the consensus client is responsible for block proposal, attestation, and following the Proof-of-Stake protocol. The Beacon API standardizes their interaction, ensuring interoperability between any compliant execution and consensus client pair. Key endpoints include eth_getBlockByNumber for retrieving block data and engine_newPayloadV1 for submitting execution payloads for inclusion in a beacon block.

For node operators, this modular setup with a defined API allows for greater flexibility and resilience. They can mix and match different client software, reducing systemic risk if a bug affects one client implementation. The API also defines the Engine API, a secure port for privileged communication used specifically for block proposal and validation. This clear interface is what enables the merge of the original Ethereum Mainnet with the Beacon Chain, allowing the network to transition to Proof-of-Stake while maintaining the existing execution environment.