WebRTC (Web Real-Time Communication) is a technology that enables Web applications and sites to capture and optionally stream audio and/or video media, as well as to exchange arbitrary data between browsers without requiring an intermediary. The set of standards that comprise WebRTC makes it possible to share data and perform teleconferencing peer-to-peer, without requiring that the user install plug-ins or any other third-party software.
WebRTC consists of several interrelated APIs and protocols which work together to achieve this. The documentation you'll find here will help you understand the fundamentals of WebRTC, how to set up and use both data and media connections, and more.
WebRTC serves multiple purposes; together with the Media Capture and Streams API, they provide powerful multimedia capabilities to the Web, including support for audio and video conferencing, file exchange, screen sharing, identity management, and interfacing with legacy telephone systems including support for sending DTMF (touch-tone dialing) signals. Connections between peers can be made without requiring any special drivers or plug-ins, and can often be made without any intermediary servers.
Connections between two peers are represented by the
RTCPeerConnection interface. Once a connection has been established and opened using
RTCPeerConnection, media streams (
MediaStreams) and/or data channels (
RTCDataChannels) can be added to the connection.
Media streams can consist of any number of tracks of media information; tracks, which are represented by objects based on the
MediaStreamTrack interface, may contain one of a number of types of media data, including audio, video, and text (such as subtitles or even chapter names). Most streams consist of at least one audio track and likely also a video track, and can be used to send and receive both live media or stored media information (such as a streamed movie).
You can also use the connection between two peers to exchange arbitrary binary data using the
RTCDataChannel interface. This can be used for back-channel information, metadata exchange, game status packets, file transfers, or even as a primary channel for data transfer.
WebRTC is in general well supported in modern browsers, but some incompatibilities remain. The adapter.js library is a shim to insulate apps from these incompatibilities.
Because WebRTC provides interfaces that work together to accomplish a variety of tasks, we have divided up the reference by category. Please see the sidebar for an alphabetical list.
These interfaces, dictionaries, and types are used to set up, open, and manage WebRTC connections. Included are interfaces representing peer media connections, data channels, and interfaces used when exchanging information on the capabilities of each peer in order to select the best possible configuration for a two-way media connection.
Represents a WebRTC connection between the local computer and a remote peer. It is used to handle efficient streaming of data between the two peers.
Represents a bi-directional data channel between two peers of a connection.
Represents the parameters of a session. Each
RTCSessionDescriptionconsists of a description
typeindicating which part of the offer/answer negotiation process it describes and of the SDP descriptor of the session.
Provides information detailing statistics for a connection or for an individual track on the connection; the report can be obtained by calling
RTCPeerConnection.getStats(). Details about using WebRTC statistics can be found in WebRTC Statistics API.
Represents information about an ICE transport.
The interface used to represent a
trackevent, which indicates that an
RTCRtpReceiverobject was added to the
RTCPeerConnectionobject, indicating that a new incoming
MediaStreamTrackwas created and added to the
Provides information which describes a Stream Control Transmission Protocol (SCTP) transport and also provides a way to access the underlying Datagram Transport Layer Security (DTLS) transport over which SCTP packets for all of an
RTCPeerConnection's data channels are sent and received.
Contains information about a given contributing source (CSRC) including the most recent time a packet that the source contributed was played out.
The amount of data currently buffered by the data channel—as indicated by its
bufferedAmountproperty—has decreased to be at or below the channel's minimum buffered data size, as specified by
The data channel has completed the closing process and is now in the
closedstate. Its underlying data transport is completely closed at this point. You can be notified before closing completes by watching for the
RTCDataChannelhas transitioned to the
closingstate, indicating that it will be closed soon. You can detect the completion of the closing process by watching for the
The connection's state, which can be accessed in
connectionState, has changed.
RTCErrorEventindicating that an error occurred on the data channel.
RTCIceTransport's gathering state has changed.
RTCPeerConnectionIceErrorEventindicating that an error has occurred while gathering ICE candidates.
A message has been received on the data channel. The event is of type
The underlying data transport for the
RTCDataChannelhas been successfully opened or re-opened.
The currently-selected pair of ICE candidates has changed for the
RTCIceTransporton which the event is fired.
The state of the
The state of the
The state of the
These APIs are used to manage user identity and security, in order to authenticate the user for a connection.
Enables a user agent is able to request that an identity assertion be generated or validated.
Represents the identity of the remote peer of the current connection. If no peer has yet been set and verified this interface returns
null. Once set it can't be changed.
Registers an identity provider (idP).
Represents a certificate that an
RTCPeerConnectionuses to authenticate.
These interfaces and events are related to interactivity with Public-Switched Telephone Networks (PTSNs). They're primarily used to send tone dialing sounds—or packets representing those tones—across the network to the remote peer.
Used by the
tonechangeevent to indicate that a DTMF tone has either begun or ended. This event does not bubble (except where otherwise stated) and is not cancelable (except where otherwise stated).
- Introduction to WebRTC protocols
This article introduces the protocols on top of which the WebRTC API is built.
- WebRTC connectivity
A guide to how WebRTC connections work and how the various protocols and interfaces can be used together to build powerful communication apps.
- Lifetime of a WebRTC session
WebRTC lets you build peer-to-peer communication of arbitrary data, audio, or video—or any combination thereof—into a browser application. In this article, we'll look at the lifetime of a WebRTC session, from establishing the connection all the way through closing the connection when it's no longer needed.
- Establishing a connection: The perfect negotiation pattern
Perfect negotiation is a design pattern which is recommended for your signaling process to follow, which provides transparency in negotiation while allowing both sides to be either the offerer or the answerer, without significant coding needed to differentiate the two.
- Signaling and two-way video calling
A tutorial and example which turns a WebSocket-based chat system created for a previous example and adds support for opening video calls among participants. The chat server's WebSocket connection is used for WebRTC signaling.
- Codecs used by WebRTC
A guide to the codecs which WebRTC requires browsers to support as well as the optional ones supported by various popular browsers. Included is a guide to help you choose the best codecs for your needs.
- Using WebRTC data channels
This guide covers how you can use a peer connection and an associated
RTCDataChannelto exchange arbitrary data between two peers.
- Using DTMF with WebRTC
WebRTC's support for interacting with gateways that link to old-school telephone systems includes support for sending DTMF tones using the
RTCDTMFSenderinterface. This guide shows how to do so.
- Improving compatibility using WebRTC adapter.js
- A simple RTCDataChannel sample
RTCDataChannelinterface is a feature which lets you open a channel between two peers over which you may send and receive arbitrary data. The API is intentionally similar to the WebSocket API, so that the same programming model can be used for each.
- Building an internet connected phone with Peer.js
This tutorial is a step-by-step guide on how to build a phone using Peer.js
|WebRTC 1.0: Real-Time Communication Between Browsers |
|Media Capture and Streams |
|Media Capture from DOM Elements |
- Interactive Connectivity Establishment (ICE): A Protocol for Network Address Translator (NAT) Traversal for Offer/Answer Protocol
- Session Traversal Utilities for NAT (STUN)
- URI Scheme for the Session Traversal Utilities for NAT (STUN) Protocol
- Traversal Using Relays around NAT (TURN) Uniform Resource Identifiers
- An Offer/Answer Model with Session Description Protocol (SDP)
- Session Traversal Utilities for NAT (STUN) Extension for Third Party Authorization
- Media Capture and Streams API
- Firefox multistream and renegotiation for Jitsi Videobridge
- Peering Through the WebRTC Fog with SocketPeer
- Inside the Party Bus: Building a Web App with Multiple Live Video Streams + Interactive Graphics
- Web media technologies
- WebRTC Statistics API