diff --git a/src/systems/data/include/units/data/bitrate.h b/src/systems/data/include/units/data/bitrate.h
index 5e871443..19c3ab6e 100644
--- a/src/systems/data/include/units/data/bitrate.h
+++ b/src/systems/data/include/units/data/bitrate.h
@@ -38,6 +38,12 @@ struct gibibit_per_second : deduced_unit<gibibit_per_second, dim_bitrate, gibibi
 struct tebibit_per_second : deduced_unit<tebibit_per_second, dim_bitrate, tebibit, isq::si::second> {};
 struct pebibit_per_second : deduced_unit<pebibit_per_second, dim_bitrate, pebibit, isq::si::second> {};
 
+struct kilobit_per_second : deduced_unit<kilobit_per_second, dim_bitrate, kilobit, isq::si::second> {};
+struct megabit_per_second : deduced_unit<megabit_per_second, dim_bitrate, megabit, isq::si::second> {};
+struct gigabit_per_second : deduced_unit<gigabit_per_second, dim_bitrate, gigabit, isq::si::second> {};
+struct terabit_per_second : deduced_unit<terabit_per_second, dim_bitrate, terabit, isq::si::second> {};
+struct petabit_per_second : deduced_unit<petabit_per_second, dim_bitrate, petabit, isq::si::second> {};
+
 template<typename T>
 concept Bitrate = QuantityOf<T, dim_bitrate>;
 
@@ -54,6 +60,12 @@ constexpr auto operator"" _q_Gib_per_s(unsigned long long l) { gsl_ExpectsAudit(
 constexpr auto operator"" _q_Tib_per_s(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return bitrate<tebibit_per_second, std::int64_t>(static_cast<std::int64_t>(l)); }
 constexpr auto operator"" _q_Pib_per_s(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return bitrate<pebibit_per_second, std::int64_t>(static_cast<std::int64_t>(l)); }
 
+constexpr auto operator"" _q_kb_per_s(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return bitrate<kilobit_per_second, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_Mb_per_s(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return bitrate<megabit_per_second, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_Gb_per_s(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return bitrate<gigabit_per_second, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_Tb_per_s(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return bitrate<terabit_per_second, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_Pb_per_s(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return bitrate<petabit_per_second, std::int64_t>(static_cast<std::int64_t>(l)); }
+
 }  // namespace literals
 
 namespace references {
@@ -65,6 +77,12 @@ inline constexpr auto Gib_per_s = reference<dim_bitrate, gibibit_per_second>{};
 inline constexpr auto Tib_per_s = reference<dim_bitrate, tebibit_per_second>{};
 inline constexpr auto Pib_per_s = reference<dim_bitrate, pebibit_per_second>{};
 
+inline constexpr auto kb_per_s = reference<dim_bitrate, kilobit_per_second>{};
+inline constexpr auto Mb_per_s = reference<dim_bitrate, megabit_per_second>{};
+inline constexpr auto Gb_per_s = reference<dim_bitrate, gigabit_per_second>{};
+inline constexpr auto Tb_per_s = reference<dim_bitrate, terabit_per_second>{};
+inline constexpr auto Pb_per_s = reference<dim_bitrate, petabit_per_second>{};
+
 }  // namespace references
 
 }  // namespace units::data
diff --git a/src/systems/data/include/units/data/information.h b/src/systems/data/include/units/data/information.h
index 47de34a4..6850a7bd 100644
--- a/src/systems/data/include/units/data/information.h
+++ b/src/systems/data/include/units/data/information.h
@@ -24,6 +24,7 @@
 
 #include <units/reference.h>
 #include <units/base_dimension.h>
+#include <units/isq/si/prefixes.h>
 #include <units/data/prefixes.h>
 #include <units/unit.h>
 #include <units/quantity.h>
@@ -37,6 +38,13 @@ struct gibibit : prefixed_unit<gibibit, gibi, bit> {};
 struct tebibit : prefixed_unit<tebibit, tebi, bit> {};
 struct pebibit : prefixed_unit<pebibit, pebi, bit> {};
 
+struct si_bit : alias_unit<bit, "b", isq::si::prefix> {};
+struct kilobit : prefixed_unit<kilobit, isq::si::kilo, si_bit> {};
+struct megabit : prefixed_unit<megabit, isq::si::mega, si_bit> {};
+struct gigabit : prefixed_unit<gigabit, isq::si::giga, si_bit> {};
+struct terabit : prefixed_unit<terabit, isq::si::tera, si_bit> {};
+struct petabit : prefixed_unit<petabit, isq::si::peta, si_bit> {};
+
 struct byte : named_scaled_unit<byte, "B", prefix, ratio(8), bit> {};
 struct kibibyte : prefixed_unit<kibibyte, kibi, byte> {};
 struct mebibyte : prefixed_unit<mebibyte, mebi, byte> {};
@@ -62,6 +70,13 @@ constexpr auto operator"" _q_Gib(unsigned long long l) { gsl_ExpectsAudit(std::i
 constexpr auto operator"" _q_Tib(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return information<tebibit, std::int64_t>(static_cast<std::int64_t>(l)); }
 constexpr auto operator"" _q_Pib(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return information<pebibit, std::int64_t>(static_cast<std::int64_t>(l)); }
 
+// bits (SI)
+constexpr auto operator"" _q_kb(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return information<kilobit, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_Mb(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return information<megabit, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_Gb(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return information<gigabit, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_Tb(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return information<terabit, std::int64_t>(static_cast<std::int64_t>(l)); }
+constexpr auto operator"" _q_Pb(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return information<petabit, std::int64_t>(static_cast<std::int64_t>(l)); }
+
 // bytes
 constexpr auto operator"" _q_B(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return information<byte, std::int64_t>(static_cast<std::int64_t>(l)); }
 constexpr auto operator"" _q_KiB(unsigned long long l) { gsl_ExpectsAudit(std::in_range<std::int64_t>(l)); return information<kibibyte, std::int64_t>(static_cast<std::int64_t>(l)); }
@@ -75,12 +90,19 @@ constexpr auto operator"" _q_PiB(unsigned long long l) { gsl_ExpectsAudit(std::i
 namespace references {
 
 inline constexpr auto b = reference<dim_information, bit>{};
+
 inline constexpr auto Kib = reference<dim_information, kibibit>{};
 inline constexpr auto Mib = reference<dim_information, mebibit>{};
 inline constexpr auto Gib = reference<dim_information, gibibit>{};
 inline constexpr auto Tib = reference<dim_information, tebibit>{};
 inline constexpr auto Pib = reference<dim_information, pebibit>{};
 
+inline constexpr auto kb = reference<dim_information, kilobit>{};
+inline constexpr auto Mb = reference<dim_information, megabit>{};
+inline constexpr auto Gb = reference<dim_information, gigabit>{};
+inline constexpr auto Tb = reference<dim_information, terabit>{};
+inline constexpr auto Pb = reference<dim_information, petabit>{};
+
 inline constexpr auto B = reference<dim_information, byte>{};
 inline constexpr auto KiB = reference<dim_information, kibibyte>{};
 inline constexpr auto MiB = reference<dim_information, mebibyte>{};
diff --git a/test/unit_test/runtime/digital_info_test.cpp b/test/unit_test/runtime/digital_info_test.cpp
index d1f269dc..deb6ef01 100644
--- a/test/unit_test/runtime/digital_info_test.cpp
+++ b/test/unit_test/runtime/digital_info_test.cpp
@@ -56,5 +56,9 @@ TEST_CASE("operator<< on a data quantity", "[text][ostream]")
       stream << 8_q_Kib * 8_q_Kib / 2_q_b;
       REQUIRE(stream.str() == "32 Mib");
     }
+    SECTION("prefixed coherent unit (SI)") {
+      stream << 32_q_kb;
+      REQUIRE(stream.str() == "32 kb");
+    }
   }
 }
diff --git a/test/unit_test/static/data_test.cpp b/test/unit_test/static/data_test.cpp
index 45ba9bed..4a333ae5 100644
--- a/test/unit_test/static/data_test.cpp
+++ b/test/unit_test/static/data_test.cpp
@@ -36,6 +36,9 @@ static_assert(1024_q_B == 1_q_KiB);
 static_assert(8 * 1024_q_b == 1_q_KiB);
 static_assert(8 * 1_q_Kib == 1_q_KiB);
 
+static_assert(1_q_kb == 1000_q_b);
+static_assert(2000_q_Mib == 2097152_q_kb);
+
 static_assert(1_q_Kib == 1024_q_b);
 static_assert(1_q_Mib == 1024_q_Kib);
 static_assert(1_q_Gib == 1024_q_Mib);