diff --git a/CHANGELOG.md b/CHANGELOG.md
index 948ac003f61..794d3ab97d2 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -11,7 +11,9 @@ As a minor extension, we have adopted a slightly different versioning convention
 
 - Optimizations of the state machine used by the signer to create individual signatures.
 
-- Support for buffering of incoming single signatures by the aggregator if it can not aggregate them yet
+- Support for buffering of incoming single signatures by the aggregator if it can not aggregate them yet.
+
+- Expose the Cardano transactions signing configuration for the current and upcoming epoch via the `/epoch-settings` route.
 
 - Crates versions:
 
diff --git a/Cargo.lock b/Cargo.lock
index 272a3ac21fa..dfe0bd5eac0 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3403,7 +3403,7 @@ dependencies = [
 
 [[package]]
 name = "mithril-aggregator"
-version = "0.5.64"
+version = "0.5.65"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -3559,7 +3559,7 @@ dependencies = [
 
 [[package]]
 name = "mithril-common"
-version = "0.4.52"
+version = "0.4.53"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -3704,7 +3704,7 @@ dependencies = [
 
 [[package]]
 name = "mithril-signer"
-version = "0.2.184"
+version = "0.2.185"
 dependencies = [
  "anyhow",
  "async-trait",
diff --git a/mithril-aggregator/Cargo.toml b/mithril-aggregator/Cargo.toml
index 36489257b7a..0d011c61d3c 100644
--- a/mithril-aggregator/Cargo.toml
+++ b/mithril-aggregator/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "mithril-aggregator"
-version = "0.5.64"
+version = "0.5.65"
 description = "A Mithril Aggregator server"
 authors = { workspace = true }
 edition = { workspace = true }
diff --git a/mithril-aggregator/src/http_server/routes/epoch_routes.rs b/mithril-aggregator/src/http_server/routes/epoch_routes.rs
index 019609458cc..7aa6bbe93b3 100644
--- a/mithril-aggregator/src/http_server/routes/epoch_routes.rs
+++ b/mithril-aggregator/src/http_server/routes/epoch_routes.rs
@@ -1,8 +1,16 @@
-use crate::http_server::routes::middlewares;
-use crate::DependencyContainer;
 use std::sync::Arc;
 use warp::Filter;
 
+use mithril_common::{
+    entities::{SignedEntityConfig, SignedEntityTypeDiscriminants},
+    messages::{EpochSettingsMessage, SignerMessagePart},
+    StdResult,
+};
+
+use crate::dependency_injection::EpochServiceWrapper;
+use crate::http_server::routes::middlewares;
+use crate::DependencyContainer;
+
 pub fn routes(
     dependency_manager: Arc<DependencyContainer>,
 ) -> impl Filter<Extract = (impl warp::Reply,), Error = warp::Rejection> + Clone {
@@ -15,70 +23,86 @@ fn epoch_settings(
 ) -> impl Filter<Extract = (impl warp::Reply,), Error = warp::Rejection> + Clone {
     warp::path!("epoch-settings")
         .and(warp::get())
-        .and(middlewares::with_epoch_service(dependency_manager))
+        .and(middlewares::with_epoch_service(dependency_manager.clone()))
+        .and(middlewares::with_signed_entity_config(dependency_manager))
         .and_then(handlers::epoch_settings)
 }
 
+async fn get_epoch_settings_message(
+    epoch_service: EpochServiceWrapper,
+    signed_entity_config: SignedEntityConfig,
+) -> StdResult<EpochSettingsMessage> {
+    let epoch_service = epoch_service.read().await;
+
+    let epoch = epoch_service.epoch_of_current_data()?;
+    let protocol_parameters = epoch_service.next_protocol_parameters()?.clone();
+    let next_protocol_parameters = epoch_service.upcoming_protocol_parameters()?.clone();
+    let current_signers = epoch_service.current_signers()?;
+    let next_signers = epoch_service.next_signers()?;
+
+    let cardano_transactions_signing_config = signed_entity_config
+        .list_allowed_signed_entity_types_discriminants()
+        .contains(&SignedEntityTypeDiscriminants::CardanoTransactions)
+        .then_some(signed_entity_config.cardano_transactions_signing_config);
+    let next_cardano_transactions_signing_config = cardano_transactions_signing_config.clone();
+
+    let epoch_settings_message = EpochSettingsMessage {
+        epoch,
+        protocol_parameters,
+        next_protocol_parameters,
+        current_signers: SignerMessagePart::from_signers(current_signers.to_vec()),
+        next_signers: SignerMessagePart::from_signers(next_signers.to_vec()),
+        cardano_transactions_signing_config,
+        next_cardano_transactions_signing_config,
+    };
+
+    Ok(epoch_settings_message)
+}
+
 mod handlers {
-    use crate::dependency_injection::EpochServiceWrapper;
-    use crate::http_server::routes::reply;
-    use mithril_common::messages::{EpochSettingsMessage, SignerMessagePart};
-    use slog_scope::{debug, warn};
+    use slog_scope::debug;
     use std::convert::Infallible;
     use warp::http::StatusCode;
 
+    use mithril_common::entities::SignedEntityConfig;
+
+    use crate::dependency_injection::EpochServiceWrapper;
+    use crate::http_server::routes::epoch_routes::get_epoch_settings_message;
+    use crate::http_server::routes::reply;
+
     /// Epoch Settings
     pub async fn epoch_settings(
         epoch_service: EpochServiceWrapper,
+        signed_entity_config: SignedEntityConfig,
     ) -> Result<impl warp::Reply, Infallible> {
         debug!("⇄ HTTP SERVER: epoch_settings");
-        let epoch_service = epoch_service.read().await;
-
-        match (
-            epoch_service.epoch_of_current_data(),
-            epoch_service.next_protocol_parameters(),
-            epoch_service.upcoming_protocol_parameters(),
-            epoch_service.current_signers(),
-            epoch_service.next_signers(),
-        ) {
-            (
-                Ok(epoch),
-                Ok(protocol_parameters),
-                Ok(next_protocol_parameters),
-                Ok(current_signers),
-                Ok(next_signers),
-            ) => {
-                let epoch_settings_message = EpochSettingsMessage {
-                    epoch,
-                    protocol_parameters: protocol_parameters.clone(),
-                    next_protocol_parameters: next_protocol_parameters.clone(),
-                    current_signers: SignerMessagePart::from_signers(current_signers.to_vec()),
-                    next_signers: SignerMessagePart::from_signers(next_signers.to_vec()),
-                };
-                Ok(reply::json(&epoch_settings_message, StatusCode::OK))
-            }
-            (Err(err), _, _, _, _)
-            | (_, Err(err), _, _, _)
-            | (_, _, Err(err), _, _)
-            | (_, _, _, Err(err), _)
-            | (_, _, _, _, Err(err)) => {
-                warn!("epoch_settings::error"; "error" => ?err);
-                Ok(reply::server_error(err))
-            }
+        let epoch_settings_message =
+            get_epoch_settings_message(epoch_service, signed_entity_config).await;
+
+        match epoch_settings_message {
+            Ok(message) => Ok(reply::json(&message, StatusCode::OK)),
+            Err(err) => Ok(reply::server_error(err)),
         }
     }
 }
 
 #[cfg(test)]
 mod tests {
+    use serde_json::Value::Null;
+    use std::collections::BTreeSet;
+    use tokio::sync::RwLock;
+    use warp::{
+        http::{Method, StatusCode},
+        test::request,
+    };
+
     use mithril_common::{
-        entities::Epoch,
+        entities::{
+            BlockNumber, CardanoTransactionsSigningConfig, Epoch, SignedEntityConfig,
+            SignedEntityTypeDiscriminants,
+        },
         test_utils::{apispec::APISpec, MithrilFixtureBuilder},
     };
-    use serde_json::Value::Null;
-    use tokio::sync::RwLock;
-    use warp::http::{Method, StatusCode};
-    use warp::test::request;
 
     use crate::http_server::SERVER_BASE_PATH;
     use crate::initialize_dependencies;
@@ -99,6 +123,62 @@ mod tests {
             .and(routes(dependency_manager).with(cors))
     }
 
+    #[tokio::test]
+    async fn get_epoch_settings_message_with_cardano_transactions_enabled() {
+        let fixture = MithrilFixtureBuilder::default().with_signers(3).build();
+        let epoch_service = FakeEpochService::from_fixture(Epoch(4), &fixture);
+        let epoch_service = Arc::new(RwLock::new(epoch_service));
+
+        let cardano_transactions_signing_config = CardanoTransactionsSigningConfig {
+            security_parameter: BlockNumber(70),
+            step: BlockNumber(15),
+        };
+        let signed_entity_config = SignedEntityConfig {
+            cardano_transactions_signing_config: cardano_transactions_signing_config.clone(),
+            allowed_discriminants: BTreeSet::from([
+                SignedEntityTypeDiscriminants::CardanoTransactions,
+            ]),
+            ..SignedEntityConfig::dummy()
+        };
+
+        let message = get_epoch_settings_message(epoch_service, signed_entity_config)
+            .await
+            .unwrap();
+
+        assert_eq!(
+            message.cardano_transactions_signing_config,
+            Some(cardano_transactions_signing_config.clone())
+        );
+        assert_eq!(
+            message.next_cardano_transactions_signing_config,
+            Some(cardano_transactions_signing_config)
+        );
+    }
+
+    #[tokio::test]
+    async fn get_epoch_settings_message_with_cardano_transactions_not_enabled() {
+        let fixture = MithrilFixtureBuilder::default().with_signers(3).build();
+        let epoch_service = FakeEpochService::from_fixture(Epoch(4), &fixture);
+        let epoch_service = Arc::new(RwLock::new(epoch_service));
+
+        let cardano_transactions_signing_config = CardanoTransactionsSigningConfig {
+            security_parameter: BlockNumber(70),
+            step: BlockNumber(15),
+        };
+        let signed_entity_config = SignedEntityConfig {
+            cardano_transactions_signing_config,
+            allowed_discriminants: BTreeSet::new(),
+            ..SignedEntityConfig::dummy()
+        };
+
+        let message = get_epoch_settings_message(epoch_service, signed_entity_config)
+            .await
+            .unwrap();
+
+        assert_eq!(message.cardano_transactions_signing_config, None);
+        assert_eq!(message.next_cardano_transactions_signing_config, None);
+    }
+
     #[tokio::test]
     async fn test_epoch_settings_get_ok() {
         let method = Method::GET.as_str();
diff --git a/mithril-common/Cargo.toml b/mithril-common/Cargo.toml
index 0116e694bcf..247afa6eb35 100644
--- a/mithril-common/Cargo.toml
+++ b/mithril-common/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "mithril-common"
-version = "0.4.52"
+version = "0.4.53"
 description = "Common types, interfaces, and utilities for Mithril nodes."
 authors = { workspace = true }
 edition = { workspace = true }
diff --git a/mithril-common/src/entities/epoch_settings.rs b/mithril-common/src/entities/epoch_settings.rs
index 955f80ac037..b46e7c80137 100644
--- a/mithril-common/src/entities/epoch_settings.rs
+++ b/mithril-common/src/entities/epoch_settings.rs
@@ -1,4 +1,4 @@
-use crate::entities::{Epoch, ProtocolParameters};
+use crate::entities::{CardanoTransactionsSigningConfig, Epoch, ProtocolParameters};
 
 use super::Signer;
 
@@ -19,4 +19,10 @@ pub struct EpochSettings {
 
     /// Signers that will be able to sign on the next epoch
     pub next_signers: Vec<Signer>,
+
+    /// Cardano transactions signing configuration for the current epoch
+    pub cardano_transactions_signing_config: Option<CardanoTransactionsSigningConfig>,
+
+    /// Cardano transactions signing configuration for the next epoch
+    pub next_cardano_transactions_signing_config: Option<CardanoTransactionsSigningConfig>,
 }
diff --git a/mithril-common/src/messages/epoch_settings.rs b/mithril-common/src/messages/epoch_settings.rs
index d7bc3247d59..197da16944c 100644
--- a/mithril-common/src/messages/epoch_settings.rs
+++ b/mithril-common/src/messages/epoch_settings.rs
@@ -1,4 +1,4 @@
-use crate::entities::{Epoch, ProtocolParameters};
+use crate::entities::{CardanoTransactionsSigningConfig, Epoch, ProtocolParameters};
 use crate::messages::SignerMessagePart;
 use serde::{Deserialize, Serialize};
 
@@ -21,6 +21,14 @@ pub struct EpochSettingsMessage {
 
     /// Signers that will be able to sign on the next epoch
     pub next_signers: Vec<SignerMessagePart>,
+
+    /// Cardano transactions signing configuration for the current epoch
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub cardano_transactions_signing_config: Option<CardanoTransactionsSigningConfig>,
+
+    /// Cardano transactions signing configuration for the next epoch
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub next_cardano_transactions_signing_config: Option<CardanoTransactionsSigningConfig>,
 }
 
 impl EpochSettingsMessage {
@@ -41,6 +49,8 @@ impl EpochSettingsMessage {
                 },
                 current_signers: [SignerMessagePart::dummy()].to_vec(),
                 next_signers: [SignerMessagePart::dummy()].to_vec(),
+                cardano_transactions_signing_config: Some(CardanoTransactionsSigningConfig::dummy()),
+                next_cardano_transactions_signing_config: Some(CardanoTransactionsSigningConfig::dummy()),
             }
         }
     }
@@ -49,6 +59,8 @@ impl EpochSettingsMessage {
 #[cfg(test)]
 mod tests {
 
+    use crate::entities::BlockNumber;
+
     use super::*;
 
     const ACTUAL_JSON: &str = r#"{
@@ -68,12 +80,21 @@ mod tests {
             "verification_key_signature":"signature_456",
             "operational_certificate":"certificate_456",
             "kes_period":45
-        }]
+        }],
+        "cardano_transactions_signing_config": {
+            "security_parameter": 70,
+            "step": 20
+        },
+        "next_cardano_transactions_signing_config": {
+            "security_parameter": 50,
+            "step": 10
+        }
         
         }"#;
 
+    // Supported structure until OpenAPI version 0.1.28.
     #[derive(Clone, Debug, PartialEq, Default, Serialize, Deserialize)]
-    pub struct EpochSettingsMessagePreviousVersion {
+    pub struct EpochSettingsMessageUntilV0_1_28 {
         /// Current Epoch
         pub epoch: Epoch,
 
@@ -86,8 +107,45 @@ mod tests {
         pub next_protocol_parameters: ProtocolParameters,
     }
 
-    fn golden_previous_message() -> EpochSettingsMessagePreviousVersion {
-        EpochSettingsMessagePreviousVersion {
+    // Supported structure until OpenAPI version 0.1.29.
+    #[derive(Clone, Debug, PartialEq, Default, Serialize, Deserialize)]
+    pub struct EpochSettingsMessageUntilV0_1_29 {
+        /// Current Epoch
+        pub epoch: Epoch,
+
+        /// Current Protocol parameters
+        #[serde(rename = "protocol")]
+        pub protocol_parameters: ProtocolParameters,
+
+        /// Next Protocol parameters
+        #[serde(rename = "next_protocol")]
+        pub next_protocol_parameters: ProtocolParameters,
+
+        /// Current Signers
+        pub current_signers: Vec<SignerMessagePart>,
+
+        /// Signers that will be able to sign on the next epoch
+        pub next_signers: Vec<SignerMessagePart>,
+    }
+
+    fn golden_message_until_open_api_0_1_28() -> EpochSettingsMessageUntilV0_1_28 {
+        EpochSettingsMessageUntilV0_1_28 {
+            epoch: Epoch(10),
+            protocol_parameters: ProtocolParameters {
+                k: 5,
+                m: 100,
+                phi_f: 0.65,
+            },
+            next_protocol_parameters: ProtocolParameters {
+                k: 50,
+                m: 1000,
+                phi_f: 0.65,
+            },
+        }
+    }
+
+    fn golden_message_until_open_api_0_1_29() -> EpochSettingsMessageUntilV0_1_29 {
+        EpochSettingsMessageUntilV0_1_29 {
             epoch: Epoch(10),
             protocol_parameters: ProtocolParameters {
                 k: 5,
@@ -99,6 +157,20 @@ mod tests {
                 m: 1000,
                 phi_f: 0.65,
             },
+            current_signers: vec![SignerMessagePart {
+                party_id: "123".to_string(),
+                verification_key: "key_123".to_string(),
+                verification_key_signature: Some("signature_123".to_string()),
+                operational_certificate: Some("certificate_123".to_string()),
+                kes_period: Some(12),
+            }],
+            next_signers: vec![SignerMessagePart {
+                party_id: "456".to_string(),
+                verification_key: "key_456".to_string(),
+                verification_key_signature: Some("signature_456".to_string()),
+                operational_certificate: Some("certificate_456".to_string()),
+                kes_period: Some(45),
+            }],
         }
     }
 
@@ -129,18 +201,37 @@ mod tests {
                 operational_certificate: Some("certificate_456".to_string()),
                 kes_period: Some(45),
             }],
+            cardano_transactions_signing_config: Some(CardanoTransactionsSigningConfig {
+                security_parameter: BlockNumber(70),
+                step: BlockNumber(20),
+            }),
+            next_cardano_transactions_signing_config: Some(CardanoTransactionsSigningConfig {
+                security_parameter: BlockNumber(50),
+                step: BlockNumber(10),
+            }),
         }
     }
 
-    // Test the backward compatibility with previous structure.
+    // Test the backward compatibility with the structure supported until OpenAPI version 0.1.28.
+    #[test]
+    fn test_actual_json_deserialized_into_message_supported_until_open_api_0_1_28() {
+        let json = ACTUAL_JSON;
+        let message: EpochSettingsMessageUntilV0_1_28 = serde_json::from_str(json).expect(
+            "This JSON is expected to be successfully parsed into a EpochSettingsMessageUntilVersion0_1_28 instance.",
+        );
+
+        assert_eq!(golden_message_until_open_api_0_1_28(), message);
+    }
+
+    // Test the backward compatibility with the structure supported until OpenAPI version 0.1.29.
     #[test]
-    fn test_actual_json_deserialized_into_previous_message() {
+    fn test_actual_json_deserialized_into_message_supported_until_open_api_0_1_29() {
         let json = ACTUAL_JSON;
-        let message: EpochSettingsMessagePreviousVersion = serde_json::from_str(json).expect(
-            "This JSON is expected to be successfully parsed into a EpochSettingsMessagePreviousVersion instance.",
+        let message: EpochSettingsMessageUntilV0_1_29 = serde_json::from_str(json).expect(
+            "This JSON is expected to be successfully parsed into a EpochSettingsMessageUntilVersion0_1_29 instance.",
         );
 
-        assert_eq!(golden_previous_message(), message);
+        assert_eq!(golden_message_until_open_api_0_1_29(), message);
     }
 
     // Test the compatibility with current structure.
diff --git a/mithril-common/src/test_utils/fake_data.rs b/mithril-common/src/test_utils/fake_data.rs
index f76b952be51..a4a409c1c9c 100644
--- a/mithril-common/src/test_utils/fake_data.rs
+++ b/mithril-common/src/test_utils/fake_data.rs
@@ -66,6 +66,12 @@ pub fn epoch_settings() -> entities::EpochSettings {
     let current_signers = signers[1..3].to_vec();
     let next_signers = signers[2..5].to_vec();
 
+    // Cardano transactions signing configuration
+    let cardano_transactions_signing_config =
+        Some(entities::CardanoTransactionsSigningConfig::dummy());
+    let next_cardano_transactions_signing_config =
+        Some(entities::CardanoTransactionsSigningConfig::dummy());
+
     // Epoch settings
     entities::EpochSettings {
         epoch: beacon.epoch,
@@ -73,6 +79,8 @@ pub fn epoch_settings() -> entities::EpochSettings {
         next_protocol_parameters,
         current_signers,
         next_signers,
+        cardano_transactions_signing_config,
+        next_cardano_transactions_signing_config,
     }
 }
 
diff --git a/mithril-signer/Cargo.toml b/mithril-signer/Cargo.toml
index 6c43d149a72..3332d03edcf 100644
--- a/mithril-signer/Cargo.toml
+++ b/mithril-signer/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "mithril-signer"
-version = "0.2.184"
+version = "0.2.185"
 description = "A Mithril Signer"
 authors = { workspace = true }
 edition = { workspace = true }
diff --git a/mithril-signer/src/message_adapters/from_epoch_settings.rs b/mithril-signer/src/message_adapters/from_epoch_settings.rs
index 99059bb37de..5e04f973e20 100644
--- a/mithril-signer/src/message_adapters/from_epoch_settings.rs
+++ b/mithril-signer/src/message_adapters/from_epoch_settings.rs
@@ -19,6 +19,9 @@ impl TryFromMessageAdapter<EpochSettingsMessage, EpochSettings> for FromEpochSet
                 .with_context(|| "'FromMessageAdapter' can not convert the current signers")?,
             next_signers: SignerMessagePart::try_into_signers(message.next_signers)
                 .with_context(|| "'FromMessageAdapter' can not convert the next signers")?,
+            cardano_transactions_signing_config: message.cardano_transactions_signing_config,
+            next_cardano_transactions_signing_config: message
+                .next_cardano_transactions_signing_config,
         };
         Ok(epoch_settings)
     }
diff --git a/mithril-signer/src/runtime/runner.rs b/mithril-signer/src/runtime/runner.rs
index 17581540bb5..2927a1b8378 100644
--- a/mithril-signer/src/runtime/runner.rs
+++ b/mithril-signer/src/runtime/runner.rs
@@ -458,7 +458,10 @@ mod tests {
             MKMap, MKMapNode, MKTreeNode, MKTreeStoreInMemory, MKTreeStorer, ProtocolInitializer,
         },
         digesters::{DumbImmutableDigester, DumbImmutableFileObserver},
-        entities::{BlockNumber, BlockRange, CardanoDbBeacon, Epoch, ProtocolParameters},
+        entities::{
+            BlockNumber, BlockRange, CardanoDbBeacon, CardanoTransactionsSigningConfig, Epoch,
+            ProtocolParameters,
+        },
         era::{adapters::EraReaderBootstrapAdapter, EraChecker, EraReader},
         signable_builder::{
             BlockRangeRootRetriever, CardanoImmutableFilesFullSignableBuilder,
@@ -545,6 +548,16 @@ mod tests {
         async fn next_signers_with_stake(&self) -> StdResult<Vec<SignerWithStake>> {
             Ok(vec![])
         }
+        fn cardano_transactions_signing_config(
+            &self,
+        ) -> StdResult<&Option<CardanoTransactionsSigningConfig>> {
+            Ok(&None)
+        }
+        fn next_cardano_transactions_signing_config(
+            &self,
+        ) -> StdResult<&Option<CardanoTransactionsSigningConfig>> {
+            Ok(&None)
+        }
 
         fn is_signer_included_in_current_stake_distribution(
             &self,
diff --git a/mithril-signer/src/runtime/state_machine.rs b/mithril-signer/src/runtime/state_machine.rs
index 624c84cfeed..7e3147260c6 100644
--- a/mithril-signer/src/runtime/state_machine.rs
+++ b/mithril-signer/src/runtime/state_machine.rs
@@ -548,6 +548,8 @@ mod tests {
             next_protocol_parameters: fake_data::protocol_parameters(),
             current_signers: vec![],
             next_signers: vec![],
+            cardano_transactions_signing_config: None,
+            next_cardano_transactions_signing_config: None,
         };
         let known_epoch = Epoch(4);
         runner
diff --git a/mithril-signer/src/services/epoch_service.rs b/mithril-signer/src/services/epoch_service.rs
index d0e8e2c114a..efa9a9fe856 100644
--- a/mithril-signer/src/services/epoch_service.rs
+++ b/mithril-signer/src/services/epoch_service.rs
@@ -2,6 +2,7 @@ use std::sync::Arc;
 
 use async_trait::async_trait;
 use mithril_common::crypto_helper::ProtocolInitializer;
+use mithril_common::entities::CardanoTransactionsSigningConfig;
 use mithril_common::entities::Epoch;
 use mithril_common::entities::PartyId;
 use mithril_common::entities::ProtocolParameters;
@@ -49,6 +50,16 @@ pub trait EpochService: Sync + Send {
     /// Get signers with stake for the next epoch
     async fn next_signers_with_stake(&self) -> StdResult<Vec<SignerWithStake>>;
 
+    /// Get the cardano transactions signing configuration for the current epoch
+    fn cardano_transactions_signing_config(
+        &self,
+    ) -> StdResult<&Option<CardanoTransactionsSigningConfig>>;
+
+    /// Get the cardano transactions signing configuration for the next epoch
+    fn next_cardano_transactions_signing_config(
+        &self,
+    ) -> StdResult<&Option<CardanoTransactionsSigningConfig>>;
+
     /// Check if a signer is included in the current stake distribution
     fn is_signer_included_in_current_stake_distribution(
         &self,
@@ -62,6 +73,8 @@ struct EpochData {
     next_protocol_parameters: ProtocolParameters,
     current_signers: Vec<Signer>,
     next_signers: Vec<Signer>,
+    cardano_transactions_signing_config: Option<CardanoTransactionsSigningConfig>,
+    next_cardano_transactions_signing_config: Option<CardanoTransactionsSigningConfig>,
 }
 
 /// Implementation of the [epoch service][EpochService].
@@ -138,6 +151,9 @@ impl EpochService for MithrilEpochService {
             next_protocol_parameters: epoch_settings.next_protocol_parameters,
             current_signers: epoch_settings.current_signers,
             next_signers: epoch_settings.next_signers,
+            cardano_transactions_signing_config: epoch_settings.cardano_transactions_signing_config,
+            next_cardano_transactions_signing_config: epoch_settings
+                .next_cardano_transactions_signing_config,
         });
 
         Ok(())
@@ -177,6 +193,18 @@ impl EpochService for MithrilEpochService {
         .await
     }
 
+    fn cardano_transactions_signing_config(
+        &self,
+    ) -> StdResult<&Option<CardanoTransactionsSigningConfig>> {
+        Ok(&self.unwrap_data()?.cardano_transactions_signing_config)
+    }
+
+    fn next_cardano_transactions_signing_config(
+        &self,
+    ) -> StdResult<&Option<CardanoTransactionsSigningConfig>> {
+        Ok(&self.unwrap_data()?.next_cardano_transactions_signing_config)
+    }
+
     fn is_signer_included_in_current_stake_distribution(
         &self,
         party_id: PartyId,
@@ -302,6 +330,8 @@ mod tests {
         assert!(service.next_signers().is_err());
         assert!(service.current_signers_with_stake().await.is_err());
         assert!(service.next_signers_with_stake().await.is_err());
+        assert!(service.cardano_transactions_signing_config().is_err());
+        assert!(service.next_cardano_transactions_signing_config().is_err());
     }
 
     #[test]
@@ -350,6 +380,17 @@ mod tests {
             epoch_settings.next_protocol_parameters,
             *service.next_protocol_parameters().unwrap()
         );
+
+        // Check cardano_transactions_signing_config
+        assert_eq!(
+            epoch_settings.cardano_transactions_signing_config,
+            *service.cardano_transactions_signing_config().unwrap()
+        );
+        // Check next_cardano_transactions_signing_config
+        assert_eq!(
+            epoch_settings.next_cardano_transactions_signing_config,
+            *service.next_cardano_transactions_signing_config().unwrap()
+        );
     }
 
     #[tokio::test]
diff --git a/openapi.yaml b/openapi.yaml
index 9f96bd7080d..18977d53176 100644
--- a/openapi.yaml
+++ b/openapi.yaml
@@ -4,7 +4,7 @@ info:
   # `mithril-common/src/lib.rs` file. If you plan to update it
   # here to reflect changes in the API, please also update the constant in the
   # Rust file.
-  version: 0.1.30
+  version: 0.1.31
   title: Mithril Aggregator Server
   description: |
     The REST API provided by a Mithril Aggregator Node in a Mithril network.
@@ -55,6 +55,10 @@ paths:
         Returns the information related to the current epoch:
           * protocol parameters for current epoch
           * protocol parameters for next epoch (to setup cryptography, allowing signers to register)
+          * signers for current epoch
+          * signers for next epoch
+          * cardano transactions signing configuration for current epoch
+          * cardano transactions signing configuration for next epoch
       responses:
         "200":
           description: epoch settings found
@@ -733,6 +737,10 @@ components:
           type: array
           items:
             $ref: "#/components/schemas/Signer"
+        cardano_transactions_signing_config:
+          $ref: "#/components/schemas/CardanoTransactionsSigningConfig"
+        next_cardano_transactions_signing_config:
+          $ref: "#/components/schemas/CardanoTransactionsSigningConfig"
       example:
         {
           "epoch": 329,
@@ -771,7 +779,11 @@ components:
                 "operational_certificate": "2c38382c3138372c3233332c34302c37322c31362c36365d2c312c3132332c5b31362c3136392c3134312c3138332c32322c3137342c3131312c33322c36342c35322c2c3232382c37392c3137352c32395312c3838282c323030",
                 "kes_period": 876
               }
-            ]
+            ],
+          "cardano_transactions_signing_config":
+            { "security_parameter": 100, "step": 10 },
+          "next_cardano_transactions_signing_config":
+            { "security_parameter": 50, "step": 5 }
         }
 
     ProtocolParameters:
@@ -797,6 +809,24 @@ components:
           format: double
       example: { "k": 857, "m": 6172, "phi_f": 0.2 }
 
+    CardanoTransactionsSigningConfig:
+      description: Cardano transactions signing configuration
+      type: object
+      additionalProperties: false
+      required:
+        - security_parameter
+        - step
+      properties:
+        security_parameter:
+          description: Number of blocks to discard from the tip of the chain when importing Cardano transactions
+          type: integer
+          format: int64
+        step:
+          description: Number of blocks between signature of Cardano transactions
+          type: integer
+          format: int64
+      example: { "security_parameter": 100, "step": 10 }
+
     CardanoDbBeacon:
       description: A point in the Cardano chain at which a Mithril certificate of the Cardano Database should be produced
       type: object