diff --git a/modules/audio_coding/codecs/red/audio_encoder_copy_red.cc b/modules/audio_coding/codecs/red/audio_encoder_copy_red.cc
index 2bfd2c4..1432e31 100644
--- a/modules/audio_coding/codecs/red/audio_encoder_copy_red.cc
+++ b/modules/audio_coding/codecs/red/audio_encoder_copy_red.cc
@@ -19,7 +19,10 @@
 #include "rtc_base/checks.h"
 
 namespace webrtc {
-static const int kRedMaxPacketSize = 1 << 10;
+// RED packets must be less than 1024 bytes to fit the 10 bit block length.
+static constexpr const int kRedMaxPacketSize = 1 << 10;
+// The typical MTU is 1200 bytes.
+static constexpr const size_t kAudioMaxRtpPacketLen = 1200;
 
 AudioEncoderCopyRed::Config::Config() = default;
 AudioEncoderCopyRed::Config::Config(Config&&) = default;
@@ -27,6 +30,7 @@
 
 AudioEncoderCopyRed::AudioEncoderCopyRed(Config&& config)
     : speech_encoder_(std::move(config.speech_encoder)),
+      max_packet_length_(kAudioMaxRtpPacketLen),
       red_payload_type_(config.payload_type) {
   RTC_CHECK(speech_encoder_) << "Speech encoder not provided.";
 }
@@ -57,12 +61,16 @@
   return speech_encoder_->GetTargetBitrate();
 }
 
-size_t AudioEncoderCopyRed::CalculateHeaderLength() const {
+size_t AudioEncoderCopyRed::CalculateHeaderLength(size_t encoded_bytes) const {
   size_t header_size = 1;
-  if (secondary_info_.encoded_bytes > 0) {
+  size_t bytes_available = max_packet_length_ - encoded_bytes;
+  if (secondary_info_.encoded_bytes > 0 &&
+      secondary_info_.encoded_bytes < bytes_available) {
     header_size += 4;
+    bytes_available -= secondary_info_.encoded_bytes;
   }
-  if (tertiary_info_.encoded_bytes > 0) {
+  if (tertiary_info_.encoded_bytes > 0 &&
+      tertiary_info_.encoded_bytes < bytes_available) {
     header_size += 4;
   }
   return header_size > 1 ? header_size : 0;
@@ -78,19 +86,22 @@
   RTC_CHECK(info.redundant.empty()) << "Cannot use nested redundant encoders.";
   RTC_DCHECK_EQ(primary_encoded.size(), info.encoded_bytes);
 
-  if (info.encoded_bytes == 0) {
+  if (info.encoded_bytes == 0 || info.encoded_bytes > kRedMaxPacketSize) {
     return info;
   }
+  RTC_DCHECK_GT(max_packet_length_, info.encoded_bytes);
 
   // Allocate room for RFC 2198 header if there is redundant data.
   // Otherwise this will send the primary payload type without
   // wrapping in RED.
-  const size_t header_length_bytes = CalculateHeaderLength();
+  const size_t header_length_bytes = CalculateHeaderLength(info.encoded_bytes);
   encoded->SetSize(header_length_bytes);
 
   size_t header_offset = 0;
+  size_t bytes_available = max_packet_length_ - info.encoded_bytes;
   if (tertiary_info_.encoded_bytes > 0 &&
-      tertiary_info_.encoded_bytes < kRedMaxPacketSize) {
+      tertiary_info_.encoded_bytes + secondary_info_.encoded_bytes <
+          bytes_available) {
     encoded->AppendData(tertiary_encoded_);
 
     const uint32_t timestamp_delta =
@@ -101,10 +112,11 @@
                  (timestamp_delta << 2) | (tertiary_info_.encoded_bytes >> 8));
     encoded->data()[header_offset + 3] = tertiary_info_.encoded_bytes & 0xff;
     header_offset += 4;
+    bytes_available -= tertiary_info_.encoded_bytes;
   }
 
   if (secondary_info_.encoded_bytes > 0 &&
-      secondary_info_.encoded_bytes < kRedMaxPacketSize) {
+      secondary_info_.encoded_bytes < bytes_available) {
     encoded->AppendData(secondary_encoded_);
 
     const uint32_t timestamp_delta =
@@ -115,6 +127,7 @@
                  (timestamp_delta << 2) | (secondary_info_.encoded_bytes >> 8));
     encoded->data()[header_offset + 3] = secondary_info_.encoded_bytes & 0xff;
     header_offset += 4;
+    bytes_available -= secondary_info_.encoded_bytes;
   }
 
   encoded->AppendData(primary_encoded);
@@ -200,4 +213,9 @@
   return speech_encoder_->GetFrameLengthRange();
 }
 
+void AudioEncoderCopyRed::OnReceivedOverhead(size_t overhead_bytes_per_packet) {
+  max_packet_length_ = kAudioMaxRtpPacketLen - overhead_bytes_per_packet;
+  return speech_encoder_->OnReceivedOverhead(overhead_bytes_per_packet);
+}
+
 }  // namespace webrtc
diff --git a/modules/audio_coding/codecs/red/audio_encoder_copy_red.h b/modules/audio_coding/codecs/red/audio_encoder_copy_red.h
index 4d7fc40..9806772 100644
--- a/modules/audio_coding/codecs/red/audio_encoder_copy_red.h
+++ b/modules/audio_coding/codecs/red/audio_encoder_copy_red.h
@@ -62,6 +62,7 @@
   void OnReceivedUplinkBandwidth(
       int target_audio_bitrate_bps,
       absl::optional<int64_t> bwe_period_ms) override;
+  void OnReceivedOverhead(size_t overhead_bytes_per_packet) override;
   absl::optional<std::pair<TimeDelta, TimeDelta>> GetFrameLengthRange()
       const override;
 
@@ -71,13 +72,16 @@
                          rtc::Buffer* encoded) override;
 
  private:
-  size_t CalculateHeaderLength() const;
+  size_t CalculateHeaderLength(size_t encoded_bytes) const;
+
   std::unique_ptr<AudioEncoder> speech_encoder_;
+  size_t max_packet_length_;
   int red_payload_type_;
   rtc::Buffer secondary_encoded_;
   EncodedInfoLeaf secondary_info_;
   rtc::Buffer tertiary_encoded_;
   EncodedInfoLeaf tertiary_info_;
+
   RTC_DISALLOW_COPY_AND_ASSIGN(AudioEncoderCopyRed);
 };
 
diff --git a/modules/audio_coding/codecs/red/audio_encoder_copy_red_unittest.cc b/modules/audio_coding/codecs/red/audio_encoder_copy_red_unittest.cc
index fbc0b8a..3352799 100644
--- a/modules/audio_coding/codecs/red/audio_encoder_copy_red_unittest.cc
+++ b/modules/audio_coding/codecs/red/audio_encoder_copy_red_unittest.cc
@@ -355,6 +355,32 @@
   EXPECT_EQ(encoded_[8], primary_payload_type);
 }
 
+TEST_F(AudioEncoderCopyRedTest, RespectsPayloadMTU) {
+  const int primary_payload_type = red_payload_type_ + 1;
+  AudioEncoder::EncodedInfo info;
+  info.encoded_bytes = 600;
+  info.encoded_timestamp = timestamp_;
+  info.payload_type = primary_payload_type;
+
+  EXPECT_CALL(*mock_encoder_, EncodeImpl(_, _, _))
+      .WillOnce(Invoke(MockAudioEncoder::FakeEncoding(info)));
+  Encode();
+  info.encoded_timestamp = timestamp_;  // update timestamp.
+  info.encoded_bytes = 500;
+  EXPECT_CALL(*mock_encoder_, EncodeImpl(_, _, _))
+      .WillOnce(Invoke(MockAudioEncoder::FakeEncoding(info)));
+  Encode();  // Second call will produce a redundant encoding.
+
+  EXPECT_EQ(encoded_.size(), 5u + 600u + 500u);
+
+  info.encoded_timestamp = timestamp_;  // update timestamp.
+  info.encoded_bytes = 400;
+  EXPECT_CALL(*mock_encoder_, EncodeImpl(_, _, _))
+      .WillOnce(Invoke(MockAudioEncoder::FakeEncoding(info)));
+  Encode();  // Third call will drop the oldest packet.
+  EXPECT_EQ(encoded_.size(), 5u + 500u + 400u);
+}
+
 #if GTEST_HAS_DEATH_TEST && !defined(WEBRTC_ANDROID)
 
 // This test fixture tests various error conditions that makes the