diff --git a/AUTHORS b/AUTHORS
index ac4d742..d445c36 100644
--- a/AUTHORS
+++ b/AUTHORS
@@ -14,6 +14,7 @@
 Christophe Dumez <ch.dumez@samsung.com>
 Cody Barnes <conceptgenesis@gmail.com>
 Colin Plumb
+Cyril Lashkevich <notorca@gmail.com>
 David Porter <david@porter.me>
 Dax Booysen <dax@younow.com>
 Danail Kirov <dkirovbroadsoft@gmail.com>
diff --git a/sdk/android/api/org/webrtc/RtpSender.java b/sdk/android/api/org/webrtc/RtpSender.java
index 168f927..bc894e5 100644
--- a/sdk/android/api/org/webrtc/RtpSender.java
+++ b/sdk/android/api/org/webrtc/RtpSender.java
@@ -11,6 +11,7 @@
 package org.webrtc;
 
 import android.support.annotation.Nullable;
+import java.util.List;
 
 /** Java wrapper for a C++ RtpSenderInterface. */
 public class RtpSender {
@@ -62,6 +63,16 @@
     return cachedTrack;
   }
 
+  public void setStreams(List<String> streamIds) {
+    checkRtpSenderExists();
+    nativeSetStreams(nativeRtpSender, streamIds);
+  }
+
+  public List<String> getStreams() {
+    checkRtpSenderExists();
+    return nativeGetStreams(nativeRtpSender);
+  }
+
   public boolean setParameters(RtpParameters parameters) {
     checkRtpSenderExists();
     return nativeSetParameters(nativeRtpSender, parameters);
@@ -117,6 +128,10 @@
   // Will be released in dispose() or setTrack().
   private static native long nativeGetTrack(long rtpSender);
 
+  private static native void nativeSetStreams(long rtpSender, List<String> streamIds);
+
+  private static native List<String> nativeGetStreams(long rtpSender);
+
   // This should increment the reference count of the DTMF sender.
   // Will be released in dispose().
   private static native long nativeGetDtmfSender(long rtpSender);
diff --git a/sdk/android/src/jni/pc/rtp_sender.cc b/sdk/android/src/jni/pc/rtp_sender.cc
index e3ef185..411e5dc 100644
--- a/sdk/android/src/jni/pc/rtp_sender.cc
+++ b/sdk/android/src/jni/pc/rtp_sender.cc
@@ -45,6 +45,26 @@
           .release());
 }
 
+static void JNI_RtpSender_SetStreams(
+    JNIEnv* jni,
+    jlong j_rtp_sender_pointer,
+    const JavaParamRef<jobject>& j_stream_labels) {
+  reinterpret_cast<RtpSenderInterface*>(j_rtp_sender_pointer)
+      ->SetStreams(JavaListToNativeVector<std::string, jstring>(
+          jni, j_stream_labels, &JavaToNativeString));
+}
+
+ScopedJavaLocalRef<jobject> JNI_RtpSender_GetStreams(
+    JNIEnv* jni,
+    jlong j_rtp_sender_pointer) {
+  ScopedJavaLocalRef<jstring> (*convert_function)(JNIEnv*, const std::string&) =
+      &NativeToJavaString;
+  return NativeToJavaList(
+      jni,
+      reinterpret_cast<RtpSenderInterface*>(j_rtp_sender_pointer)->stream_ids(),
+      convert_function);
+}
+
 jlong JNI_RtpSender_GetDtmfSender(JNIEnv* jni,
                                   jlong j_rtp_sender_pointer) {
   return jlongFromPointer(
diff --git a/sdk/objc/api/peerconnection/RTCRtpSender.h b/sdk/objc/api/peerconnection/RTCRtpSender.h
index 49f61b8..c03b4cc 100644
--- a/sdk/objc/api/peerconnection/RTCRtpSender.h
+++ b/sdk/objc/api/peerconnection/RTCRtpSender.h
@@ -35,6 +35,9 @@
  */
 @property(nonatomic, copy, nullable) RTCMediaStreamTrack *track;
 
+/** IDs of streams associated with the RTP sender */
+@property(nonatomic, copy) NSArray<NSString *> *streamIds;
+
 /** The RTCDtmfSender accociated with the RTP sender. */
 @property(nonatomic, readonly, nullable) id<RTCDtmfSender> dtmfSender;
 
diff --git a/sdk/objc/api/peerconnection/RTCRtpSender.mm b/sdk/objc/api/peerconnection/RTCRtpSender.mm
index b227025..d292651 100644
--- a/sdk/objc/api/peerconnection/RTCRtpSender.mm
+++ b/sdk/objc/api/peerconnection/RTCRtpSender.mm
@@ -57,6 +57,23 @@
   }
 }
 
+- (NSArray<NSString *> *)streamIds {
+  std::vector<std::string> nativeStreamIds = _nativeRtpSender->stream_ids();
+  NSMutableArray *streamIds = [NSMutableArray arrayWithCapacity:nativeStreamIds.size()];
+  for (const auto &s : nativeStreamIds) {
+    [streamIds addObject:[NSString stringForStdString:s]];
+  }
+  return streamIds;
+}
+
+- (void)setStreamIds:(NSArray<NSString *> *)streamIds {
+  std::vector<std::string> nativeStreamIds;
+  for (NSString *streamId in streamIds) {
+    nativeStreamIds.push_back([streamId UTF8String]);
+  }
+  _nativeRtpSender->SetStreams(nativeStreamIds);
+}
+
 - (NSString *)description {
   return [NSString stringWithFormat:@"RTCRtpSender {\n  senderId: %@\n}",
       self.senderId];
