Media Controls

These APIs let you control local and remote audio behavior during an active call.

Client-side vs server-side controls

Mute and noise suppression are applied locally on the device — they stop audio from being sent or filter it before transmission. Earmuff is applied server-side — the Vonage API suppresses the incoming audio stream before it reaches the client.

Platform Availability

Control	Android	iOS	Web
Mute / Unmute	Yes	Yes	Yes
Earmuff	Yes	Yes	Yes
DTMF	Yes	Yes	Yes
Noise suppression	Yes	Yes	No

Mute

Mute the local microphone so the remote party cannot hear you. The call remains active.

const callId = 'callId';
await client.mute(callId);

// Callback
 client.mute("callId") {
     it?.let { err ->
         // Handle Error in muting call
         println("Error in muting call: $err")
     }
 }

 // Coroutine
 try {
     client.mute("callId")
 } catch (e: Error) {
     // Handle Error in muting call
 }

client.mute("callId", it -> {
     if (it != null) {
         // Handle Error in muting call
         System.out.println("Error in muting call: " + it);
     }
     return null;
 });

// Callback
 client.mute("someCallId"){ error in
     if let error = error {
         print("Mute Failed with error: \(error)")
         return
     }
 }
 
 // Async Await
 Task.detached {
     do {
         try await client.mute("someCallId")
     } catch {
         print("Failed to mute \(error.localizedDescription)")
     }
 }

[client mute:@"someCallId" callback:^(NSError * _Nullable error) {
     if(error){
         NSLog(@"Mute Failed with error: %@", error);
     }
 }];

Unmute

Re-enable the local microphone after muting.

const callId = 'callId';
await client.unmute(callId);

// Callback
 client.unmute("callId") {
     it?.let { err ->
         // Handle Error in unmuting call
         println("Error in unmuting call: $err")
     }
 }

 // Coroutine
 try {
     client.unmute("callId")
 } catch (e: Error) {
     // Handle Error in unmuting call
 }

client.unmute("callId", it -> {
     if (it != null) {
         // Handle Error in unmuting call
         System.out.println("Error in unmuting call: " + it);
     }
     return null;
 });

// Callback
 client.unmute("someCallId"){ error in
     if let error = error {
         print("Unmute Failed with error: \(error)")
         return
     }
 }
 
 // Async Await
 Task.detached {
     do {
         try await client.unmute("someCallId")
     } catch {
         print("Failed to unmute \(error.localizedDescription)")
     }
 }

[client unmute:@"someCallId" callback:^(NSError * _Nullable error) {
         if(error){
             NSLog(@"Unmute Failed with error: %@", error);
         }
 }];

onMute Update Event

Fires when mute state changes, including changes triggered by the remote side or server.

client.on('mute', (callId, legId, mute) => {
  if (mute) {
    console.log(`Leg ${legId} of call ${callId} was muted`);
  } else {
    console.log(`Leg ${legId} of call ${callId} was unmuted`);
  }
});

 client.setOnMutedListener { call, legId, isMuted ->
     if (isMuted) {
         // leg is muted
         println("leg:$legId for call: $call was muted")
     } else {
         // leg is unmuted
         println("leg:$legId for call: $call was un-muted")
     }
 }

client.setOnMutedListener((call, legId, isMuted) -> {
     if (isMuted) {
         System.out.println("Leg " + legId + " for call " + call + " was muted");
     } else {
         System.out.println("Leg " + legId + " for call " + call + " was unmuted");
     }
     return null;
 });

class MuteUpdateExampleDelegate: NSObject, VGVoiceClientDelegate {
     func voiceClient(_ client: VGVoiceClient, didReceiveMuteForCall callId: VGCallId, withLegId legId: VGCallId, andStatus isMuted: Bool) {
         if (isMuted) {
             print("Leg:\(legId) has been muted")
         } else {
             print("Leg:\(legId) has been unmuted")
         }
     }
     
     func voiceClient(_ client: VGVoiceClient, didReceiveInviteForCall callId: VGCallId, from caller: String, with type: VGVoiceChannelType) {}
     func voiceClient(_ client: VGVoiceClient, didReceiveHangupForCall callId: VGCallId, withQuality callQuality: VGRTCQuality, reason: VGHangupReason) {}
     func voiceClient(_ client: VGVoiceClient, didReceiveInviteCancelForCall callId: VGCallId, with reason: VGVoiceInviteCancelReason) {}
     func client(_ client: VGBaseClient, didReceiveSessionErrorWith reason: VGSessionErrorReason) {}
 }

- (void) voiceClient:(VGVoiceClient *)client didReceiveMuteForCall:(VGCallId)callId withLegId:(NSString *)legId andStatus:(Boolean)isMuted {

     if(isMuted){
         NSLog(@"Leg: %@ has been muted", legId);
     } else {
         NSLog(@"Leg: %@ has been unmuted", legId);
     }
 }

Enable Earmuff

Earmuff prevents the local user from hearing remote audio. Unlike mute, earmuff is applied server-side — the audio stream is suppressed before it reaches the client.

const callId = 'callId';
await client.enableEarmuff(callId);

 // Callback
 client.enableEarmuff("callId") {
     it?.let { err ->
         // Handle Error in enabling earmuff
         println("Error in enabling earmuff: $err")
     }
 }

 // Coroutine
 try {
     client.enableEarmuff("callId")
 } catch (e: Error) {
     // Handle Error in enabling earmuff
 }

 client.enableEarmuff("callId", it -> {
     if (it != null) {
         // Handle Error in enabling earmuff
         System.out.println("Error in enabling earmuff: " + it);
     }
     return null;
 });

// Callback
 client.enableEarmuff("someCallId"){ error in
     if let error = error {
         print("Enable Earmuff Failed with error: \(error)")
         return
     }
 }
 
 // Async Await
 Task.detached {
     do {
         try await client.enableEarmuff("someCallId")
     } catch {
         print("Failed to enableEarmuff \(error.localizedDescription)")
     }
 }

 [client enableEarmuff:@"someCallId" callback:^(NSError * _Nullable error) {
     if(error){
         NSLog(@"Enable Earmuff Failed with error: %@", error);
     }
 }];

Disable Earmuff

Restore incoming audio after earmuffing.

const callId = 'callId';
await client.disableEarmuff(callId);

 // Callback
 client.disableEarmuff("callId") {
     it?.let { err ->
         // Handle Error in disabling earmuff
         println("Error in disabling earmuff: $err")
     }
 }

 // Coroutine
 try {
     client.disableEarmuff("callId")
 } catch (e: Error) {
     // Handle Error in disabling earmuff
 }

 client.disableEarmuff("callId", it -> {
     if (it != null) {
         // Handle Error in disabling earmuff
         System.out.println("Error in disabling earmuff: " + it);
     }
     return null;
 });

 // Callback
 client.disableEarmuff("someCallId"){ error in
     if let error = error {
         print("Disable Earmuff Failed with error: \(error)")
         return
     }
 }
 
 // Async Await
 Task.detached {
     do {
         try await client.disableEarmuff("someCallId")
     } catch {
         print("Failed to disableEarmuff \(error.localizedDescription)")
     }
 }

 [client disableEarmuff:@"someCallId" callback:^(NSError * _Nullable error) {
     if(error){
         NSLog(@"Disable Earmuff Failed with error: %@", error);
     }
 }];

onEarmuff Update Event

Fires when earmuff state changes.

client.on('earmuff', (callId, legId, earmuff) => {
  if (earmuff) {
    console.log(`Leg ${legId} of call ${callId} had earmuff enabled`);
  } else {
    console.log(`Leg ${legId} of call ${callId} had earmuff disabled`);
  }
});

 client.setOnEarmuffListener {call, legId, earmuffStatus ->
     if (earmuffStatus) {
         // earmuff enabled
         println("earmuff is enabled for leg:$legId with Call $call")
     } else {
         // earmuff disabled
         println("earmuff is disabled for leg:$legId with Call $call")
     }
 }

 client.setOnEarmuffListener((call, legId, earmuffStatus) -> {
     if (earmuffStatus) {
         System.out.println("Leg " + legId + " for call " + call + " was earmuffed");
     } else {
         System.out.println("Leg " + legId + " for call " + call + " was unearmuffed");
     }
     return null;
 });

 class EarmuffListenerExampleDelegate : NSObject, VGVoiceClientDelegate {
     func voiceClient(_ client: VGVoiceClient, didReceiveEarmuffForCall callId: VGCallId, withLegId legId: VGCallId, andStatus earmuffStatus: Bool) {
         if (earmuffStatus) {
             print("Leg:\(legId) has enabled earmuff")
         } else {
             print("Leg:\(legId) has disabled earmuff")
         }
     }
     
     func voiceClient(_ client: VGVoiceClient, didReceiveInviteForCall callId: VGCallId, from caller: String, with type: VGVoiceChannelType) {}
     func voiceClient(_ client: VGVoiceClient, didReceiveHangupForCall callId: VGCallId, withQuality callQuality: VGRTCQuality, reason: VGHangupReason) {}
     func voiceClient(_ client: VGVoiceClient, didReceiveInviteCancelForCall callId: VGCallId, with reason: VGVoiceInviteCancelReason) {}
     func client(_ client: VGBaseClient, didReceiveSessionErrorWith reason: VGSessionErrorReason) {}
 }

 - (void)voiceClient:(VGVoiceClient *)client didReceiveEarmuffForCall:(VGCallId)callId withLegId:(NSString *)legId andStatus:(Boolean)earmuffStatus {
     if(earmuffStatus){
         NSLog(@"Leg: %@ has enabled earmuff", legId);
     } else {
         NSLog(@"Leg: %@ has disabled earmuff", legId);
     }
 }

Send DTMF

Send dual-tone multi-frequency signals during an active call. Valid digits are 0-9, *, and #. DTMF is commonly used for IVR navigation and phone-system interaction.

const callId = 'callId';
await client.sendDTMF(callId, '1234');

 // Callback
 client.sendDTMF("callId", "1234") {
     it?.let { err ->
         // Handle Error in sending DTMF
         println("Error in sending DTMF: $err")
     }
 }

 // Coroutine
 try {
     client.sendDTMF("callId", "1234")
 } catch (e: Error) {
     // Handle Error in sending DTMF
 }

 client.sendDTMF("callId", "1234", it -> {
     if (it != null) {
         // Handle Error in sending DTMF
         System.out.println("Error in sending DTMF: " + it);
     }
     return null;
 });

 // Callback
 client.sendDTMF("someCallId", withDigits: "1234"){ error in
     if let error = error {
         print("DTMF Failed with error: \(error)")
         return
     }
 }
 
 // Async Await
 Task.detached {
     do {
         try await client.sendDTMF("someCallId", withDigits: "1234")
     } catch {
         print("Failed to sendDTMF \(error.localizedDescription)")
     }
 }

 [client sendDTMF:@"someCallId" withDigits:@"1234" callback:^(NSError * _Nullable error) {
     if(error){
         NSLog(@"DTMF Failed with error: %@", error);
     }
 }];

onDTMF Update Event

Fires when DTMF digits are received from the remote party.

client.on('dtmf', (callId, legId, dtmf) => {
  console.log(`Leg ${legId} of call ${callId} sent DTMF ${dtmf}`);
});

 client.setOnDTMFListener {call, legId, digits ->
     println("Received DTMF digits: $digits for leg:$legId with Call $call")
 }

 client.setOnDTMFListener((call, legId, dtmf) -> {
     System.out.println("Leg " + legId + " for call " + call + " sent DTMF: " + dtmf);
     return null;
 });

 class DTMFListenerExampleDelegate : NSObject, VGVoiceClientDelegate {
     func voiceClient(_ client: VGVoiceClient, didReceiveDTMFForCall callId: VGCallId, withLegId legId: VGCallId, andDigits digits: String) {
         print("Leg:\(legId) has sent DTMF: \(digits)")
     }
     
     func voiceClient(_ client: VGVoiceClient, didReceiveInviteForCall callId: VGCallId, from caller: String, with type: VGVoiceChannelType) {}
     func voiceClient(_ client: VGVoiceClient, didReceiveHangupForCall callId: VGCallId, withQuality callQuality: VGRTCQuality, reason: VGHangupReason) {}
     func voiceClient(_ client: VGVoiceClient, didReceiveInviteCancelForCall callId: VGCallId, with reason: VGVoiceInviteCancelReason) {}
     func client(_ client: VGBaseClient, didReceiveSessionErrorWith reason: VGSessionErrorReason) {}
 }

 - (void)voiceClient:(VGVoiceClient *)client didReceiveDTMFForCall:(VGCallId)callId withLegId:(NSString *)legId andDigits:(NSString *)digits {
     NSLog(@"Leg %@ has sent DTMF: %@", legId, digits);
 }

Enable Noise Suppression (Android/iOS)

Enable on-device noise suppression to filter background noise from the local microphone input. Not available on Web.

 // Callback
 client.enableNoiseSuppression("callId") { err ->
     err?.let {
         println("Error enabling noise suppression: $it")
     } ?: println("Noise suppression successfully enabled")
 }

 // Coroutine
 try {
     client.enableNoiseSuppression("callId")
 } catch (e: Error) {
     println("Error enabling noise suppression: $e")
 }

 client.enableNoiseSuppression("callId", err -> {
     if(err != null){
         System.out.println("Error enabling noise suppression: " + err);
     }
     System.out.println("Noise suppression successfully enabled");
     return null;
 });

 // Callback
 client.enableNoiseSuppression("someCallId"){ error in
     if let error = error {
         print("Failed to enable noise suppression: \(error.localizedDescription)")
     } else {
         print("Noise suppression successfully enabled")
     }
 }

 // Async Await
 Task.detached {
     do {
         try await client.enableNoiseSuppression("someCallId")
         print("Noise suppression successfully enabled")
     }
     catch {
         print("Failed to enable noise suppression: \(error.localizedDescription)")
     }
 }

 [client enableNoiseSuppression:@"someCallId" callback:^(NSError * _Nullable error) {
     if(error){
         NSLog(@"Failed to enable noise suppression: %@", error);
     } else {
         NSLog(@"Noise suppression successfully enabled");
     }
 }];

Disable Noise Suppression (Android/iOS)

Disable on-device noise suppression.

 // Callback
 client.disableNoiseSuppression("callId") { err ->
     err?.let {
         println("Error disabling noise suppression: $it")
     } ?: println("Noise suppression successfully disabled")
 }

 // Coroutine
 try {
     client.disableNoiseSuppression("callId")
     println("Noise suppression successfully disabled")
 } catch (e: Error) {
     println("Error disabling noise suppression: $e")
 }

 client.disableNoiseSuppression("callId", err -> {
     if(err != null){
         System.out.println("Error disabling noise suppression: " + err);
     }
     System.out.println("Noise suppression successfully disabled");
     return null;
 });

 // Callback
 client.disableNoiseSuppression("someCallId"){ error in
     if let error = error {
         print("Failed to disable noise suppression: \(error.localizedDescription)")
     } else {
         print("Noise suppression successfully disabled")
     }
 }

 // Async Await
 Task.detached {
     do {
         try await client.disableNoiseSuppression("someCallId")
         print("Noise suppression successfully disabled")
     }
     catch {
         print("Failed to disable noise suppression: \(error.localizedDescription)")
     }
 }

 [client disableNoiseSuppression:@"someCallId" callback:^(NSError * _Nullable error) {
     if(error){
         NSLog(@"Failed to disable noise suppression: %@", error);
     } else {
         NSLog(@"Noise suppression successfully disabled");
     }
 }];