WebRTC peer to peer calls for everyone. See it live in action at peercalls.com.

The server has been completely rewriten in Go and all the original functionality works. An optional implementation of a Selective Forwarding Unit (SFU) is available to make Peer Calls consume less bandwith for user video uploads. This wouldn't haven been possible without the awesome pion/webrtc library.

The config file format is still YAML, but is different than what was in v3. The v3 source code is available in version-3 branch. Version 4 will no longer be published on NPM since the server is no longer written in NodeJS.

• Core rewritten in Golang.
• Selective Forwarding Unit. Can be enabled using NETWORK_TYPE=sfu environment variable. The peercalls.com instance has this enabled.
• Ability to change video and audio devices without reconnecting.
• Improved toolbar layout. Can be toggled by clicking or tapping.
• Multiple videos are now shown in a full-size grid and each can be minimized.
• Video cropping can be turned off.
• Improved file sending. Users are now able to send files larger than 64 or 256 KB (depends on the browser).
• Device names are correctly populated in the dropdown list.
• Improved desktop sharing.
• Copy invite link to clipboard. Will show as share icon on devices that support it.
• Fix: Toolbar icons render correctly on iOS 12 devices.
• Fix: Video autoplays.
• Fix: Toolbar is no longer visible until call is joined
• Fix: Add warning when using an unsupported browser
• Fix: Add warning when JavaScript is disabled

• Support dynamic adding and removing of streams
• Support RTCP packet Picture Loss Indicator (PLI)
• Support RTCP packet Receiver Estimated Maximum Bitrate (REMB)
• Add handling of other RTCP packets besides NACK, PLI and REMB
• Add JitterBuffer (experimental, currently without congestion control)
• Support multiple Peer Calls nodes when using SFU

• Node.js 8 or Node.js 12
• Go 1.14

Alternatively, Docker can be used to run Peer Calls.

• Golang
• pion/webrtc
• github.com/go-chi/chi
• nhooyr.io/websocket

See go.mod for more information

• React
• Redux
• TypeScript (since peer-calls v2.1.0)

See package.json for more information.

Head to Releases and download a precompiled version. Currently the binaries for the following systems are built automatically:

• linux amd64
• linux arm
• darwin (macOS) amd64
• windows amd64

Use the peercalls/peercalls image from Docker Hub:

docker run --rm -it -p 3000:3000 peercalls/peercalls:latest

git clone https://github.com/peer-calls/peer-calls.git
cd peer-calls
npm install

# for production
npm run build
npm run build:go:linux

# for development
npm run start

git clone https://github.com/peer-calls/peer-calls
cd peer-calls
docker build -t peer-calls .
docker run --rm -it -p 3000:3000 peer-calls

The default ICE servers in use are:

• stun:stun.l.google.com:19302
• stun:global.stun.twilio.com:3478?transport=udp

Only a single ICE server can be defined via environment variables. To define more use a YAML config file. To load a config file, use the -c /path/to/config.yml command line argument.

See config/types.go for configuration types.

Example:

base_url: ''
bind_host: '0.0.0.0'
bind_port: 3005
ice_servers:
 - urls:
   - 'stun:stun.l.google.com:19302'
- urls:
  - 'stun:global.stun.twilio.com:3478?transport=udp'
#- urls:
#  - 'turn:coturn.mydomain.com'
#  auth_type: secret
#  auth_secret:
#    username: "peercalls"
#    secret: "some-static-secret"
# tls:
#   cert: test.pem
#   key: test.key
store:
  type: memory
  # type: redis
  # redis:
  #   host: localhost
  #   port: 6379
  #   prefix: peercalls
network:
  type: mesh
  # type: sfu
  # sfu:
  #   interfaces:
  #   - eth0
prometheus:
  access_token: "mytoken"

Prometheus /metrics URL will not be accessible without an access token set. The access token can be provided by either:

• Setting Authorization header to Bearer mytoken, or
• Providing the access token as a query string: /metrics?access_token=mytoken

To access the server, go to http://localhost:3000.

Most browsers will prevent access to user media devices if the application is accessed from the network (not via 127.0.0.1). If you wish to test your mobile devices, you'll have to enable TLS by setting the PEERCALLS_TLS_CERT and PEERCALLS_TLS_KEY environment variables. To generate a self-signed certificate you can use:

openssl req -nodes -x509 -newkey rsa:4096 -keyout key.pem -subj "/C=US/ST=Oregon/L=Portland/O=Company Name/OU=Org/CN=example.com" -out cert.pem -days 365

Replace example.com with your server's hostname.

Redis can be used to allow users connected to different instances to connect. The following needs to be added to config.yaml to enable Redis:

store:
  type: redis
  redis:
    host: redis-host  # redis host
    port: 6379        # redis port
    prefix: peercalls # all instances must use the same prefix

By default, Peer Calls server will log only basic information. Client-side logging is disabled by default.

Server-side logs can be configured via the PEERCALLS_LOG environment variable. Setting it to * will enable all server-side logging:

• PEERCALLS_LOG=*

Client-side logs can be configured via localStorage.DEBUG and localStorage.LOG variables:

• Setting localStorage.log=1 enables logging of Redux actions and state changes
• Setting localStorage.debug=peercalls,peercalls:* enables all other client-side logging

Below are some common scripts used for development:

npm start              build all resources and start the server.
npm run build          build all client-side resources.
npm run start:server   start the server
npm run js:watch       build and watch resources
npm test               run all client-side tests.
go test ./...          run all server tests
npm run ci             run all linting, tests and build the client-side

Tested on Firefox and Chrome, including mobile versions. Also works on Safari and iOS since version 11. Does not work on Microsoft Edge because they do not support DataChannels yet.

For more details, see here:

• http://caniuse.com/#feat=rtcpeerconnection
• http://caniuse.com/#search=getUserMedia

In Firefox, it might be useful to use about:webrtc to debug connection issues. In Chrome, use about:webrtc-internals.

When experiencing connection issues, the first thing to try is to have all peers to use the same browser.

When a direct connection cannot be established, it might be help to use a TURN server. The peercalls.com instance is configured to use a TURN server and it can be used for testing. However, the server bandwidth there is not unlimited.

Here are the steps to install a TURN server on Ubuntu/Debian Linux:

sudo apt install coturn

Use the following configuration as a template for /etc/turnserver.conf:

lt-cred-mech
use-auth-secret
static-auth-secret=p4ssw0rd
realm=example.com
total-quota=300
cert=/etc/letsencrypt/live/rtc.example.com/fullchain.pem
pkey=/etc/letsencrypt/live/rtc.example.com/privkey.pem
log-file=/dev/stdout
no-multicast-peers
proc-user=turnserver
proc-group=turnserver

Change the p4ssw0rd, realm and paths to server certificates.

Use the following configuration for Peer Calls:

iceServers:
- urls:
  - 'turn:rtc.example.com'
  auth_type: secret
  auth_secret:
    username: 'example'
    secret: 'p4ssw0rd'

Finally, enable and start the coturn service:

sudo systemctl enable coturn
sudo systemctl start coturn

See Contributing section.

If you encounter a bug, please open a new issue!

The development of Peer Calls is sponsored by rondomoon. If you'd like enterprise on-site support or become a sponsor, please contact hello@rondomoon.com.

If you wish to support future development of Peer Calls, you can donate here:

Thank you ❤️

Apache 2.0