diff --git a/modules/juce_osc/osc/juce_OSCReceiver.cpp b/modules/juce_osc/osc/juce_OSCReceiver.cpp
index defc8664d..2b0fe33b1 100644
--- a/modules/juce_osc/osc/juce_OSCReceiver.cpp
+++ b/modules/juce_osc/osc/juce_OSCReceiver.cpp
@@ -412,14 +412,19 @@ struct OSCReceiver::Pimpl   : private Thread,
     //==============================================================================
     struct CallbackMessage   : public Message
     {
-        CallbackMessage (OSCBundle::Element oscElement)  : content (oscElement) {}
+        CallbackMessage (OSCBundle::Element oscElement, const String& senderIPAddress, int senderPort)
+        : content (oscElement)
+        , senderIPAddress(senderIPAddress)
+        , senderPort(senderPort) {}
 
         // the payload of the message. Can be either an OSCMessage or an OSCBundle.
         OSCBundle::Element content;
+        String senderIPAddress;
+        int senderPort;
     };
 
     //==============================================================================
-    void handleBuffer (const char* data, size_t dataSize)
+    void handleBuffer (const char* data, size_t dataSize, const String& senderIPAddress, int senderPort)
     {
         OSCInputStream inStream (data, dataSize);
 
@@ -429,15 +434,15 @@ struct OSCReceiver::Pimpl   : private Thread,
 
             // realtime listeners should receive the OSC content first - and immediately
             // on this thread:
-            callRealtimeListeners (content);
+            callRealtimeListeners (content, senderIPAddress, senderPort);
 
             if (content.isMessage())
-                callRealtimeListenersWithAddress (content.getMessage());
+                callRealtimeListenersWithAddress (content.getMessage(), senderIPAddress, senderPort);
 
             // now post the message that will trigger the handleMessage callback
             // dealing with the non-realtime listeners.
             if (listeners.size() > 0 || listenersWithAddress.size() > 0)
-                postMessage (new CallbackMessage (content));
+                postMessage (new CallbackMessage (content, senderIPAddress, senderPort));
         }
         catch (const OSCFormatError&)
         {
@@ -470,10 +475,13 @@ private:
             if (ready == 0)
                 continue;
 
-            auto bytesRead = (size_t) socket->read (oscBuffer.getData(), bufferSize, false);
+            String senderIPAddress;
+            int senderPort;
+
+            auto bytesRead = (size_t) socket->read (oscBuffer.getData(), bufferSize, false, senderIPAddress, senderPort);
 
             if (bytesRead >= 4)
-                handleBuffer (oscBuffer.getData(), bytesRead);
+                handleBuffer (oscBuffer.getData(), bytesRead, senderIPAddress, senderPort);
         }
     }
 
@@ -516,61 +524,61 @@ private:
         {
             auto& content = callbackMessage->content;
 
-            callListeners (content);
+            callListeners (content, callbackMessage->senderIPAddress, callbackMessage->senderPort);
 
             if (content.isMessage())
-                callListenersWithAddress (content.getMessage());
+                callListenersWithAddress (content.getMessage(), callbackMessage->senderIPAddress, callbackMessage->senderPort);
         }
     }
 
     //==============================================================================
-    void callListeners (const OSCBundle::Element& content)
+    void callListeners (const OSCBundle::Element& content, const String& senderIPAddress, int senderPortNumber)
     {
         using Listener = OSCReceiver::Listener<OSCReceiver::MessageLoopCallback>;
 
         if (content.isMessage())
         {
             auto&& message = content.getMessage();
-            listeners.call ([&] (Listener& l) { l.oscMessageReceived (message); });
+            listeners.call ([&] (Listener& l) { l.oscMessageReceived (message, senderIPAddress, senderPortNumber); });
         }
         else if (content.isBundle())
         {
             auto&& bundle = content.getBundle();
-            listeners.call ([&] (Listener& l) { l.oscBundleReceived (bundle); });
+            listeners.call ([&] (Listener& l) { l.oscBundleReceived (bundle, senderIPAddress, senderPortNumber); });
         }
     }
 
-    void callRealtimeListeners (const OSCBundle::Element& content)
+    void callRealtimeListeners (const OSCBundle::Element& content, const String& senderIPAddress, int senderPortNumber)
     {
         using Listener = OSCReceiver::Listener<OSCReceiver::RealtimeCallback>;
 
         if (content.isMessage())
         {
             auto&& message = content.getMessage();
-            realtimeListeners.call ([&] (Listener& l) { l.oscMessageReceived (message); });
+            realtimeListeners.call ([&] (Listener& l) { l.oscMessageReceived (message, senderIPAddress, senderPortNumber); });
         }
         else if (content.isBundle())
         {
             auto&& bundle = content.getBundle();
-            realtimeListeners.call ([&] (Listener& l) { l.oscBundleReceived (bundle); });
+            realtimeListeners.call ([&] (Listener& l) { l.oscBundleReceived (bundle, senderIPAddress, senderPortNumber); });
         }
     }
 
     //==============================================================================
-    void callListenersWithAddress (const OSCMessage& message)
+    void callListenersWithAddress (const OSCMessage& message, const String& senderIPAddress, int senderPortNumber)
     {
         for (auto& entry : listenersWithAddress)
             if (auto* listener = entry.second)
                 if (message.getAddressPattern().matches (entry.first))
-                    listener->oscMessageReceived (message);
+                    listener->oscMessageReceived (message, senderIPAddress, senderPortNumber);
     }
 
-    void callRealtimeListenersWithAddress (const OSCMessage& message)
+    void callRealtimeListenersWithAddress (const OSCMessage& message, const String& senderIPAddress, int senderPortNumber)
     {
         for (auto& entry : realtimeListenersWithAddress)
             if (auto* listener = entry.second)
                 if (message.getAddressPattern().matches (entry.first))
-                    listener->oscMessageReceived (message);
+                    listener->oscMessageReceived (message, senderIPAddress, senderPortNumber);
     }
 
     //==============================================================================
diff --git a/modules/juce_osc/osc/juce_OSCReceiver.h b/modules/juce_osc/osc/juce_OSCReceiver.h
index a98359acb..61d752cf3 100644
--- a/modules/juce_osc/osc/juce_OSCReceiver.h
+++ b/modules/juce_osc/osc/juce_OSCReceiver.h
@@ -117,11 +117,29 @@ public:
         */
         virtual void oscMessageReceived (const OSCMessage& message) = 0;
 
+        /** This version also receives the IP and port of the sender.
+            The default implementation just passes the message to the
+            other version.
+        */
+        virtual void oscMessageReceived (const OSCMessage& message, const String& senderIPAddress, int senderPortNumber)
+        {
+            oscMessageReceived(message);
+        }
+
         /** Called when the OSCReceiver receives a new OSC bundle.
             If you are not interested in OSC bundles, just ignore this method.
             The default implementation provided here will simply do nothing.
         */
         virtual void oscBundleReceived (const OSCBundle& /*bundle*/) {}
+
+        /** This version also receives the IP and port of the sender.
+            The default implementation just passes the message to the
+            other version.
+        */
+        virtual void oscBundleReceived (const OSCBundle& bundle, const String& /*senderIPAddress*/, int /*senderPortNumber*/)
+        {
+            oscBundleReceived(bundle);
+        }
     };
 
     //==============================================================================
@@ -155,7 +173,16 @@ public:
         /** Called when the OSCReceiver receives an OSC message with an OSC address
             pattern that matches the OSC address with which this listener was added.
         */
-        virtual void oscMessageReceived (const OSCMessage& message) = 0;
+        virtual void oscMessageReceived (const OSCMessage& message) {};
+
+        /** This version also receives the IP and port of the sender.
+            The default implementation just passes the message to the
+            other version.
+        */
+        virtual void oscMessageReceived (const OSCMessage& message, const String& /*senderIPAddress*/, int /*senderPortNumber*/)
+        {
+            oscMessageReceived(message);
+        }
     };
 
     //==============================================================================