diff --git a/libraries/audio-client/src/AudioClient.cpp b/libraries/audio-client/src/AudioClient.cpp
index 9e9fae87831..3f012d76581 100644
--- a/libraries/audio-client/src/AudioClient.cpp
+++ b/libraries/audio-client/src/AudioClient.cpp
@@ -488,6 +488,95 @@ void AudioClient::setAllowedCodecs(const QStringList &userCodecs) {
     negotiateAudioFormat();
 }
 
+QMap<QString,bool> AudioClient::getEncoderFeatures() {
+    QMap<QString,bool> features;
+
+    if (_encoder) {
+        features.insert("isLossless", _encoder->isLossless());
+        features.insert("hasApplication", _encoder->hasApplication());
+        features.insert("hasComplexity", _encoder->hasComplexity());
+        features.insert("hasBitrate", _encoder->hasBitrate());
+        features.insert("hasFEC", _encoder->hasFEC());
+        features.insert("hasPacketLossPercent", _encoder->hasPacketLossPercent());
+        features.insert("hasBandpass", _encoder->hasBandpass());
+        features.insert("hasSignalType", _encoder->hasSignalType());
+        features.insert("hasVBR", _encoder->hasVBR());
+    }
+
+    return features;
+}
+
+bool AudioClient::getEncoderVBR() {
+    if (_encoder) {
+        return _encoder->getVBR();
+    }
+
+    return false;
+}
+
+void AudioClient::setEncoderVBR(bool enabled) {
+    if (_encoder) {
+        _encoder->setVBR(enabled);
+    }
+}
+
+int AudioClient::getEncoderBitrate() {
+    if (_encoder) {
+        return _encoder->getBitrate();
+    }
+
+    return 0;
+}
+
+void AudioClient::setEncoderBitrate(int bitrate) {
+    if (_encoder) {
+        _encoder->setBitrate(bitrate);
+    }
+}
+
+int AudioClient::getEncoderComplexity() {
+    if (_encoder) {
+        return _encoder->getComplexity();
+    }
+
+    return 0;
+}
+
+void AudioClient::setEncoderComplexity(int complexity) {
+    if (_encoder) {
+        _encoder->setComplexity(complexity);
+    }
+}
+
+bool AudioClient::getEncoderFEC() {
+    if (_encoder) {
+        return _encoder->getFEC();
+    }
+
+    return false;
+}
+
+void AudioClient::setEncoderFEC(bool enabled) {
+    if (_encoder) {
+        _encoder->setFEC(enabled);
+    }
+}
+
+int AudioClient::getEncoderPacketLossPercent() {
+    if (_encoder) {
+        return _encoder->getPacketLossPercent();
+    }
+
+    return 0;
+}
+
+void AudioClient::setEncoderPacketLossPercent(int percent) {
+    if (_encoder) {
+        _encoder->setPacketLossPercent(percent);
+    }
+}
+
+
 HifiAudioDeviceInfo getNamedAudioDeviceForMode(QAudio::Mode mode, const QString& deviceName, const QString& hmdName, bool isHmd=false) {
     HifiAudioDeviceInfo result;
     foreach (HifiAudioDeviceInfo audioDevice, getAvailableDevices(mode,hmdName)) {
diff --git a/libraries/audio-client/src/AudioClient.h b/libraries/audio-client/src/AudioClient.h
index d1594bfe83b..913f25d1c25 100644
--- a/libraries/audio-client/src/AudioClient.h
+++ b/libraries/audio-client/src/AudioClient.h
@@ -194,6 +194,23 @@ class AudioClient : public AbstractAudioInterface, public Dependency {
     void setAllowedCodecs(const QStringList &codecs) override;
     void setCodecSettings(const std::vector<Encoder::CodecSettings> &settings ) { _codecSettings = settings; }
 
+    QMap<QString,bool> getEncoderFeatures() override;
+
+    bool getEncoderVBR() override;
+    void setEncoderVBR(bool enabled) override;
+
+    int getEncoderBitrate() override;
+    void setEncoderBitrate(int bitrate) override;
+
+    int getEncoderComplexity() override;
+    void setEncoderComplexity(int complexity) override;
+
+    bool getEncoderFEC() override;
+    void setEncoderFEC(bool enabled) override;
+
+    int getEncoderPacketLossPercent() override;
+    void setEncoderPacketLossPercent(int percent) override;
+
 #ifdef Q_OS_WIN
     static QString getWinDeviceName(wchar_t* guid);
 #endif
diff --git a/libraries/audio/src/AbstractAudioInterface.h b/libraries/audio/src/AbstractAudioInterface.h
index ed566bdb61e..410c5dafbc7 100644
--- a/libraries/audio/src/AbstractAudioInterface.h
+++ b/libraries/audio/src/AbstractAudioInterface.h
@@ -60,6 +60,26 @@ public slots:
     virtual void setAllowedCodecs(const QStringList &codec) = 0;
     virtual QStringList getAllowedCodecs() = 0;
 
+    virtual QMap<QString,bool> getEncoderFeatures() = 0;
+
+    virtual bool getEncoderVBR() = 0;
+    virtual void setEncoderVBR(bool enabled) = 0;
+
+    virtual int getEncoderBitrate() = 0;
+    virtual void setEncoderBitrate(int bitrate) = 0;
+
+    virtual int getEncoderComplexity() = 0;
+    virtual void setEncoderComplexity(int complexity) = 0;
+
+    virtual bool getEncoderFEC() = 0;
+    virtual void setEncoderFEC(bool enabled) = 0;
+
+    virtual int getEncoderPacketLossPercent() = 0;
+    virtual void setEncoderPacketLossPercent(int percent) = 0;
+
+
+
+
 signals:
     void isStereoInputChanged(bool isStereo);
 };
diff --git a/libraries/audio/src/AudioScriptingInterface.cpp b/libraries/audio/src/AudioScriptingInterface.cpp
index 5be024600ae..b3e419aabfa 100644
--- a/libraries/audio/src/AudioScriptingInterface.cpp
+++ b/libraries/audio/src/AudioScriptingInterface.cpp
@@ -167,4 +167,84 @@ QStringList AudioScriptingInterface::getAllowedCodecs() {
     }
 
     return codecs;
+}
+
+QMap<QString,bool> AudioScriptingInterface::getEncoderFeatures() {
+    QMap<QString, bool> features;
+
+    if (_localAudioInterface) {
+        features = _localAudioInterface->getEncoderFeatures();
+    }
+
+    return features;
+}
+
+int AudioScriptingInterface::getEncoderBitrate() {
+    if (_localAudioInterface) {
+        return _localAudioInterface->getEncoderBitrate();
+    }
+
+    return 0;
+}
+
+void AudioScriptingInterface::setEncoderBitrate(int bitrate) {
+    if (_localAudioInterface) {
+        _localAudioInterface->setEncoderBitrate(bitrate);
+    }
+}
+
+int AudioScriptingInterface::getEncoderComplexity() {
+    if (_localAudioInterface) {
+        return _localAudioInterface->getEncoderComplexity();
+    }
+
+    return 0;
+}
+
+void AudioScriptingInterface::setEncoderComplexity(int complexity) {
+    if (_localAudioInterface) {
+        _localAudioInterface->setEncoderComplexity(complexity);
+    }
+}
+
+bool AudioScriptingInterface::getEncoderVBR() {
+    if (_localAudioInterface) {
+        return _localAudioInterface->getEncoderVBR();
+    }
+
+    return 0;
+}
+
+void AudioScriptingInterface::setEncoderVBR(bool enabled) {
+    if (_localAudioInterface) {
+        _localAudioInterface->setEncoderVBR(enabled);
+    }
+}
+
+bool AudioScriptingInterface::getEncoderFEC() {
+    if (_localAudioInterface) {
+        return _localAudioInterface->getEncoderFEC();
+    }
+
+    return 0;
+}
+
+void AudioScriptingInterface::setEncoderFEC(bool enabled) {
+    if (_localAudioInterface) {
+        _localAudioInterface->setEncoderFEC(enabled);
+    }
+}
+
+int AudioScriptingInterface::getEncoderPacketLossPercent() {
+    if (_localAudioInterface) {
+        return _localAudioInterface->getEncoderPacketLossPercent();
+    }
+
+    return 0;
+}
+
+void AudioScriptingInterface::setEncoderPacketLossPercent(int percent) {
+    if (_localAudioInterface) {
+        _localAudioInterface->setEncoderPacketLossPercent(percent);
+    }
 }
\ No newline at end of file
diff --git a/libraries/audio/src/AudioScriptingInterface.h b/libraries/audio/src/AudioScriptingInterface.h
index 3e98d517d0a..0279e17069a 100644
--- a/libraries/audio/src/AudioScriptingInterface.h
+++ b/libraries/audio/src/AudioScriptingInterface.h
@@ -165,6 +165,29 @@ class AudioScriptingInterface : public QObject, public Dependency {
 
     Q_INVOKABLE QStringList getAllowedCodecs();
 
+    Q_INVOKABLE QMap<QString,bool> getEncoderFeatures();
+
+    Q_INVOKABLE int getEncoderBitrate();
+
+    Q_INVOKABLE void setEncoderBitrate(int bitrate);
+
+    Q_INVOKABLE bool getEncoderVBR();
+
+    Q_INVOKABLE void setEncoderVBR(bool enabled);
+
+    Q_INVOKABLE int getEncoderComplexity();
+
+    Q_INVOKABLE void setEncoderComplexity(int complexity);
+
+    Q_INVOKABLE bool getEncoderFEC();
+
+    Q_INVOKABLE void setEncoderFEC(bool enabled);
+
+    Q_INVOKABLE int getEncoderPacketLossPercent();
+
+    Q_INVOKABLE void setEncoderPacketLossPercent(int percent);
+
+
 
 protected:
     AudioScriptingInterface() = default;