Draft
This page is not complete.
This is an experimental technology
Because this technology's specification has not stabilized, check the compatibility table for usage in various browsers. Also note that the syntax and behavior of an experimental technology is subject to change in future versions of browsers as the specification changes.
The RTCPeerConnection
interface represents a WebRTC connection between the local computer and a remote peer. It provides methods to connect to a remote peer, maintain and monitor the connection, and close the connection once it's no longer needed.
RTCPeerConnection
and RTCSessionDescription
are currently prefixed in many browsers. It's strongly recommended you use a shim library such as the excellent and broadly supported Adapter.js, in order to ensure the broadest possible compatibility of your site or Web app. It's worth noting that Adapter.js goes beyond prefix handling, implementing shims to bridge compatibility gaps between browsers' implementations of WebRTC.
RTCPeerConnection()
RTCPeerConnection()
constructor returns a newly-created RTCPeerConnection
, which represents a connection between the local device and a remote peer.Also inherits properties from: EventTarget
canTrickleIceCandidates
RTCPeerConnection.canTrickleIceCandidates
returns a Boolean
which indicates whether or not the remote peer can accept trickled ICE candidates.connectionState
connectionState
property of the RTCPeerConnection
interface indicates the current state of the peer connection by returning one of the string values specified by the enum RTCPeerConnectionState
.currentLocalDescription
RTCPeerConnection.currentLocalDescription
returns an RTCSessionDescription
object describing the local end of the connection as it was most recently successfully negotiated since the last time the RTCPeerConnection
finished negotiating and connecting to a remote peer. Also included is a list of any ICE candidates that may already have been generated by the ICE agent since the offer or answer represented by the description was first instantiated.currentRemoteDescription
RTCPeerConnection.currentRemoteDescription
returns an RTCSessionDescription
object describing the remote end of the connection as it was most recently successfully negotiated since the last time the RTCPeerConnection
finished negotiating and connecting to a remote peer. Also included is a list of any ICE candidates that may already have been generated by the ICE agent since the offer or answer represented by the description was first instantiated.defaultIceServers
RTCPeerConnection.defaultIceServers
returns an array of objects based on the RTCIceServer
dictionary, which indicates what—if any—ICE servers the browser will use by default if none are provided to the RTCPeerConnection
in its RTCConfiguration
. However, browsers are not required to provide any default ICE servers at all.iceConnectionState
Read only
RTCPeerConnection.iceConnectionState
returns an enum of type RTCIceConnectionState
which state of the ICE agent associated with the RTCPeerConnection
.iceGatheringState
Read only
RTCPeerConnection.iceGatheringState
returns an enum of type RTCIceGatheringState
that describes connection's ICE gathering state. This lets you detect, for example, when collection of ICE candidates has finished.localDescription
Read only
RTCPeerConnection.localDescription
returns an RTCSessionDescription
describing the session for the local end of the connection. If it has not yet been set, this is null.peerIdentity
Read only
RTCPeerConnection.peerIdentity
returns an RTCIdentityAssertion
, containing a DOMString
once set and verified. If no peer has yet been set and verified, this property will return null
. Once set, via the appropriate method, it can't be changed.pendingLocalDescription
RTCPeerConnection.pendingLocalDescription
returns an RTCSessionDescription
object describing a pending configuration change for the local end of the connection. This does not describe the connection as it currently stands, but as it may exist in the near future. Use RTCPeerConnection.currentLocalDescription
or RTCPeerConnection.localDescription
to get the current state of the endpoint. For details on the difference, see "Pending and current descriptions" in WebRTC connectivity.pendingRemoteDescription
Read only
RTCPeerConnection.pendingRemoteDescription
returns an RTCSessionDescription
object describing a pending configuration change for the remote end of the connection. This does not describe the connection as it currently stands, but as it may exist in the near future. Use RTCPeerConnection.currentRemoteDescription
or RTCPeerConnection.remoteDescription
to get the current session description for the remote endpoint. For details on the difference, see "Pending and current descriptions" in WebRTC connectivity.remoteDescription
Read only
RTCPeerConnection.remoteDescription
returns a RTCSessionDescription
describing the session (which includes configuration and media information) for the remote end of the connection. If this hasn't been set yet, this is null
.sctp
sctp
property on the RTCPeerConnection
interface returns an RTCSctpTransport
describing the SCTP transport over which SCTP data is being sent and received. If SCTP hasn't been negotiated, this value is null
.signalingState
Read only
signalingState
property on the RTCPeerConnection
interface returns one of the string values specified by the RTCSignalingState
enum; these values describe the state of the signaling process on the local end of the connection while connecting or reconnecting to another peer. See "Signaling" in Lifetime of a WebRTC session for more details about the signaling process.Also inherits event handlers from: EventTarget
onaddstream
RTCPeerConnection.onaddstream
event handler is a property containing the code to execute when the addstream
event, of type MediaStreamEvent
, is received by this RTCPeerConnection
. Such an event is sent when a MediaStream
is added to this connection by the remote peer. The event is sent immediately after the call setRemoteDescription()
and doesn't wait for the result of the SDP negotiation.onconnectionstatechange
RTCPeerConnection.onconnectionstatechange
property specifies an EventHandler
which is called to handle the connectionstatechange
event when it occurs on an instance of RTCPeerConnection
. This happens whenever the aggregate state of the connection changes.ondatachannel
RTCPeerConnection.ondatachannel
property is an EventHandler
which specifies a function which is called when the datachannel
event occurs on an RTCPeerConnection
. This event, of type RTCDataChannelEvent
, is sent when an RTCDataChannel
is added to the connection by the remote peer calling createDataChannel()
.onicecandidate
RTCPeerConnection.onicecandidate
property is an EventHandler
which specifies a function to be called when the icecandidate
event occurs on an RTCPeerConnection
instance. This happens whenever the local ICE agent needs to deliver a message to the other peer through the signaling server.oniceconnectionstatechange
RTCPeerConnection.oniceconnectionstatechange
property is an event handler which specifies a function to be called when the iceconnectionstatechange
event is fired on an RTCPeerConnection
instance. This happens when the state of the connection's ICE agent, as represented by the iceConnectionState
property, changes.onicegatheringstatechange
RTCPeerConnection.onicegatheringstatechange
property is an EventHandler
which specifies a function to be called when the icegatheringstatechange
event is sent to an RTCPeerConnection
instance. This happens when the ICE gathering state—that is, whether or not the ICE agent is actively gathering candidates—changes.onidentityresult
RTCPeerConnection.onidentityresult
event handler is a property containing the code to execute when the identityresult
event, of type RTCIdentityEvent
, is received by this RTCPeerConnection
. Such an event is sent when an identity assertion is generated, via getIdentityAssertion()
or during the creation of an offer or an answer.onidpassertionerror
RTCPeerConnection.onidpassertionerror
event handler is a property containing the code to execute whent the idpassertionerror
event, of type RTCIdentityErrorEvent
, is received by this RTCPeerConnection
. Such an event is sent when the associated identity provider (IdP) encounters an error while generating an identity assertion.onidpvalidationerror
RTCPeerConnection.onidpvalidationerror
event handler is a property containing the code to execute whent the idpvalidationerror
event, of type RTCIdentityErrorEvent
, is received by this RTCPeerConnection
. Such an event is sent when the associated identity provider (IdP) encounters an error while validating an identity assertion.onnegotiationneeded
RTCPeerConnection.onnegotiationneeded
property is an EventHandler
which specifies a function which is called to handle the negotiationneeded
event when it occurs on an RTCPeerConnection
instance. This event is fired when a change has occurred which requires session negotiation.onpeeridentity
RTCPeerConnection.onpeeridentity
event handler is a property containing the code to execute whent the peeridentity
event, of type Event
, is received by this RTCPeerConnection
. Such an event is sent when an identity assertion, received from a peer, has been successfully validated.onremovestream
RTCPeerConnection.onremovestream
event handler is a property containing the code to execute when the removestream
event, of type MediaStreamEvent
, is received by this RTCPeerConnection
. Such an event is sent when a MediaStream
is removed from this connection.onsignalingstatechange
RTCPeerConnection.onsignalingstatechange
property is an EventHandler
which specifies a function to be called when the signalingstatechange
event occurs on an RTCPeerConnection
interface. The function receives as input the event object, of type Event
; this event is sent when the value of RTCPeerConnection.signalingState
changes, as the result of a call to either setLocalDescription()
or setRemoteDescription()
.ontrack
RTCPeerConnection.ontrack
property is an EventHandler
which specifies a function to be called when the track
event occurs on an RTCPeerConnection
interface. The function receives as input the event object, of type RTCTrackEvent
; this event is sent when a new incoming MediaStreamTrack
has been created and associated with an RTCRtpReceiver
object which has been added to the set of receivers on connection.Also inherits methods from: EventTarget
addIceCandidate()
RTCPeerConnection
receives a new ICE candidate from the remote peer over its signaling channel, it delivers the newly-received candidate to the browser's ICE agent by calling RTCPeerConnection.addIceCandidate()
.addStream()
RTCPeerConnection.addStream()
method adds a MediaStream
as a local source of audio or video. If the negotiation already happened, a new one will be needed for the remote peer to be able to use it.addTrack()
RTCPeerConnection
method addTrack()
adds a new media track to the connection. The track is added to the set of tracks which will be transmitted to the other peer.close()
RTCPeerConnection.close()
method closes the current peer connection.createAnswer()
createAnswer()
method on the RTCPeerConnection
interface creates an answer to an offer received from a remote peer during the offer/answer negotiation of a WebRTC connection. Once the answer is created, it should be sent to the source of the offer to continue the negotiation process.createOffer()
createOffer()
method of the RTCPeerConnection
interface initiates the creation of an SDP offer which includes information about any MediaStreamTrack
s already attached to the WebRTC session, codec and options supported by the browser, and any candidates already gathered by the ICE agent, for the purpose of being sent over the signaling channel to a potential peer to request a connection or to update the configuration of an existing connection.generateCertificate()
generateCertificate()
method of the RTCPeerConnection
interface creates and stores an X.509 certificate and corresponding private key then returns an RTCCertificate
, providing access to it.getIdentityAssertion()
RTCPeerConnection.getIdentityAssertion()
method initiates the gathering of an identity assertion. This has an effect only if the signalingState
is not "closed"
.getLocalStreams()
RTCPeerConnection.getLocalStreams()
method returns an array of MediaStream
associated with the local end of the connection. The array may be empty.getRemoteStreams()
RTCPeerConnection.getRemoteStreams()
method returns an array of MediaStream
associated with the remote end of the connection. The array may be empty.getSenders()
RTCPeerConnection.getSenders()
method returns an array of RTCRtpSender
objects, each of which represents one RTP sender. Each RTP sender is responsible for transmitting data for one track, and provides methods and properties for examining and controlling the transmission and encoding of the track's data.getStreamById()
RTCPeerConnection.getStreamById()
method returns the MediaStream
with the given id that is associated with local or remote end of the connection. If no stream matches, it returns null
.removeStream()
RTCPeerConnection.removeStream()
method removes a MediaStream
as a local source of audio or video. If the negotiation already happened, a new one will be needed for the remote peer to be able to use it. Because this method has been deprecated, you should instead use removeTrack()
if your target browser versions have implemented it.removeTrack
RTCPeerConnection.removeTrack()
method tells the local end of the connection to stop sending media from the specified track, without actually removing the corresponding RTCRtpSender
from the list of senders as reported by RTCPeerConnection.getSenders()
. If the track is already stopped, or is not in the connection's senders list, this method has no effect.setConfiguration()
RTCPeerConnection.setConfiguration()
method sets the current configuration of the RTCPeerConnection
based on the values included in the specified RTCConfiguration
object. This lets you change the ICE servers used by the connection and which transport policies to use.setIdentityProvider()
RTCPeerConnection.setIdentityProvider()
method sets the Identity Provider (IdP) to the triplet given in parameter: its name, the protocol used to communicate with it (optional) and an optional username. The IdP will be used only when an assertion is needed.setLocalDescription()
RTCPeerConnection.setLocalDescription()
method changes the local description associated with the connection. This description specifies the properties of the local end of the connection, including the media format.setRemoteDescription()
RTCPeerConnection.setRemoteDescription()
method changes the remote description associated with the connection. This description specifies the properties of the remote end of the connection, including the media format.The following method was obsoleted long ago and was never implemented in all major browsers.
RTCPeerConnection.createDTMFSender()
RTCDTMFSender
, associated to a specific MediaStreamTrack
, that will be able to send DTMF phone signaling over the connection.The RTCBundlePolicy
enum defines string constants which are used to request a specific policy for gathering ICE candidates if the remote peer isn't compatible with the SDP BUNDLE standard for bundling multiple media streams on a single transport link.
In technical terms, a BUNDLE lets all media flows between two peers flow across a single 5-tuple; that is, from the same IP and port on one peer to the same IP and port on the other peer, using the same transport protocol.
Constant | Description |
---|---|
"balanced" | On BUNDLE-aware connections, the ICE agent should gather candidates for all of the media types in use (audio, video, and data). Otherwise, the ICE agent should only negotiate one audio and video track on separate transports. |
"max-compat" | The ICE agent should gather candidates for each track, using separate transports to negotiate all media tracks for connections which aren't BUNDLE-compatible. |
"max-bundle" | The ICE agent should gather candidates for just one track. If the connection isn't BUNDLE-compatible, then the ICE agent should negotiate just one media track. |
The RTCIceConnectionState
enum defines the string constants used to describe the current state of the ICE agent and its connection to the ICE server (that is, the STUN or TURN server).
Constant | Description |
---|---|
"new" | The ICE agent is gathering addresses or is waiting to be given remote candidates through calls to RTCPeerConnection.addIceCandidate() (or both). |
"checking" | The ICE agent has been given one or more remote candidates and is checking pairs of local and remote candidates against one another to try to find a compatible match, but has not yet found a pair which will allow the peer connection to be made. It's possible that gathering of candidates is also still underway. |
"connected" | A usable pairing of local and remote candidates has been found for all components of the connection, and the connection has been established. It's possible that gathering is still underway, and it's also possible that the ICE agent is still checking candidates against one another looking for a better connection to use. |
"completed" | The ICE agent has finished gathering candidates, has checked all pairs against one another, and has found a connection for all components. |
"failed" | The ICE candidate has checked all candidates pairs against one another and has failed to find compatible matches for all components of the connection. It is, however, possible that the ICE agent did find compatible connections for some components. |
"disconnected" | Checks to ensure that components are still connected failed for at least one component of the RTCPeerConnection . This is a less stringent test than "failed" and may trigger intermittently and resolve just as spontaneously on less reliable networks, or during temporary disconnections. When the problem resolves, the connection may return to the "connected" state. |
"closed" | The ICE agent for this RTCPeerConnection has shut down and is no longer handling requests. |
The RTCIceGatheringState
enum defines string constants which reflect the current status of ICE gathering, as returned using the RTCPeerConnection.iceGatheringState
property. You can detect when this value changes by watching for an event of type icegatheringstatechange
.
Constant | Description |
---|---|
"new" | The peer connection was just created and hasn't done any networking yet. |
"gathering" | The ICE agent is in the process of gathering candidates for the connection. |
"complete" | The ICE agent has finished gathering candidates. If something happens that requires collecting new candidates, such as a new interface being added or the addition of a new ICE server, the state will revert to "gathering" to gather those candidates. |
The RTCIceTransportPolicy
enum defines string constants which can be used to limit the transport policies of the ICE candidates to be considered during the connection process.
Constant | Description |
---|---|
"all" | All ICE candidates will be considered. |
"public"
| Only ICE candidates with public IP addresses will be considered. Removed from the specification's May 13, 2016 working draft. |
"relay" | Only ICE candidates whose IP addresses are being relayed, such as those being passed through a TURN server, will be considered. |
The RTCPeerConnectionState
enum defines string constants which describe states in which the RTCPeerConnection
may be. These values are returned by the connectionState
property. This state essentially represents the aggregate state of all ICE transports (which are of type RTCIceTransport
or RTCDtlsTransport
) being used by the connection.
Constant | Description |
---|---|
"new" | At least one of the connection's ICE transports (RTCIceTransport s or RTCDtlsTransport s) are in the "new" state, and none of them are in one of the following states: "connecting" , "checking" , "failed" , or "disconnected" , or all of the connection's transports are in the "closed" state. |
"connecting" | One or more of the ICE transports are currently in the process of establishing a connection; that is, their RTCIceConnectionState is either "checking" or "connected" , and no transports are in the "failed" state. <<< Make this a link once I know where that will be documented
|
"connected" | Every ICE transport used by the connection is either in use (state "connected" or "completed" ) or is closed (state "closed" ); in addition, at least one transport is either "connected" or "completed" . |
"disconnected" | At least one of the ICE transports for the connection is in the "disconnected" state and none of the other transports are in the state "failed" , "connecting" , or "checking" . |
"failed" | One or more of the ICE transports on the connection is in the "failed" state. |
"closed" | The This value was in the |
The RTCRtcpMuxPolicy
enum defines string constants which specify what ICE candidates are gathered to support non-multiplexed RTCP. <<<add a link to info about multiplexed RTCP.
Constant | Description |
---|---|
"negotiate" | Instructs the ICE agent to gather both RTP and RTCP candidates. If the remote peer can multiplex RTCP, then RTCP candidates are multiplexed atop the corresponding RTP candidates. Otherwise, both the RTP and RTCP candidates are returned, separately. |
"relay" | Tells the ICE agent to gather ICE candidates for only RTP, and to multiplex RTCP atop them. If the remote peer doesn't support RTCP multiplexing, then session negotiation fails. |
The RTCSignalingState
enum specifies the possible values of RTCPeerConnection.signalingState
, which indicates where in the process of signaling the exchange of offer and answer the connection currently is.
Constant | Description |
---|---|
"stable" | There is no ongoing exchange of offer and answer underway. This may mean that the RTCPeerConnection object is new, in which case both the localDescription and remoteDescription are null ; it may also mean that negotiation is complete and a connection has been established. |
"have-local-offer" | The local peer has called RTCPeerConnection.setLocalDescription() , passing in SDP representing an offer (usually created by calling RTCPeerConnection.createOffer() ), and the offer has been applied successfully. |
"have-remote-offer" | The remote peer has created an offer and used the signaling server to deliver it to the local peer, which has set the offer as the remote description by calling RTCPeerConnection.setRemoteDescription() . |
"have-local-pranswer" | The offer sent by the remote peer has been applied and an answer has been created (usually by calling RTCPeerConnection.createAnswer() ) and applied by calling RTCPeerConnection.setLocalDescription() . This provisional answer describes the supported media formats and so forth, but may not have a complete set of ICE candidates included. Further candidates will be delivered separately later. |
"have-remote-pranswer" | A provisional answer has been received and successfully applied in response to an offer previously sent and established by calling setLocalDescription() . |
"closed"
| The connection is closed. This value moved into the |
Specification | Status | Comment |
---|---|---|
WebRTC 1.0: Real-time Communication Between Browsers | Working Draft | Initial definition. |
Feature | Chrome | Edge | Firefox (Gecko) | Internet Explorer | Microsoft Edge | Opera | Safari (WebKit) |
---|---|---|---|---|---|---|---|
Basic support | (Yes) | (Yes) |
22 (22) -moz until Firefox 44 | ? | ? | ? | ? |
iceConnectionState : disconnected
| ? | ? | 52 (52) | ? | ? | ? | ? |
Feature | Android | Android Webview | Edge | Firefox Mobile (Gecko) | Firefox OS | IE Mobile | Opera Mobile | Safari Mobile | Chrome for Android |
---|---|---|---|---|---|---|---|---|---|
Basic support | No support | (Yes) | (Yes) |
22 (22) -moz until Firefox 44 | 22 | ? | ? | ? | (Yes) |
iceConnectionState : disconnected
| No support | ? | ? | 52 (52) | No support | ? | ? | ? | ? |
© 2005–2017 Mozilla Developer Network and individual contributors.
Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.
https://developer.mozilla.org/en-US/docs/Web/API/RTCPeerConnection