diff --git a/src/accounts/hatchet/account/HatchetAccount.cpp b/src/accounts/hatchet/account/HatchetAccount.cpp
index 3c0652e2a..0a92b6bf5 100644
--- a/src/accounts/hatchet/account/HatchetAccount.cpp
+++ b/src/accounts/hatchet/account/HatchetAccount.cpp
@@ -183,8 +183,6 @@ HatchetAccount::sipPlugin( bool create )
 
         tLog() << Q_FUNC_INFO;
         m_tomahawkSipPlugin = QPointer< HatchetSipPlugin >( new HatchetSipPlugin( this ) );
-        connect( m_tomahawkSipPlugin.data(), SIGNAL( authUrlDiscovered( Tomahawk::Accounts::HatchetAccount::Service, QString ) ),
-                 this, SLOT( authUrlDiscovered( Tomahawk::Accounts::HatchetAccount::Service, QString ) ) );
 
         return m_tomahawkSipPlugin.data();
     }
@@ -524,20 +522,6 @@ HatchetAccount::onFetchAccessTokenFinished( QNetworkReply* reply, const QString&
 }
 
 
-QString
-HatchetAccount::authUrlForService( const Service &service ) const
-{
-    return m_extraAuthUrls.value( service, QString() );
-}
-
-
-void
-HatchetAccount::authUrlDiscovered( Service service, const QString &authUrl )
-{
-    m_extraAuthUrls[ service ] = authUrl;
-}
-
-
 QVariantMap
 HatchetAccount::parseReply( QNetworkReply* reply, bool& okRet ) const
 {
diff --git a/src/accounts/hatchet/account/HatchetAccount.h b/src/accounts/hatchet/account/HatchetAccount.h
index 06c10c122..5034de69c 100644
--- a/src/accounts/hatchet/account/HatchetAccount.h
+++ b/src/accounts/hatchet/account/HatchetAccount.h
@@ -89,8 +89,6 @@ public:
 
     void fetchAccessToken( const QString& type = "dreamcatcher" );
 
-    QString authUrlForService( const Service& service ) const;
-
 signals:
     void authError( QString error, int statusCode, const QVariantMap );
     void deauthenticated();
@@ -99,7 +97,6 @@ signals:
 private slots:
     void onPasswordLoginFinished( QNetworkReply*, const QString& username );
     void onFetchAccessTokenFinished( QNetworkReply*, const QString& type );
-    void authUrlDiscovered( Tomahawk::Accounts::HatchetAccount::Service service, const QString& authUrl );
 
 private:
     QByteArray refreshToken() const;
@@ -119,7 +116,6 @@ private:
     Account::ConnectionState m_state;
 
     QPointer< HatchetSipPlugin > m_tomahawkSipPlugin;
-    QHash< Service, QString > m_extraAuthUrls;
 
     static HatchetAccount* s_instance;
     friend class HatchetAccountConfig;
diff --git a/src/accounts/hatchet/sip/HatchetSip.h b/src/accounts/hatchet/sip/HatchetSip.h
index 64d3754a5..426b7f1b6 100644
--- a/src/accounts/hatchet/sip/HatchetSip.h
+++ b/src/accounts/hatchet/sip/HatchetSip.h
@@ -65,7 +65,6 @@ public slots:
 signals:
     void connectWebSocket() const;
     void disconnectWebSocket() const;
-    void authUrlDiscovered( Tomahawk::Accounts::HatchetAccount::Service service, const QString& authUrl ) const;
     void rawBytes( QByteArray bytes ) const;
 
 private slots:
diff --git a/src/accounts/hatchet/sip/WebSocket.cpp b/src/accounts/hatchet/sip/WebSocket.cpp
index 25aac9555..6d6a7975f 100644
--- a/src/accounts/hatchet/sip/WebSocket.cpp
+++ b/src/accounts/hatchet/sip/WebSocket.cpp
@@ -23,10 +23,11 @@
 
 typedef typename websocketpp::lib::error_code error_code;
 
-WebSocket::WebSocket( const QString& url )
+WebSocket::WebSocket( const QString& url, const QString& authorizationHeader )
     : QObject( nullptr )
     , m_disconnecting( false )
     , m_url( url )
+    , m_authorizationHeader( authorizationHeader )
     , m_outputStream()
     , m_lastSocketState( QAbstractSocket::UnconnectedState )
     , m_connectionTimer( this )
@@ -46,12 +47,16 @@ WebSocket::WebSocket( const QString& url )
 WebSocket::~WebSocket()
 {
     if ( m_connection )
+    {
         m_connection.reset();
+    }
 
     m_client.reset();
 
     if ( m_socket )
+    {
         delete m_socket.data();
+    }
 }
 
 
@@ -60,11 +65,32 @@ WebSocket::setUrl( const QString &url )
 {
     tLog() << Q_FUNC_INFO << "Setting url to" << url;
     if ( m_url == url )
+    {
         return;
+    }
 
     // We'll let automatic reconnection handle things
     if ( m_socket && m_socket->isEncrypted() )
+    {
         disconnectWs();
+    }
+}
+
+
+void
+WebSocket::setAuthorizationHeader( const QString &authorizationHeader )
+{
+    tLog() << Q_FUNC_INFO << "Setting authorization header";
+    if ( m_authorizationHeader == authorizationHeader )
+    {
+        return;
+    }
+
+    // We'll let automatic reconnection handle things
+    if ( m_socket && m_socket->isEncrypted() )
+    {
+        disconnectWs();
+    }
 }
 
 
@@ -76,10 +102,14 @@ WebSocket::connectWs()
     if ( m_socket )
     {
         if ( m_socket->isEncrypted() )
+        {
             return;
+        }
 
         if ( m_socket->state() == QAbstractSocket::ClosingState )
+        {
             QMetaObject::invokeMethod( this, "connectWs", Qt::QueuedConnection );
+        }
 
         return;
     }
@@ -119,9 +149,13 @@ void
 WebSocket::disconnectSocket()
 {
     if ( m_socket && m_socket->state() == QAbstractSocket::ConnectedState )
+    {
         m_socket->disconnectFromHost();
+    }
     else
+    {
         QMetaObject::invokeMethod( this, "cleanup", Qt::QueuedConnection );
+    }
 
     QTimer::singleShot( 5000, this, SLOT( cleanup() ) ); //safety
 }
@@ -178,7 +212,9 @@ WebSocket::sslErrors( const QList< QSslError >& errors )
 {
     tLog() << Q_FUNC_INFO << "Encountered errors when trying to connect via SSL";
     foreach( QSslError error, errors )
+    {
         tLog() << Q_FUNC_INFO << "Error: " << error.errorString();
+    }
     QMetaObject::invokeMethod( this, "disconnectWs", Qt::QueuedConnection );
 }
 
@@ -199,6 +235,10 @@ WebSocket::encrypted()
         disconnectWs();
         return;
     }
+    if ( !m_authorizationHeader.isEmpty() )
+    {
+        m_connection->replace_header( "Authorization", m_authorizationHeader.toStdString() );
+    }
     m_client->connect( m_connection );
     QMetaObject::invokeMethod( this, "readOutput", Qt::QueuedConnection );
     emit connected();
@@ -241,17 +281,23 @@ WebSocket::readOutput()
             m_connectionTimer.stop();
         }
         else if ( !m_disconnecting )
+        {
             QTimer::singleShot( 200, this, SLOT( readOutput() ) );
+        }
     }
     else
+    {
         m_connectionTimer.stop();
+    }
 }
 
 void
 WebSocket::socketReadyRead()
 {
     if ( !m_socket || !m_socket->isEncrypted() )
+    {
         return;
+    }
 
     if ( !m_socket->isValid() )
     {
@@ -296,7 +342,9 @@ WebSocket::encodeMessage( const QByteArray &bytes )
         m_connectionTimer.start();
     }
     else
+    {
         m_connection->send( std::string( bytes.constData() ), websocketpp::frame::opcode::TEXT );
+    }
 
     QMetaObject::invokeMethod( this, "readOutput", Qt::QueuedConnection );
 }
diff --git a/src/accounts/hatchet/sip/WebSocket.h b/src/accounts/hatchet/sip/WebSocket.h
index 2ff69fe15..08a48eda9 100644
--- a/src/accounts/hatchet/sip/WebSocket.h
+++ b/src/accounts/hatchet/sip/WebSocket.h
@@ -39,7 +39,7 @@ class WebSocket : public QObject
 {
     Q_OBJECT
 public:
-    explicit WebSocket( const QString& url );
+    explicit WebSocket( const QString& url, const QString& authorizationHeader = QString() );
     virtual ~WebSocket();
 
 signals:
@@ -49,6 +49,7 @@ signals:
 
 public slots:
     void setUrl( const QString& url );
+    void setAuthorizationHeader( const QString& authorizationHeader );
     void connectWs();
     void disconnectWs( websocketpp::close::status::value status = websocketpp::close::status::normal, const QString& reason = QString( "Disconnecting" ) );
     void encodeMessage( const QByteArray& bytes );
@@ -70,6 +71,7 @@ private:
 
     bool m_disconnecting;
     QUrl m_url;
+    QString m_authorizationHeader;
     std::stringstream m_outputStream;
     std::unique_ptr< hatchet_client > m_client;
     hatchet_client::connection_ptr m_connection;
diff --git a/src/accounts/hatchet/sip/WebSocketThreadController.cpp b/src/accounts/hatchet/sip/WebSocketThreadController.cpp
index 86beed07a..e0b16960e 100644
--- a/src/accounts/hatchet/sip/WebSocketThreadController.cpp
+++ b/src/accounts/hatchet/sip/WebSocketThreadController.cpp
@@ -49,11 +49,22 @@ WebSocketThreadController::setUrl( const QString &url )
 }
 
 
+void
+WebSocketThreadController::setAuthorizationHeader( const QString &authorizationHeader )
+{
+    m_authorizationHeader = authorizationHeader;
+    if ( m_webSocket )
+    {
+        QMetaObject::invokeMethod( m_webSocket, "setAuthorizationHeader", Qt::QueuedConnection, Q_ARG( QString, authorizationHeader ));
+    }
+}
+
+
 void
 WebSocketThreadController::run()
 {
     tLog() << Q_FUNC_INFO << "Starting";
-    m_webSocket = QPointer< WebSocket >( new WebSocket( m_url ) );
+    m_webSocket = QPointer< WebSocket >( new WebSocket( m_url, m_authorizationHeader ) );
     if ( m_webSocket && m_sip )
     {
         tLog() << Q_FUNC_INFO << "Have a valid websocket and parent";
diff --git a/src/accounts/hatchet/sip/WebSocketThreadController.h b/src/accounts/hatchet/sip/WebSocketThreadController.h
index 0964fffad..e69e041c5 100644
--- a/src/accounts/hatchet/sip/WebSocketThreadController.h
+++ b/src/accounts/hatchet/sip/WebSocketThreadController.h
@@ -32,6 +32,7 @@ public:
     virtual ~WebSocketThreadController();
 
     void setUrl( const QString &url );
+    void setAuthorizationHeader( const QString &authorizationHeader );
 
 protected:
     void run();
@@ -42,6 +43,7 @@ private:
     QPointer< WebSocket > m_webSocket;
     QPointer< QObject > m_sip;
     QString m_url;
+    QString m_authorizationHeader;
 };
 
 #endif