diff --git a/spec/ParseLiveQuery.spec.js b/spec/ParseLiveQuery.spec.js
index 80eebaa733..899d9c85a3 100644
--- a/spec/ParseLiveQuery.spec.js
+++ b/spec/ParseLiveQuery.spec.js
@@ -16,7 +16,7 @@ describe('ParseLiveQuery', function () {
     const query = new Parse.Query(TestObject);
     query.equalTo('objectId', object.id);
     const subscription = await query.subscribe();
-    subscription.on('update', async object => {
+    subscription.on('update', object => {
       expect(object.get('foo')).toBe('bar');
       done();
     });
@@ -24,6 +24,254 @@ describe('ParseLiveQuery', function () {
     await object.save();
   });
 
+  it('expect afterEvent create', async done => {
+    await reconfigureServer({
+      liveQuery: {
+        classNames: ['TestObject'],
+      },
+      startLiveQueryServer: true,
+      verbose: false,
+      silent: true,
+    });
+    Parse.Cloud.afterLiveQueryEvent('TestObject', req => {
+      expect(req.event).toBe('Create');
+      expect(req.user).toBeUndefined();
+      expect(req.current.get('foo')).toBe('bar');
+    });
+
+    const query = new Parse.Query(TestObject);
+    const subscription = await query.subscribe();
+    subscription.on('create', object => {
+      expect(object.get('foo')).toBe('bar');
+      done();
+    });
+
+    const object = new TestObject();
+    object.set('foo', 'bar');
+    await object.save();
+  });
+
+  it('expect afterEvent payload', async done => {
+    await reconfigureServer({
+      liveQuery: {
+        classNames: ['TestObject'],
+      },
+      startLiveQueryServer: true,
+      verbose: false,
+      silent: true,
+    });
+    const object = new TestObject();
+    await object.save();
+
+    Parse.Cloud.afterLiveQueryEvent('TestObject', req => {
+      expect(req.event).toBe('Update');
+      expect(req.user).toBeUndefined();
+      expect(req.current.get('foo')).toBe('bar');
+      expect(req.original.get('foo')).toBeUndefined();
+      done();
+    });
+
+    const query = new Parse.Query(TestObject);
+    query.equalTo('objectId', object.id);
+    await query.subscribe();
+    object.set({ foo: 'bar' });
+    await object.save();
+  });
+
+  it('expect afterEvent enter', async done => {
+    await reconfigureServer({
+      liveQuery: {
+        classNames: ['TestObject'],
+      },
+      startLiveQueryServer: true,
+      verbose: false,
+      silent: true,
+    });
+    Parse.Cloud.afterLiveQueryEvent('TestObject', req => {
+      expect(req.event).toBe('Enter');
+      expect(req.user).toBeUndefined();
+      expect(req.current.get('foo')).toBe('bar');
+      expect(req.original.get('foo')).toBeUndefined();
+    });
+
+    const object = new TestObject();
+    await object.save();
+
+    const query = new Parse.Query(TestObject);
+    query.equalTo('foo', 'bar');
+    const subscription = await query.subscribe();
+    subscription.on('enter', object => {
+      expect(object.get('foo')).toBe('bar');
+      done();
+    });
+
+    object.set('foo', 'bar');
+    await object.save();
+  });
+
+  it('expect afterEvent leave', async done => {
+    await reconfigureServer({
+      liveQuery: {
+        classNames: ['TestObject'],
+      },
+      startLiveQueryServer: true,
+      verbose: false,
+      silent: true,
+    });
+    Parse.Cloud.afterLiveQueryEvent('TestObject', req => {
+      expect(req.event).toBe('Leave');
+      expect(req.user).toBeUndefined();
+      expect(req.current.get('foo')).toBeUndefined();
+      expect(req.original.get('foo')).toBe('bar');
+    });
+
+    const object = new TestObject();
+    object.set('foo', 'bar');
+    await object.save();
+
+    const query = new Parse.Query(TestObject);
+    query.equalTo('foo', 'bar');
+    const subscription = await query.subscribe();
+    subscription.on('leave', object => {
+      expect(object.get('foo')).toBeUndefined();
+      done();
+    });
+
+    object.unset('foo');
+    await object.save();
+  });
+
+  it('can handle afterEvent modification', async done => {
+    await reconfigureServer({
+      liveQuery: {
+        classNames: ['TestObject'],
+      },
+      startLiveQueryServer: true,
+      verbose: false,
+      silent: true,
+    });
+    const object = new TestObject();
+    await object.save();
+
+    Parse.Cloud.afterLiveQueryEvent('TestObject', req => {
+      const current = req.current;
+      current.set('foo', 'yolo');
+
+      const original = req.original;
+      original.set('yolo', 'foo');
+    });
+
+    const query = new Parse.Query(TestObject);
+    query.equalTo('objectId', object.id);
+    const subscription = await query.subscribe();
+    subscription.on('update', (object, original) => {
+      expect(object.get('foo')).toBe('yolo');
+      expect(original.get('yolo')).toBe('foo');
+      done();
+    });
+    object.set({ foo: 'bar' });
+    await object.save();
+  });
+
+  it('can return different object in afterEvent', async done => {
+    await reconfigureServer({
+      liveQuery: {
+        classNames: ['TestObject'],
+      },
+      startLiveQueryServer: true,
+      verbose: false,
+      silent: true,
+    });
+    const object = new TestObject();
+    await object.save();
+
+    Parse.Cloud.afterLiveQueryEvent('TestObject', () => {
+      const object = new Parse.Object('Yolo');
+      return object;
+    });
+
+    const query = new Parse.Query(TestObject);
+    query.equalTo('objectId', object.id);
+    const subscription = await query.subscribe();
+    subscription.on('update', object => {
+      expect(object.className).toBe('Yolo');
+      done();
+    });
+    object.set({ foo: 'bar' });
+    await object.save();
+  });
+
+  it('can handle async afterEvent modification', async done => {
+    await reconfigureServer({
+      liveQuery: {
+        classNames: ['TestObject'],
+      },
+      startLiveQueryServer: true,
+      verbose: false,
+      silent: true,
+    });
+    const parent = new TestObject();
+    const child = new TestObject();
+    child.set('bar', 'foo');
+    await Parse.Object.saveAll([parent, child]);
+
+    Parse.Cloud.afterLiveQueryEvent('TestObject', async req => {
+      const current = req.current;
+      const pointer = current.get('child');
+      await pointer.fetch();
+    });
+
+    const query = new Parse.Query(TestObject);
+    query.equalTo('objectId', parent.id);
+    const subscription = await query.subscribe();
+    subscription.on('update', object => {
+      expect(object.get('child')).toBeDefined();
+      expect(object.get('child').get('bar')).toBe('foo');
+      done();
+    });
+    parent.set('child', child);
+    await parent.save();
+  });
+
+  it('can handle afterEvent throw', async done => {
+    await reconfigureServer({
+      liveQuery: {
+        classNames: ['TestObject'],
+      },
+      startLiveQueryServer: true,
+      verbose: false,
+      silent: true,
+    });
+
+    const object = new TestObject();
+    await object.save();
+
+    Parse.Cloud.afterLiveQueryEvent('TestObject', req => {
+      const current = req.current;
+      const original = req.original;
+
+      setTimeout(() => {
+        done();
+      }, 2000);
+
+      if (current.get('foo') != original.get('foo')) {
+        throw "Don't pass an update trigger, or message";
+      }
+    });
+
+    const query = new Parse.Query(TestObject);
+    query.equalTo('objectId', object.id);
+    const subscription = await query.subscribe();
+    subscription.on('update', () => {
+      fail('update should not have been called.');
+    });
+    subscription.on('error', () => {
+      fail('error should not have been called.');
+    });
+    object.set({ foo: 'bar' });
+    await object.save();
+  });
+
   it('can handle beforeConnect / beforeSubscribe hooks', async done => {
     await reconfigureServer({
       liveQuery: {
@@ -56,7 +304,7 @@ describe('ParseLiveQuery', function () {
     const query = new Parse.Query(TestObject);
     query.equalTo('objectId', object.id);
     const subscription = await query.subscribe();
-    subscription.on('update', async object => {
+    subscription.on('update', object => {
       expect(object.get('foo')).toBe('bar');
       done();
     });
diff --git a/src/LiveQuery/ParseLiveQueryServer.js b/src/LiveQuery/ParseLiveQueryServer.js
index 5d28367961..8123e21498 100644
--- a/src/LiveQuery/ParseLiveQueryServer.js
+++ b/src/LiveQuery/ParseLiveQueryServer.js
@@ -14,6 +14,7 @@ import {
   runLiveQueryEventHandlers,
   maybeRunConnectTrigger,
   maybeRunSubscribeTrigger,
+  maybeRunAfterEventTrigger,
 } from '../triggers';
 import { getAuthForSessionToken, Auth } from '../Auth';
 import { getCacheController } from '../Controllers';
@@ -193,7 +194,7 @@ class ParseLiveQueryServer {
       originalParseObject = message.originalParseObject.toJSON();
     }
     const classLevelPermissions = message.classLevelPermissions;
-    const currentParseObject = message.currentParseObject.toJSON();
+    let currentParseObject = message.currentParseObject.toJSON();
     const className = currentParseObject.className;
     logger.verbose(
       'ClassName: %s | ObjectId: %s',
@@ -243,6 +244,7 @@ class ParseLiveQueryServer {
           // Set current ParseObject ACL checking promise, if the object does not match
           // subscription, we do not need to check ACL
           let currentACLCheckingPromise;
+          let res;
           if (!isCurrentSubscriptionMatched) {
             currentACLCheckingPromise = Promise.resolve(false);
           } else {
@@ -267,35 +269,58 @@ class ParseLiveQueryServer {
                 currentACLCheckingPromise,
               ]);
             })
-            .then(
-              ([isOriginalMatched, isCurrentMatched]) => {
-                logger.verbose(
-                  'Original %j | Current %j | Match: %s, %s, %s, %s | Query: %s',
-                  originalParseObject,
-                  currentParseObject,
-                  isOriginalSubscriptionMatched,
-                  isCurrentSubscriptionMatched,
-                  isOriginalMatched,
-                  isCurrentMatched,
-                  subscription.hash
-                );
-
-                // Decide event type
-                let type;
-                if (isOriginalMatched && isCurrentMatched) {
-                  type = 'Update';
-                } else if (isOriginalMatched && !isCurrentMatched) {
-                  type = 'Leave';
-                } else if (!isOriginalMatched && isCurrentMatched) {
-                  if (originalParseObject) {
-                    type = 'Enter';
-                  } else {
-                    type = 'Create';
-                  }
+            .then(([isOriginalMatched, isCurrentMatched]) => {
+              logger.verbose(
+                'Original %j | Current %j | Match: %s, %s, %s, %s | Query: %s',
+                originalParseObject,
+                currentParseObject,
+                isOriginalSubscriptionMatched,
+                isCurrentSubscriptionMatched,
+                isOriginalMatched,
+                isCurrentMatched,
+                subscription.hash
+              );
+
+              // Decide event type
+              let type;
+              if (isOriginalMatched && isCurrentMatched) {
+                type = 'Update';
+              } else if (isOriginalMatched && !isCurrentMatched) {
+                type = 'Leave';
+              } else if (!isOriginalMatched && isCurrentMatched) {
+                if (originalParseObject) {
+                  type = 'Enter';
                 } else {
-                  return null;
+                  type = 'Create';
+                }
+              } else {
+                return null;
+              }
+              message.event = type;
+              res = {
+                event: type,
+                sessionToken: client.sessionToken,
+                current: currentParseObject,
+                original: originalParseObject,
+              };
+              return maybeRunAfterEventTrigger('afterEvent', className, res);
+            })
+            .then(
+              newObj => {
+                if (res.current != currentParseObject) {
+                  currentParseObject = res.current.toJSON();
+                  currentParseObject.className = className;
                 }
-                const functionName = 'push' + type;
+                if (res.original != originalParseObject) {
+                  originalParseObject = res.original.toJSON();
+                  originalParseObject.className = className;
+                }
+                if (newObj) {
+                  currentParseObject = newObj.toJSON();
+                  currentParseObject.className = newObj.className;
+                }
+
+                const functionName = 'push' + message.event;
                 client[functionName](
                   requestId,
                   currentParseObject,
diff --git a/src/cloud-code/Parse.Cloud.js b/src/cloud-code/Parse.Cloud.js
index 088c4dc3c1..2ea210bccc 100644
--- a/src/cloud-code/Parse.Cloud.js
+++ b/src/cloud-code/Parse.Cloud.js
@@ -511,6 +511,16 @@ ParseCloud.onLiveQueryEvent = function (handler) {
   triggers.addLiveQueryEventHandler(handler, Parse.applicationId);
 };
 
+ParseCloud.afterLiveQueryEvent = function (parseClass, handler) {
+  const className = getClassName(parseClass);
+  triggers.addTrigger(
+    triggers.Types.afterEvent,
+    className,
+    handler,
+    Parse.applicationId
+  );
+};
+
 ParseCloud._removeAllHooks = () => {
   triggers._unregisterAll();
 };
diff --git a/src/triggers.js b/src/triggers.js
index 96dcb65e47..0e614a5433 100644
--- a/src/triggers.js
+++ b/src/triggers.js
@@ -18,6 +18,7 @@ export const Types = {
   afterDeleteFile: 'afterDeleteFile',
   beforeConnect: 'beforeConnect',
   beforeSubscribe: 'beforeSubscribe',
+  afterEvent: 'afterEvent',
 };
 
 const FileClassName = '@File';
@@ -781,6 +782,25 @@ export async function maybeRunConnectTrigger(triggerType, request) {
   return trigger(request);
 }
 
+export async function maybeRunAfterEventTrigger(
+  triggerType,
+  className,
+  request
+) {
+  const trigger = getTrigger(className, triggerType, Parse.applicationId);
+  if (!trigger) {
+    return;
+  }
+  if (request.current) {
+    request.current = Parse.Object.fromJSON(request.current);
+  }
+  if (request.original) {
+    request.original = Parse.Object.fromJSON(request.original);
+  }
+  request.user = await userForSessionToken(request.sessionToken);
+  return trigger(request);
+}
+
 export async function maybeRunSubscribeTrigger(
   triggerType,
   className,