diff --git a/crates/node/builder/src/launch/common.rs b/crates/node/builder/src/launch/common.rs
index 83ba10e213044..ac2339fa6cfc0 100644
--- a/crates/node/builder/src/launch/common.rs
+++ b/crates/node/builder/src/launch/common.rs
@@ -939,7 +939,6 @@ where
                     EthApiClient::<
                         alloy_rpc_types::Transaction,
                         alloy_rpc_types::Block,
-                        alloy_rpc_types::Header,
                         alloy_rpc_types::Receipt,
                     >::chain_id(&client)
                     .await
diff --git a/crates/rpc/rpc-builder/src/lib.rs b/crates/rpc/rpc-builder/src/lib.rs
index 6ee3f9fd0c85e..385b92af3d0b0 100644
--- a/crates/rpc/rpc-builder/src/lib.rs
+++ b/crates/rpc/rpc-builder/src/lib.rs
@@ -194,7 +194,6 @@ use reth_rpc::{
 use reth_rpc_api::servers::*;
 use reth_rpc_eth_api::{
     helpers::{Call, EthApiSpec, EthTransactions, LoadPendingBlock, TraceExt},
-    types::RpcHeader,
     EthApiServer, EthApiTypes, FullEthApiServer, RpcBlock, RpcReceipt, RpcTransaction,
 };
 use reth_rpc_eth_types::{EthConfig, EthStateCache, EthSubscriptionIdProvider};
@@ -1073,7 +1072,6 @@ where
     EthApi: EthApiServer<
             RpcTransaction<EthApi::NetworkTypes>,
             RpcBlock<EthApi::NetworkTypes>,
-            RpcHeader<EthApi::NetworkTypes>,
             RpcReceipt<EthApi::NetworkTypes>,
         > + EthApiTypes,
     BlockExecutor: BlockExecutorProvider,
diff --git a/crates/rpc/rpc-builder/tests/it/http.rs b/crates/rpc/rpc-builder/tests/it/http.rs
index a5e2e61f236ee..89aafce9f36fb 100644
--- a/crates/rpc/rpc-builder/tests/it/http.rs
+++ b/crates/rpc/rpc-builder/tests/it/http.rs
@@ -173,24 +173,16 @@ where
     .unwrap();
 
     // Implemented
-    EthApiClient::<Transaction, Block, Header, Receipt>::protocol_version(client).await.unwrap();
-    EthApiClient::<Transaction, Block, Header, Receipt>::chain_id(client).await.unwrap();
-    EthApiClient::<Transaction, Block, Header, Receipt>::accounts(client).await.unwrap();
-    EthApiClient::<Transaction, Block, Header, Receipt>::get_account(
-        client,
-        address,
-        block_number.into(),
-    )
-    .await
-    .unwrap();
-    EthApiClient::<Transaction, Block, Header, Receipt>::block_number(client).await.unwrap();
-    EthApiClient::<Transaction, Block, Header, Receipt>::get_code(client, address, None)
-        .await
-        .unwrap();
-    EthApiClient::<Transaction, Block, Header, Receipt>::send_raw_transaction(client, tx)
+    EthApiClient::<Transaction, Block, Receipt>::protocol_version(client).await.unwrap();
+    EthApiClient::<Transaction, Block, Receipt>::chain_id(client).await.unwrap();
+    EthApiClient::<Transaction, Block, Receipt>::accounts(client).await.unwrap();
+    EthApiClient::<Transaction, Block, Receipt>::get_account(client, address, block_number.into())
         .await
         .unwrap();
-    EthApiClient::<Transaction, Block, Header, Receipt>::fee_history(
+    EthApiClient::<Transaction, Block, Receipt>::block_number(client).await.unwrap();
+    EthApiClient::<Transaction, Block, Receipt>::get_code(client, address, None).await.unwrap();
+    EthApiClient::<Transaction, Block, Receipt>::send_raw_transaction(client, tx).await.unwrap();
+    EthApiClient::<Transaction, Block, Receipt>::fee_history(
         client,
         U64::from(0),
         block_number,
@@ -198,13 +190,11 @@ where
     )
     .await
     .unwrap();
-    EthApiClient::<Transaction, Block, Header, Receipt>::balance(client, address, None)
-        .await
-        .unwrap();
-    EthApiClient::<Transaction, Block, Header, Receipt>::transaction_count(client, address, None)
+    EthApiClient::<Transaction, Block, Receipt>::balance(client, address, None).await.unwrap();
+    EthApiClient::<Transaction, Block, Receipt>::transaction_count(client, address, None)
         .await
         .unwrap();
-    EthApiClient::<Transaction, Block, Header, Receipt>::storage_at(
+    EthApiClient::<Transaction, Block, Receipt>::storage_at(
         client,
         address,
         U256::default().into(),
@@ -212,79 +202,64 @@ where
     )
     .await
     .unwrap();
-    EthApiClient::<Transaction, Block, Header, Receipt>::block_by_hash(client, hash, false)
+    EthApiClient::<Transaction, Block, Receipt>::block_by_hash(client, hash, false).await.unwrap();
+    EthApiClient::<Transaction, Block, Receipt>::block_by_number(client, block_number, false)
         .await
         .unwrap();
-    EthApiClient::<Transaction, Block, Header, Receipt>::block_by_number(
+    EthApiClient::<Transaction, Block, Receipt>::block_transaction_count_by_number(
         client,
         block_number,
-        false,
     )
     .await
     .unwrap();
-    EthApiClient::<Transaction, Block, Header, Receipt>::block_transaction_count_by_number(
-        client,
-        block_number,
-    )
-    .await
-    .unwrap();
-    EthApiClient::<Transaction, Block, Header, Receipt>::block_transaction_count_by_hash(
-        client, hash,
-    )
-    .await
-    .unwrap();
-    EthApiClient::<Transaction, Block, Header, Receipt>::block_uncles_count_by_hash(client, hash)
+    EthApiClient::<Transaction, Block, Receipt>::block_transaction_count_by_hash(client, hash)
         .await
         .unwrap();
-    EthApiClient::<Transaction, Block, Header, Receipt>::block_uncles_count_by_number(
-        client,
-        block_number,
-    )
-    .await
-    .unwrap();
-    EthApiClient::<Transaction, Block, Header, Receipt>::uncle_by_block_hash_and_index(
-        client, hash, index,
-    )
-    .await
-    .unwrap();
-    EthApiClient::<Transaction, Block, Header, Receipt>::uncle_by_block_number_and_index(
+    EthApiClient::<Transaction, Block, Receipt>::block_uncles_count_by_hash(client, hash)
+        .await
+        .unwrap();
+    EthApiClient::<Transaction, Block, Receipt>::block_uncles_count_by_number(client, block_number)
+        .await
+        .unwrap();
+    EthApiClient::<Transaction, Block, Receipt>::uncle_by_block_hash_and_index(client, hash, index)
+        .await
+        .unwrap();
+    EthApiClient::<Transaction, Block, Receipt>::uncle_by_block_number_and_index(
         client,
         block_number,
         index,
     )
     .await
     .unwrap();
-    EthApiClient::<Transaction, Block, Header, Receipt>::sign(client, address, bytes.clone())
+    EthApiClient::<Transaction, Block, Receipt>::sign(client, address, bytes.clone())
         .await
         .unwrap_err();
-    EthApiClient::<Transaction, Block, Header, Receipt>::sign_typed_data(
-        client, address, typed_data,
-    )
-    .await
-    .unwrap_err();
-    EthApiClient::<Transaction, Block, Header, Receipt>::transaction_by_hash(client, tx_hash)
+    EthApiClient::<Transaction, Block, Receipt>::sign_typed_data(client, address, typed_data)
+        .await
+        .unwrap_err();
+    EthApiClient::<Transaction, Block, Receipt>::transaction_by_hash(client, tx_hash)
         .await
         .unwrap();
-    EthApiClient::<Transaction, Block, Header, Receipt>::transaction_by_block_hash_and_index(
+    EthApiClient::<Transaction, Block, Receipt>::transaction_by_block_hash_and_index(
         client, hash, index,
     )
     .await
     .unwrap();
-    EthApiClient::<Transaction, Block, Header, Receipt>::transaction_by_block_number_and_index(
+    EthApiClient::<Transaction, Block, Receipt>::transaction_by_block_number_and_index(
         client,
         block_number,
         index,
     )
     .await
     .unwrap();
-    EthApiClient::<Transaction, Block, Header, Receipt>::create_access_list(
+    EthApiClient::<Transaction, Block, Receipt>::create_access_list(
         client,
         call_request.clone(),
         Some(block_number.into()),
     )
     .await
     .unwrap();
-    EthApiClient::<Transaction, Block, Header, Receipt>::estimate_gas(
+    EthApiClient::<Transaction, Block, Receipt>::estimate_gas(
         client,
         call_request.clone(),
         Some(block_number.into()),
@@ -292,7 +267,7 @@ where
     )
     .await
     .unwrap();
-    EthApiClient::<Transaction, Block, Header, Receipt>::call(
+    EthApiClient::<Transaction, Block, Receipt>::call(
         client,
         call_request.clone(),
         Some(block_number.into()),
@@ -301,41 +276,38 @@ where
     )
     .await
     .unwrap();
-    EthApiClient::<Transaction, Block, Header, Receipt>::syncing(client).await.unwrap();
-    EthApiClient::<Transaction, Block, Header, Receipt>::send_transaction(
-        client,
-        transaction_request,
-    )
-    .await
-    .unwrap_err();
-    EthApiClient::<Transaction, Block, Header, Receipt>::hashrate(client).await.unwrap();
-    EthApiClient::<Transaction, Block, Header, Receipt>::submit_hashrate(
+    EthApiClient::<Transaction, Block, Receipt>::syncing(client).await.unwrap();
+    EthApiClient::<Transaction, Block, Receipt>::send_transaction(client, transaction_request)
+        .await
+        .unwrap_err();
+    EthApiClient::<Transaction, Block, Receipt>::hashrate(client).await.unwrap();
+    EthApiClient::<Transaction, Block, Receipt>::submit_hashrate(
         client,
         U256::default(),
         B256::default(),
     )
     .await
     .unwrap();
-    EthApiClient::<Transaction, Block, Header, Receipt>::gas_price(client).await.unwrap_err();
-    EthApiClient::<Transaction, Block, Header, Receipt>::max_priority_fee_per_gas(client)
+    EthApiClient::<Transaction, Block, Receipt>::gas_price(client).await.unwrap_err();
+    EthApiClient::<Transaction, Block, Receipt>::max_priority_fee_per_gas(client)
         .await
         .unwrap_err();
-    EthApiClient::<Transaction, Block, Header, Receipt>::get_proof(client, address, vec![], None)
+    EthApiClient::<Transaction, Block, Receipt>::get_proof(client, address, vec![], None)
         .await
         .unwrap();
 
     // Unimplemented
     assert!(is_unimplemented(
-        EthApiClient::<Transaction, Block, Header, Receipt>::author(client).await.err().unwrap()
+        EthApiClient::<Transaction, Block, Receipt>::author(client).await.err().unwrap()
     ));
     assert!(is_unimplemented(
-        EthApiClient::<Transaction, Block, Header, Receipt>::is_mining(client).await.err().unwrap()
+        EthApiClient::<Transaction, Block, Receipt>::is_mining(client).await.err().unwrap()
     ));
     assert!(is_unimplemented(
-        EthApiClient::<Transaction, Block, Header, Receipt>::get_work(client).await.err().unwrap()
+        EthApiClient::<Transaction, Block, Receipt>::get_work(client).await.err().unwrap()
     ));
     assert!(is_unimplemented(
-        EthApiClient::<Transaction, Block, Header, Receipt>::submit_work(
+        EthApiClient::<Transaction, Block, Receipt>::submit_work(
             client,
             B64::default(),
             B256::default(),
@@ -346,13 +318,10 @@ where
         .unwrap()
     ));
     assert!(is_unimplemented(
-        EthApiClient::<Transaction, Block, Header, Receipt>::sign_transaction(
-            client,
-            call_request.clone()
-        )
-        .await
-        .err()
-        .unwrap()
+        EthApiClient::<Transaction, Block, Receipt>::sign_transaction(client, call_request.clone())
+            .await
+            .err()
+            .unwrap()
     ));
 }
 
diff --git a/crates/rpc/rpc-builder/tests/it/middleware.rs b/crates/rpc/rpc-builder/tests/it/middleware.rs
index 780daf4de1706..0e2186e56eeb6 100644
--- a/crates/rpc/rpc-builder/tests/it/middleware.rs
+++ b/crates/rpc/rpc-builder/tests/it/middleware.rs
@@ -1,5 +1,5 @@
 use crate::utils::{test_address, test_rpc_builder};
-use alloy_rpc_types_eth::{Block, Header, Receipt, Transaction};
+use alloy_rpc_types_eth::{Block, Receipt, Transaction};
 use jsonrpsee::{
     server::{middleware::rpc::RpcServiceT, RpcServiceBuilder},
     types::Request,
@@ -75,7 +75,7 @@ async fn test_rpc_middleware() {
         .unwrap();
 
     let client = handle.http_client().unwrap();
-    EthApiClient::<Transaction, Block, Header, Receipt>::protocol_version(&client).await.unwrap();
+    EthApiClient::<Transaction, Block, Receipt>::protocol_version(&client).await.unwrap();
     let count = mylayer.count.load(Ordering::Relaxed);
     assert_eq!(count, 1);
 }
diff --git a/crates/rpc/rpc-eth-api/src/core.rs b/crates/rpc/rpc-eth-api/src/core.rs
index 38d9b3ae97eef..66bc5a44d2db9 100644
--- a/crates/rpc/rpc-eth-api/src/core.rs
+++ b/crates/rpc/rpc-eth-api/src/core.rs
@@ -8,8 +8,8 @@ use alloy_rpc_types::{
     serde_helpers::JsonStorageKey,
     simulate::{SimulatePayload, SimulatedBlock},
     state::{EvmOverrides, StateOverride},
-    BlockOverrides, Bundle, EIP1186AccountProofResponse, EthCallResponse, FeeHistory, Index,
-    StateContext, SyncStatus, Work,
+    BlockOverrides, Bundle, EIP1186AccountProofResponse, EthCallResponse, FeeHistory, Header,
+    Index, StateContext, SyncStatus, Work,
 };
 use alloy_rpc_types_eth::transaction::TransactionRequest;
 use jsonrpsee::{core::RpcResult, proc_macros::rpc};
@@ -19,7 +19,6 @@ use tracing::trace;
 
 use crate::{
     helpers::{EthApiSpec, EthBlocks, EthCall, EthFees, EthState, EthTransactions, FullEthApi},
-    types::RpcHeader,
     RpcBlock, RpcReceipt, RpcTransaction,
 };
 
@@ -29,7 +28,6 @@ pub trait FullEthApiServer:
     EthApiServer<
         RpcTransaction<Self::NetworkTypes>,
         RpcBlock<Self::NetworkTypes>,
-        RpcHeader<Self::NetworkTypes>,
         RpcReceipt<Self::NetworkTypes>,
     > + FullEthApi
     + Clone
@@ -40,7 +38,6 @@ impl<T> FullEthApiServer for T where
     T: EthApiServer<
             RpcTransaction<T::NetworkTypes>,
             RpcBlock<T::NetworkTypes>,
-            RpcHeader<T::NetworkTypes>,
             RpcReceipt<T::NetworkTypes>,
         > + FullEthApi
         + Clone
@@ -50,7 +47,7 @@ impl<T> FullEthApiServer for T where
 /// Eth rpc interface: <https://ethereum.github.io/execution-apis/api-documentation/>
 #[cfg_attr(not(feature = "client"), rpc(server, namespace = "eth"))]
 #[cfg_attr(feature = "client", rpc(server, client, namespace = "eth"))]
-pub trait EthApi<T: RpcObject, B: RpcObject, H: RpcObject, R: RpcObject> {
+pub trait EthApi<T: RpcObject, B: RpcObject, R: RpcObject> {
     /// Returns the protocol version encoded as a string.
     #[method(name = "protocolVersion")]
     async fn protocol_version(&self) -> RpcResult<U64>;
@@ -204,11 +201,11 @@ pub trait EthApi<T: RpcObject, B: RpcObject, H: RpcObject, R: RpcObject> {
 
     /// Returns the block's header at given number.
     #[method(name = "getHeaderByNumber")]
-    async fn header_by_number(&self, hash: BlockNumberOrTag) -> RpcResult<Option<H>>;
+    async fn header_by_number(&self, hash: BlockNumberOrTag) -> RpcResult<Option<Header>>;
 
     /// Returns the block's header at given hash.
     #[method(name = "getHeaderByHash")]
-    async fn header_by_hash(&self, hash: B256) -> RpcResult<Option<H>>;
+    async fn header_by_hash(&self, hash: B256) -> RpcResult<Option<Header>>;
 
     /// `eth_simulateV1` executes an arbitrary number of transactions on top of the requested state.
     /// The transactions are packed into individual blocks. Overrides can be provided.
@@ -369,7 +366,6 @@ impl<T>
     EthApiServer<
         RpcTransaction<T::NetworkTypes>,
         RpcBlock<T::NetworkTypes>,
-        RpcHeader<T::NetworkTypes>,
         RpcReceipt<T::NetworkTypes>,
     > for T
 where
@@ -611,16 +607,13 @@ where
     }
 
     /// Handler for: `eth_getHeaderByNumber`
-    async fn header_by_number(
-        &self,
-        block_number: BlockNumberOrTag,
-    ) -> RpcResult<Option<RpcHeader<T::NetworkTypes>>> {
+    async fn header_by_number(&self, block_number: BlockNumberOrTag) -> RpcResult<Option<Header>> {
         trace!(target: "rpc::eth", ?block_number, "Serving eth_getHeaderByNumber");
         Ok(EthBlocks::rpc_block_header(self, block_number.into()).await?)
     }
 
     /// Handler for: `eth_getHeaderByHash`
-    async fn header_by_hash(&self, hash: B256) -> RpcResult<Option<RpcHeader<T::NetworkTypes>>> {
+    async fn header_by_hash(&self, hash: B256) -> RpcResult<Option<Header>> {
         trace!(target: "rpc::eth", ?hash, "Serving eth_getHeaderByHash");
         Ok(EthBlocks::rpc_block_header(self, hash.into()).await?)
     }
diff --git a/crates/rpc/rpc-eth-api/src/helpers/block.rs b/crates/rpc/rpc-eth-api/src/helpers/block.rs
index 3cf46b7fea7cf..090f2ab0d562c 100644
--- a/crates/rpc/rpc-eth-api/src/helpers/block.rs
+++ b/crates/rpc/rpc-eth-api/src/helpers/block.rs
@@ -8,9 +8,7 @@ use reth_primitives::{BlockId, Receipt, SealedBlock, SealedBlockWithSenders};
 use reth_provider::{BlockIdReader, BlockReader, BlockReaderIdExt, HeaderProvider};
 use reth_rpc_types_compat::block::from_block;
 
-use crate::{
-    node::RpcNodeCoreExt, types::RpcHeader, FromEthApiError, FullEthApiTypes, RpcBlock, RpcReceipt,
-};
+use crate::{node::RpcNodeCoreExt, FromEthApiError, FullEthApiTypes, RpcBlock, RpcReceipt};
 
 use super::{LoadPendingBlock, LoadReceipt, SpawnBlocking};
 
@@ -26,7 +24,7 @@ pub trait EthBlocks: LoadBlock {
     fn rpc_block_header(
         &self,
         block_id: BlockId,
-    ) -> impl Future<Output = Result<Option<RpcHeader<Self::NetworkTypes>>, Self::Error>> + Send
+    ) -> impl Future<Output = Result<Option<Header>, Self::Error>> + Send
     where
         Self: FullEthApiTypes,
     {
@@ -194,7 +192,7 @@ pub trait EthBlocks: LoadBlock {
                 let block = Block::uncle_from_header(uncle);
                 Block {
                     header: Header {
-                        inner: block.header.inner.into(),
+                        inner: block.header.inner,
                         size: block.header.size,
                         total_difficulty: block.header.total_difficulty,
                         hash: block.header.hash,
diff --git a/crates/rpc/rpc-eth-api/src/types.rs b/crates/rpc/rpc-eth-api/src/types.rs
index a8dbb1eaab4a4..620f4523d21a9 100644
--- a/crates/rpc/rpc-eth-api/src/types.rs
+++ b/crates/rpc/rpc-eth-api/src/types.rs
@@ -2,12 +2,11 @@
 
 use std::{
     error::Error,
-    fmt::{self, Debug},
+    fmt::{self},
 };
 
 use alloy_network::Network;
 use alloy_rpc_types::Block;
-use jsonrpsee::core::{DeserializeOwned, Serialize};
 use reth_rpc_types_compat::TransactionCompat;
 
 use crate::{AsEthApiError, FromEthApiError, FromEvmError};
@@ -23,18 +22,7 @@ pub trait EthApiTypes: Send + Sync + Clone {
         + Send
         + Sync;
     /// Blockchain primitive types, specific to network, e.g. block and transaction.
-    type NetworkTypes: Network<
-        Header: Send
-                    + Sync
-                    + Clone
-                    + Debug
-                    + Unpin
-                    + From<alloy_consensus::Header>
-                    + Serialize
-                    + DeserializeOwned
-                    + 'static,
-        HeaderResponse = alloy_rpc_types::Header<<Self::NetworkTypes as Network>::Header>,
-    >;
+    type NetworkTypes: Network<HeaderResponse = alloy_rpc_types::Header>;
     /// Conversion methods for transaction RPC type.
     type TransactionCompat: Send + Sync + Clone + fmt::Debug;
 
@@ -45,11 +33,8 @@ pub trait EthApiTypes: Send + Sync + Clone {
 /// Adapter for network specific transaction type.
 pub type RpcTransaction<T> = <T as Network>::TransactionResponse;
 
-/// Adapter for network specific header type.
-pub type RpcHeader<T> = <T as Network>::HeaderResponse;
-
 /// Adapter for network specific block type.
-pub type RpcBlock<T> = Block<RpcTransaction<T>, RpcHeader<T>>;
+pub type RpcBlock<T> = Block<RpcTransaction<T>, <T as Network>::HeaderResponse>;
 
 /// Adapter for network specific receipt type.
 pub type RpcReceipt<T> = <T as Network>::ReceiptResponse;
diff --git a/crates/rpc/rpc-eth-types/src/simulate.rs b/crates/rpc/rpc-eth-types/src/simulate.rs
index 95cce2af7461e..95111931619d9 100644
--- a/crates/rpc/rpc-eth-types/src/simulate.rs
+++ b/crates/rpc/rpc-eth-types/src/simulate.rs
@@ -1,9 +1,9 @@
 //! Utilities for serving `eth_simulateV1`
 
-use alloy_consensus::{BlockHeader, Transaction as _, TxEip4844Variant, TxType, TypedTransaction};
+use alloy_consensus::{Transaction as _, TxEip4844Variant, TxType, TypedTransaction};
 use alloy_rpc_types::{
     simulate::{SimCallResult, SimulateError, SimulatedBlock},
-    Block, BlockTransactionsKind, Header,
+    Block, BlockTransactionsKind,
 };
 use alloy_rpc_types_eth::transaction::TransactionRequest;
 use jsonrpsee_types::ErrorObject;
@@ -170,7 +170,7 @@ where
 
 /// Handles outputs of the calls execution and builds a [`SimulatedBlock`].
 #[expect(clippy::complexity)]
-pub fn build_block<T: TransactionCompat, H: BlockHeader + From<alloy_consensus::Header>>(
+pub fn build_block<T: TransactionCompat>(
     results: Vec<(Address, ExecutionResult)>,
     transactions: Vec<TransactionSigned>,
     block_env: &BlockEnv,
@@ -179,7 +179,7 @@ pub fn build_block<T: TransactionCompat, H: BlockHeader + From<alloy_consensus::
     full_transactions: bool,
     db: &CacheDB<StateProviderDatabase<StateProviderTraitObjWrapper<'_>>>,
     tx_resp_builder: &T,
-) -> Result<SimulatedBlock<Block<T::Transaction, Header<H>>>, EthApiError> {
+) -> Result<SimulatedBlock<Block<T::Transaction>>, EthApiError> {
     let mut calls: Vec<SimCallResult> = Vec::with_capacity(results.len());
     let mut senders = Vec::with_capacity(results.len());
     let mut receipts = Vec::with_capacity(results.len());
@@ -305,6 +305,6 @@ pub fn build_block<T: TransactionCompat, H: BlockHeader + From<alloy_consensus::
     let txs_kind =
         if full_transactions { BlockTransactionsKind::Full } else { BlockTransactionsKind::Hashes };
 
-    let block = from_block::<T, H>(block, total_difficulty, txs_kind, None, tx_resp_builder)?;
+    let block = from_block::<T>(block, total_difficulty, txs_kind, None, tx_resp_builder)?;
     Ok(SimulatedBlock { inner: block, calls })
 }
diff --git a/crates/rpc/rpc-testing-util/src/debug.rs b/crates/rpc/rpc-testing-util/src/debug.rs
index e1574552699db..97fe008fa97c1 100644
--- a/crates/rpc/rpc-testing-util/src/debug.rs
+++ b/crates/rpc/rpc-testing-util/src/debug.rs
@@ -7,7 +7,7 @@ use std::{
 };
 
 use alloy_primitives::{TxHash, B256};
-use alloy_rpc_types::{Block, Header, Transaction};
+use alloy_rpc_types::{Block, Transaction};
 use alloy_rpc_types_eth::transaction::TransactionRequest;
 use alloy_rpc_types_trace::{
     common::TraceResult,
@@ -77,7 +77,7 @@ pub trait DebugApiExt {
 
 impl<T> DebugApiExt for T
 where
-    T: EthApiClient<Transaction, Block, Header, Receipt> + DebugApiClient + Sync,
+    T: EthApiClient<Transaction, Block, Receipt> + DebugApiClient + Sync,
 {
     type Provider = T;
 
diff --git a/crates/rpc/rpc-testing-util/tests/it/trace.rs b/crates/rpc/rpc-testing-util/tests/it/trace.rs
index 6077d773839ee..b0fccefbb464c 100644
--- a/crates/rpc/rpc-testing-util/tests/it/trace.rs
+++ b/crates/rpc/rpc-testing-util/tests/it/trace.rs
@@ -1,7 +1,7 @@
 //! Integration tests for the trace API.
 
 use alloy_primitives::map::HashSet;
-use alloy_rpc_types::{Block, Header, Transaction};
+use alloy_rpc_types::{Block, Transaction};
 use alloy_rpc_types_trace::{
     filter::TraceFilter, parity::TraceType, tracerequest::TraceCallRequest,
 };
@@ -113,7 +113,7 @@ async fn debug_trace_block_entire_chain() {
 
     let client = HttpClientBuilder::default().build(url).unwrap();
     let current_block: u64 =
-        <HttpClient as EthApiClient<Transaction, Block, Header, Receipt>>::block_number(&client)
+        <HttpClient as EthApiClient<Transaction, Block, Receipt>>::block_number(&client)
             .await
             .unwrap()
             .try_into()
diff --git a/crates/rpc/rpc-types-compat/src/block.rs b/crates/rpc/rpc-types-compat/src/block.rs
index 17133ada9c534..c56c51f5ad2c1 100644
--- a/crates/rpc/rpc-types-compat/src/block.rs
+++ b/crates/rpc/rpc-types-compat/src/block.rs
@@ -1,6 +1,6 @@
 //! Compatibility functions for rpc `Block` type.
 
-use alloy_consensus::{BlockHeader, Sealed};
+use alloy_consensus::Sealed;
 use alloy_primitives::{B256, U256};
 use alloy_rlp::Encodable;
 use alloy_rpc_types::{
@@ -14,19 +14,19 @@ use crate::{transaction::from_recovered_with_block_context, TransactionCompat};
 /// [`BlockTransactionsKind`]
 ///
 /// If a `block_hash` is provided, then this is used, otherwise the block hash is computed.
-pub fn from_block<T: TransactionCompat, H: BlockHeader + From<alloy_consensus::Header>>(
+pub fn from_block<T: TransactionCompat>(
     block: BlockWithSenders,
     total_difficulty: U256,
     kind: BlockTransactionsKind,
     block_hash: Option<B256>,
     tx_resp_builder: &T,
-) -> Result<Block<T::Transaction, Header<H>>, BlockError> {
+) -> Result<Block<T::Transaction>, BlockError> {
     match kind {
         BlockTransactionsKind::Hashes => {
-            Ok(from_block_with_tx_hashes::<T::Transaction, H>(block, total_difficulty, block_hash))
+            Ok(from_block_with_tx_hashes::<T::Transaction>(block, total_difficulty, block_hash))
         }
         BlockTransactionsKind::Full => {
-            from_block_full::<T, H>(block, total_difficulty, block_hash, tx_resp_builder)
+            from_block_full::<T>(block, total_difficulty, block_hash, tx_resp_builder)
         }
     }
 }
@@ -36,11 +36,11 @@ pub fn from_block<T: TransactionCompat, H: BlockHeader + From<alloy_consensus::H
 ///
 /// This will populate the `transactions` field with only the hashes of the transactions in the
 /// block: [`BlockTransactions::Hashes`]
-pub fn from_block_with_tx_hashes<T, H: BlockHeader + From<alloy_consensus::Header>>(
+pub fn from_block_with_tx_hashes<T>(
     block: BlockWithSenders,
     total_difficulty: U256,
     block_hash: Option<B256>,
-) -> Block<T, Header<H>> {
+) -> Block<T> {
     let block_hash = block_hash.unwrap_or_else(|| block.header.hash_slow());
     let transactions = block.body.transactions().map(|tx| tx.hash()).collect();
 
@@ -58,12 +58,12 @@ pub fn from_block_with_tx_hashes<T, H: BlockHeader + From<alloy_consensus::Heade
 ///
 /// This will populate the `transactions` field with the _full_
 /// [`TransactionCompat::Transaction`] objects: [`BlockTransactions::Full`]
-pub fn from_block_full<T: TransactionCompat, H: BlockHeader + From<alloy_consensus::Header>>(
+pub fn from_block_full<T: TransactionCompat>(
     mut block: BlockWithSenders,
     total_difficulty: U256,
     block_hash: Option<B256>,
     tx_resp_builder: &T,
-) -> Result<Block<T::Transaction, Header<H>>, BlockError> {
+) -> Result<Block<T::Transaction>, BlockError> {
     let block_hash = block_hash.unwrap_or_else(|| block.block.header.hash_slow());
     let block_number = block.block.number;
     let base_fee_per_gas = block.block.base_fee_per_gas;
@@ -111,13 +111,13 @@ pub fn from_primitive_with_hash(primitive_header: reth_primitives::SealedHeader)
 }
 
 #[inline]
-fn from_block_with_transactions<T, H: BlockHeader + From<alloy_consensus::Header>>(
+fn from_block_with_transactions<T>(
     block_length: usize,
     block_hash: B256,
     block: PrimitiveBlock,
     total_difficulty: U256,
     transactions: BlockTransactions<T>,
-) -> Block<T, Header<H>> {
+) -> Block<T> {
     let withdrawals = block
         .header
         .withdrawals_root
@@ -127,7 +127,7 @@ fn from_block_with_transactions<T, H: BlockHeader + From<alloy_consensus::Header
 
     let uncles = block.body.ommers.into_iter().map(|h| h.hash_slow()).collect();
     let header = Header::from_consensus(
-        Sealed::new_unchecked(block.header.into(), block_hash),
+        Sealed::new_unchecked(block.header, block_hash),
         Some(total_difficulty),
         Some(U256::from(block_length)),
     );
diff --git a/crates/rpc/rpc/src/engine.rs b/crates/rpc/rpc/src/engine.rs
index b49bee7b7f9fa..928e2050a5c2d 100644
--- a/crates/rpc/rpc/src/engine.rs
+++ b/crates/rpc/rpc/src/engine.rs
@@ -9,7 +9,7 @@ use reth_primitives::{BlockId, BlockNumberOrTag};
 use reth_rpc_api::{EngineEthApiServer, EthApiServer, EthFilterApiServer};
 /// Re-export for convenience
 pub use reth_rpc_engine_api::EngineApi;
-use reth_rpc_eth_api::{types::RpcHeader, FullEthApiTypes, RpcBlock, RpcReceipt, RpcTransaction};
+use reth_rpc_eth_api::{FullEthApiTypes, RpcBlock, RpcReceipt, RpcTransaction};
 use tracing_futures::Instrument;
 
 macro_rules! engine_span {
@@ -40,7 +40,6 @@ where
     Eth: EthApiServer<
             RpcTransaction<Eth::NetworkTypes>,
             RpcBlock<Eth::NetworkTypes>,
-            RpcHeader<Eth::NetworkTypes>,
             RpcReceipt<Eth::NetworkTypes>,
         > + FullEthApiTypes,
     EthFilter: EthFilterApiServer<RpcTransaction<Eth::NetworkTypes>>,
diff --git a/crates/rpc/rpc/src/eth/core.rs b/crates/rpc/rpc/src/eth/core.rs
index 9ad655bf68516..98ac9e9f4094f 100644
--- a/crates/rpc/rpc/src/eth/core.rs
+++ b/crates/rpc/rpc/src/eth/core.rs
@@ -549,7 +549,7 @@ mod tests {
     /// Invalid block range
     #[tokio::test]
     async fn test_fee_history_empty() {
-        let response = <EthApi<_, _, _, _> as EthApiServer<_, _, _, _>>::fee_history(
+        let response = <EthApi<_, _, _, _> as EthApiServer<_, _, _>>::fee_history(
             &build_test_eth_api(NoopProvider::default()),
             U64::from(1),
             BlockNumberOrTag::Latest,
@@ -571,7 +571,7 @@ mod tests {
         let (eth_api, _, _) =
             prepare_eth_api(newest_block, oldest_block, block_count, MockEthProvider::default());
 
-        let response = <EthApi<_, _, _, _> as EthApiServer<_, _, _, _>>::fee_history(
+        let response = <EthApi<_, _, _, _> as EthApiServer<_, _, _>>::fee_history(
             &eth_api,
             U64::from(newest_block + 1),
             newest_block.into(),
@@ -594,7 +594,7 @@ mod tests {
         let (eth_api, _, _) =
             prepare_eth_api(newest_block, oldest_block, block_count, MockEthProvider::default());
 
-        let response = <EthApi<_, _, _, _> as EthApiServer<_, _, _, _>>::fee_history(
+        let response = <EthApi<_, _, _, _> as EthApiServer<_, _, _>>::fee_history(
             &eth_api,
             U64::from(1),
             (newest_block + 1000).into(),
@@ -617,7 +617,7 @@ mod tests {
         let (eth_api, _, _) =
             prepare_eth_api(newest_block, oldest_block, block_count, MockEthProvider::default());
 
-        let response = <EthApi<_, _, _, _> as EthApiServer<_, _, _, _>>::fee_history(
+        let response = <EthApi<_, _, _, _> as EthApiServer<_, _, _>>::fee_history(
             &eth_api,
             U64::from(0),
             newest_block.into(),
diff --git a/crates/rpc/rpc/src/otterscan.rs b/crates/rpc/rpc/src/otterscan.rs
index 8806ab803bfe0..7a7ac8923bdb9 100644
--- a/crates/rpc/rpc/src/otterscan.rs
+++ b/crates/rpc/rpc/src/otterscan.rs
@@ -1,7 +1,7 @@
 use alloy_consensus::{BlockHeader, Transaction};
 use alloy_network::{ReceiptResponse, TransactionResponse};
 use alloy_primitives::{Address, Bytes, TxHash, B256, U256};
-use alloy_rpc_types::{BlockTransactions, TransactionReceipt};
+use alloy_rpc_types::{BlockTransactions, Header, TransactionReceipt};
 use alloy_rpc_types_trace::{
     otterscan::{
         BlockDetails, ContractCreator, InternalOperation, OperationType, OtsBlockTransactions,
@@ -15,7 +15,6 @@ use reth_primitives::{BlockId, BlockNumberOrTag};
 use reth_rpc_api::{EthApiServer, OtterscanServer};
 use reth_rpc_eth_api::{
     helpers::{EthTransactions, TraceExt},
-    types::RpcHeader,
     FullEthApiTypes, RpcBlock, RpcReceipt, RpcTransaction, TransactionCompat,
 };
 use reth_rpc_eth_types::{utils::binary_search, EthApiError};
@@ -50,7 +49,7 @@ where
         &self,
         block: RpcBlock<Eth::NetworkTypes>,
         receipts: Vec<RpcReceipt<Eth::NetworkTypes>>,
-    ) -> RpcResult<BlockDetails<RpcHeader<Eth::NetworkTypes>>> {
+    ) -> RpcResult<BlockDetails> {
         // blob fee is burnt, so we don't need to calculate it
         let total_fees = receipts
             .iter()
@@ -62,23 +61,18 @@ where
 }
 
 #[async_trait]
-impl<Eth> OtterscanServer<RpcTransaction<Eth::NetworkTypes>, RpcHeader<Eth::NetworkTypes>>
-    for OtterscanApi<Eth>
+impl<Eth> OtterscanServer<RpcTransaction<Eth::NetworkTypes>, Header> for OtterscanApi<Eth>
 where
     Eth: EthApiServer<
             RpcTransaction<Eth::NetworkTypes>,
             RpcBlock<Eth::NetworkTypes>,
-            RpcHeader<Eth::NetworkTypes>,
             RpcReceipt<Eth::NetworkTypes>,
         > + EthTransactions
         + TraceExt
         + 'static,
 {
     /// Handler for `{ots,erigon}_getHeaderByNumber`
-    async fn get_header_by_number(
-        &self,
-        block_number: u64,
-    ) -> RpcResult<Option<RpcHeader<Eth::NetworkTypes>>> {
+    async fn get_header_by_number(&self, block_number: u64) -> RpcResult<Option<Header>> {
         self.eth.header_by_number(BlockNumberOrTag::Number(block_number)).await
     }
 
@@ -171,10 +165,7 @@ where
     }
 
     /// Handler for `ots_getBlockDetails`
-    async fn get_block_details(
-        &self,
-        block_number: u64,
-    ) -> RpcResult<BlockDetails<RpcHeader<Eth::NetworkTypes>>> {
+    async fn get_block_details(&self, block_number: u64) -> RpcResult<BlockDetails<Header>> {
         let block_id = block_number.into();
         let block = self.eth.block_by_number(block_id, true);
         let block_id = block_id.into();
@@ -187,10 +178,7 @@ where
     }
 
     /// Handler for `getBlockDetailsByHash`
-    async fn get_block_details_by_hash(
-        &self,
-        block_hash: B256,
-    ) -> RpcResult<BlockDetails<RpcHeader<Eth::NetworkTypes>>> {
+    async fn get_block_details_by_hash(&self, block_hash: B256) -> RpcResult<BlockDetails<Header>> {
         let block = self.eth.block_by_hash(block_hash, true);
         let block_id = block_hash.into();
         let receipts = self.eth.block_receipts(block_id);
@@ -207,9 +195,7 @@ where
         block_number: u64,
         page_number: usize,
         page_size: usize,
-    ) -> RpcResult<
-        OtsBlockTransactions<RpcTransaction<Eth::NetworkTypes>, RpcHeader<Eth::NetworkTypes>>,
-    > {
+    ) -> RpcResult<OtsBlockTransactions<RpcTransaction<Eth::NetworkTypes>, Header>> {
         let block_id = block_number.into();
         // retrieve full block and its receipts
         let block = self.eth.block_by_number(block_id, true);