Creates a new TelnyxRTC instance with the provided options.
Options for initializing a client
Authenticating with a JSON Web Token:
const client = new TelnyxRTC({
login_token: login_token,
});
Authenticating with username and password credentials:
const client = new TelnyxRTC({
login: username,
password: password,
});
Custom ringback and ringtone files can be a wav/mp3 in your local public folder or a file hosted on a CDN, ex: https://cdn.company.com/sounds/call.mp3.
To use the ringbackFile, make sure the "Generate Ringback Tone" option is disabled
in your Telnyx Portal connection
configuration (Inbound tab.)
const client = new TelnyxRTC({
login_token: login_token,
ringtoneFile: './sounds/incoming_call.mp3',
ringbackFile: './sounds/ringback_tone.mp3',
});
client.remoteElement = 'remoteMedia';
The corresponding HTML:
<audio id="remoteMedia" autoplay="true" />
<!-- or for video: -->
<!-- <video id="remoteMedia" autoplay="true" playsinline="true" /> -->
true if the client is connected to the Telnyx RTC server
const client = new TelnyxRTC(options);
console.log(client.connected); // => false
Gets the local html element.
const client = new TelnyxRTC(options);
console.log(client.localElement);
// => HTMLMediaElement
Sets the local html element that will receive the local stream.
const client = new TelnyxRTC(options);
client.localElement = 'localElementMediaId';
Audio and video constraints currently used by the client.
const client = new TelnyxRTC(options);
console.log(client.mediaConstraints);
// => { audio: true, video: false }
Gets the remote html element.
const client = new TelnyxRTC(options);
console.log(client.remoteElement);
// => HTMLMediaElement
Sets the remote html element that will receive the remote stream.
const client = new TelnyxRTC(options);
client.remoteElement = 'remoteElementMediaId';
Default audio output device, if set by client.
const client = new TelnyxRTC(options);
console.log(client.speaker);
// => "abc123xyz"
Sets the default audio output device for subsequent calls.
let result = await client.getAudioOutDevices();
if (result.length) {
client.speaker = result[1].deviceId;
}
Checks if the browser has the permission to access mic and/or webcam
Whether to check for microphone permissions.
Whether to check for webcam permissions.
Checking for audio and video permissions:
const client = new TelnyxRTC(options);
client.checkPermissions();
Checking only for audio permissions:
const client = new TelnyxRTC(options);
client.checkPermissions(true, false);
Checking only for video permissions:
const client = new TelnyxRTC(options);
client.checkPermissions(false, true);
Disables use of the microphone in subsequent calls.
Note: This setting will be ignored if audio: true is
specified when creating a new call.
const client = new TelnyxRTC(options);
client.disableMicrophone();
Keep in mind that new calls will fail if both the
microphone and webcam is disabled. Make sure that the
webcam is manually enabled, or video: true is
specified before disabling the microphone.
const client = new TelnyxRTC({
...options,
video: true
});
client.disableMicrophone();
Returns the audio input devices supported by the browser.
Promise with an array of MediaDeviceInfo
Using async/await:
async function() {
const client = new TelnyxRTC(options);
let result = await client.getAudioInDevices();
console.log(result);
}
Using ES6 Promises:
client.getAudioInDevices().then((result) => {
console.log(result);
});
Returns the audio output devices supported by the browser.
Browser Compatibility Note: Firefox has yet to fully implement
audio output devices. As of v63, this feature is behind the
user preference media.setsinkid.enabled.
See: https://bugzilla.mozilla.org/show_bug.cgi?id=1152401#c98
Promise with an array of MediaDeviceInfo
Using async/await:
async function() {
const client = new TelnyxRTC(options);
let result = await client.getAudioOutDevices();
console.log(result);
}
Using ES6 Promises:
client.getAudioOutDevices().then((result) => {
console.log(result);
});
Returns supported resolution for the given webcam.
the deviceId from your webcam.
If deviceId is null
if deviceId is null and you don't have a webcam connected to your computer,
it will throw an error with the message "Requested device not found".
if deviceId is null and you have one or more webcam connected to your computer,
it will return a list of resolutions from the default device set up in your operating system.
Using async/await:
async function() {
const client = new TelnyxRTC(options);
let result = await client.getDeviceResolutions();
console.log(result);
}
Using ES6 Promises:
client.getDeviceResolutions().then((result) => {
console.log(result);
});
If deviceId is not null
it will return a list of resolutions from the deviceId sent.
Using async/await:
async function() {
const client = new TelnyxRTC(options);
let result = await client.getDeviceResolutions(deviceId);
console.log(result);
}
Using ES6 Promises:
client.getDeviceResolutions(deviceId).then((result) => {
console.log(result);
});
Returns a list of devices supported by the browser
Using async/await:
async function() {
const client = new TelnyxRTC(options);
let result = await client.getDevices();
console.log(result);
}
Using ES6 Promises:
client.getDevices().then((result) => {
console.log(result);
});
Returns a list of video devices supported by the browser (i.e. webcam).
Promise with an array of MediaDeviceInfo
Using async/await:
async function() {
const client = new TelnyxRTC(options);
let result = await client.getVideoDevices();
console.log(result);
}
Using ES6 Promises:
client.getVideoDevices().then((result) => {
console.log(result);
});
Makes a new outbound call.
Options object for a new call.
The new outbound Call object.
Making an outbound call to +1 856-444-0362 using default values from the client:
const call = client.newCall({
destinationNumber: '+18564440362',
callerNumber: '+15551231234'
});
You can omit callerNumber when dialing a SIP address:
const call = client.newCall({
destinationNumber: 'sip:example-sip-username@voip-provider.example.net'
});
If you are making calls from one Telnyx connection to another, you may specify just the SIP username:
const call = client.newCall({
destinationNumber: 'telnyx-sip-username' // This is equivalent to 'sip:telnyx-sip-username@sip.telnyx.com'
});
An error will be thrown if destinationNumber is not specified.
const call = client.newCall().catch(console.error);
// => `destinationNumber is required`
client.newCall({
destinationNumber: '18004377950',
callerNumber: '155531234567',
customHeaders: [ {name: "X-Header", value: "value" } ]
});
You can pass preferred_codecs to the newCall method to set codec preference during the call.
preferred_codecs is a sub-array of the codecs returned by RTCRtpReceiver.getCapabilities('audio')
const allCodecs = RTCRtpReceiver.getCapabilities('audio').codecs;
const PCMACodec = allCodecs.find((c) => c.mimeType.toLowerCase().includes('pcma'));
client.newCall({
destinationNumber: 'xxx',
preferred_codecs: [PCMACodec],
});
ICE candidate prefetching can be enabled by passing prefetchIceCandidates to the newCall method.
example:
client.newCall({
destinationNumber: 'xxx',
prefetchIceCandidates: true,
});
Trickle ICE can be enabled by passing trickleIce to the newCall method.
example:
client.newCall({
destinationNumber: 'xxx',
trickleIce: true,
});
Removes an event handler that were attached with .on(). If no handler parameter is passed, all listeners for that event will be removed.
Event name.
Optional callback: FunctionFunction handler to be removed.
The client object itself.
Note: a handler will be removed from the stack by reference
so make sure to use the same reference in both .on() and .off() methods.
Subscribe to the telnyx.error and then, remove the event handler.
const errorHandler = (error) => {
// Log the error..
}
const client = new TelnyxRTC(options);
client.on('telnyx.error', errorHandler)
// .. later
client.off('telnyx.error', errorHandler)
Attaches an event handler for a specific type of event.
telnyx.ready |
The client is authenticated and available to use |
telnyx.error |
An error occurred at the session level |
telnyx.notification |
An update to the call or session |
telnyx.socket.open |
The WebSocket connection has been made |
telnyx.socket.close |
The WebSocket connection is set to close |
telnyx.socket.error |
An error occurred at the WebSocket level |
telnyx.socket.message |
The client has received a message through WebSockets |
Event name.
Function to call when the event comes.
The client object itself.
Subscribe to the telnyx.ready and telnyx.error events.
const client = new TelnyxRTC(options);
client.on('telnyx.ready', (client) => {
// Your client is ready!
}).on('telnyx.error', (error) => {
// Got an error...
})
Sets the default audio constraints for your client. See here for further details.
Note: It's a common behaviour, in WebRTC applications,
to persist devices user's selection to then reuse them across visits.
Due to a Webkit’s security protocols, Safari generates random deviceId on each page load.
To avoid this issue you can specify two additional properties
micId and micLabel in the constraints input parameter.
The client will use these values to assure the microphone you want to use is available
by matching both id and label with the device list retrieved from the browser.
MediaTrackConstraints object with the addition of micId and micLabel.
Promise<MediaTrackConstraints> Audio constraints applied to the client.
Set microphone by id and label with the echoCancellation flag turned off:
// within an async function
const constraints = await client.setAudioSettings({
micId: '772e94959e12e589b1cc71133d32edf543d3315cfd1d0a4076a60601d4ff4df8',
micLabel: 'Internal Microphone (Built-in)',
echoCancellation: false
})
Static webRTCInfoChecks if the running browser has support for TelnyRTC
An object with WebRTC browser support information or a string error message.
Check if your browser supports TelnyxRTC
const info = TelnyxRTC.webRTCInfo();
const isWebRTCSupported = info.supportWebRTC;
console.log(isWebRTCSupported); // => true
An error message will be returned if your browser doesn't support TelnyxRTC
const info = TelnyxRTC.webRTCInfo();
if (!info.supportWebRTC) {
console.error(info) // => 'This browser does not support @telnyx/webrtc. To see browser support list: `TelnyxRTC.webRTCSupportedBrowserList()'
}
Static webRTCSupportedReturns the WebRTC supported browser list.
The following table indicates the browsers supported by TelnyxRTC. We support the most recent (N) versions of these browsers unless otherwise indicated.
| Chrome | Firefox | Safari | Edge | |
|---|---|---|---|---|
| Android | [-] | [-] | [ ] | [ ] |
| iOS | [ ] | [ ] | [x] | [ ] |
| Linux | [x] | [-] | [ ] | [ ] |
| MacOS | [x] | [-] | [x] | [-] |
| Windows | [x] | [-] | [ ] | [-] |
[x] supports audio and video [-] supports only audio [ ] not supported
An array with supported operational systems and browsers.
const browserList = TelnyxRTC.webRTCSupportedBrowserList();
console.log(browserList) // => [{"operationSystem": "Android", "supported": [{"browserName": "Chrome", "features": ["video", "audio"], "supported": "full"},{...}]
The
TelnyxRTCclient connects your application to the Telnyx backend, enabling you to make outgoing calls and handle incoming calls.Examples