diff --git a/backbone.js b/backbone.js
index f08ecdf9..f4cfabd2 100644
--- a/backbone.js
+++ b/backbone.js
@@ -190,25 +190,27 @@
 
     // An inversion-of-control version of `on`. Tell *this* object to listen to
     // an event in another object ... keeping track of what it's listening to.
-    listenTo: function(object, events, callback) {
+    listenTo: function(object, events, callback, context) {
+      context = context || this;
       var listeners = this._listeners || (this._listeners = {});
       var id = object._listenerId || (object._listenerId = _.uniqueId('l'));
       listeners[id] = object;
-      object.on(events, callback || this, this);
+      object.on(events, callback || context, context);
       return this;
     },
 
     // Tell this object to stop listening to either specific events ... or
     // to every object it's currently listening to.
-    stopListening: function(object, events, callback) {
+    stopListening: function(object, events, callback, context) {
+      context = context || this;
       var listeners = this._listeners;
       if (!listeners) return;
       if (object) {
-        object.off(events, callback, this);
+        object.off(events, callback, context);
         if (!events && !callback) delete listeners[object._listenerId];
       } else {
         for (var id in listeners) {
-          listeners[id].off(null, null, this);
+          listeners[id].off(null, null, context);
         }
         this._listeners = {};
       }
diff --git a/index.html b/index.html
index 5f90e72b..096bedac 100644
--- a/index.html
+++ b/index.html
@@ -773,10 +773,10 @@ object.off();
     </p>
 
     <p id="Events-listenTo">
-      <b class="header">listenTo</b><code>object.listenTo(other, event, callback)</code>
+      <b class="header">listenTo</b><code>object.listenTo(other, event, callback, [context])</code>
       <br />
       Tell an <b>object</b> to listen to a particular event on an <b>other</b> object.
-      The advantage of using this form, instead of <tt>other.on(event, callback)</tt>,
+      The advantage of using this form, instead of <tt>other.on(event, callback, [context])</tt>,
       is that <b>listenTo</b> allows the <b>object</b> to keep track of the events,
       and they can be removed all at once later on.
     </p>
@@ -786,7 +786,7 @@ view.listenTo(model, 'change', view.render);
 </pre>
 
     <p id="Events-stopListening">
-      <b class="header">stopListening</b><code>object.stopListening([other], [event], [callback])</code>
+      <b class="header">stopListening</b><code>object.stopListening([other], [event], [callback], [context])</code>
       <br />
       Tell an <b>object</b> to stop listening to events. Either call
       <b>stopListening</b> with no arguments to have the <b>object</b> remove
diff --git a/test/events.js b/test/events.js
index c3f1d61d..946c25bb 100644
--- a/test/events.js
+++ b/test/events.js
@@ -86,6 +86,30 @@ $(document).ready(function() {
     b.trigger('change');
   });
 
+  test("listenTo with context", 1, function() {
+    var a = _.extend({}, Backbone.Events);
+    var ctx = {};
+    a.listenTo(a, 'foo', function(){ equal(this, ctx); }, ctx);
+    a.trigger('foo');
+  });
+
+  test("stopListening with context", 2, function() {
+    var a = _.extend({}, Backbone.Events);
+    var ctx = {};
+    var calledWithContext = false;
+    var calledWithoutContext = false;
+
+    a.listenTo(a, 'foo', function(){ calledWithContext = true; }, ctx);
+    a.listenTo(a, 'foo', function(){ calledWithoutContext = true; });
+
+    a.stopListening(a, 'foo', null, ctx);
+
+    a.trigger('foo');
+
+    equal(false, calledWithContext);
+    equal(true, calledWithoutContext);
+  });
+
   test("trigger all for each event", 3, function() {
     var a, b, obj = { counter: 0 };
     _.extend(obj, Backbone.Events);