diff --git a/src/CoreManager.js b/src/CoreManager.js
index 9a5881dcc..75cad7c54 100644
--- a/src/CoreManager.js
+++ b/src/CoreManager.js
@@ -121,7 +121,8 @@ type UserController = {
   logIn: (user: ParseUser, options: RequestOptions) => Promise;
   become: (options: RequestOptions) => Promise;
   hydrate: (userJSON: AttributeMap) => Promise;
-  logOut: () => Promise;
+  logOut: (options: RequestOptions) => Promise;
+  me: (options: RequestOptions) => Promise;
   requestPasswordReset: (email: string, options: RequestOptions) => Promise;
   updateUserOnDisk: (user: ParseUser) => Promise;
   upgradeToRevocableSession: (user: ParseUser, options: RequestOptions) => Promise;
@@ -378,6 +379,7 @@ module.exports = {
       'logIn',
       'become',
       'logOut',
+      'me',
       'requestPasswordReset',
       'upgradeToRevocableSession',
       'linkWith',
diff --git a/src/ParseUser.js b/src/ParseUser.js
index 7cbefa948..7f1d03e9c 100644
--- a/src/ParseUser.js
+++ b/src/ParseUser.js
@@ -651,6 +651,25 @@ class ParseUser extends ParseObject {
     return controller.become(becomeOptions);
   }
 
+  /**
+   * Retrieves a user with a session token.
+   *
+   * @param {String} sessionToken The sessionToken to get user with.
+   * @param {Object} options
+   * @static
+   * @return {Promise} A promise that is fulfilled with the user is fetched.
+   */
+  static me(sessionToken: string, options?: RequestOptions = {}) {
+    const controller = CoreManager.getUserController();
+    const meOptions: RequestOptions = {
+      sessionToken: sessionToken
+    };
+    if (options.useMasterKey) {
+      meOptions.useMasterKey = options.useMasterKey;
+    }
+    return controller.me(meOptions);
+  }
+
   /**
    * Logs in a user with a session token. On success, this saves the session
    * to disk, so you can retrieve the currently logged in user using
@@ -674,20 +693,15 @@ class ParseUser extends ParseObject {
    * Logs out the currently logged in user session. This will remove the
    * session from disk, log out of linked services, and future calls to
    * <code>current</code> will return <code>null</code>.
-
+   *
+   * @param {Object} options
    * @static
    * @return {Promise} A promise that is resolved when the session is
    *   destroyed on the server.
    */
-  static logOut() {
-    if (!canUseCurrentUser) {
-      throw new Error(
-        'There is no current user on a node.js server environment.'
-      );
-    }
-
+  static logOut(options: RequestOptions = {}) {
     const controller = CoreManager.getUserController();
-    return controller.logOut();
+    return controller.logOut(options);
   }
 
   /**
@@ -998,11 +1012,28 @@ const DefaultController = {
     }
   },
 
-  logOut(): Promise<ParseUser> {
+  me(options: RequestOptions): Promise<ParseUser> {
+    const RESTController = CoreManager.getRESTController();
+    return RESTController.request(
+      'GET', 'users/me', {}, options
+    ).then((response) => {
+      const user = new ParseUser();
+      user._finishFetch(response);
+      user._setExisted(true);
+      return user;
+    });
+  },
+
+  logOut(options: RequestOptions): Promise<ParseUser> {
+    const RESTController = CoreManager.getRESTController();
+    if (options.sessionToken) {
+      return RESTController.request(
+        'POST', 'logout', {}, options
+      );
+    }
     return DefaultController.currentUserAsync().then((currentUser) => {
       const path = Storage.generatePath(CURRENT_USER_KEY);
       let promise = Storage.removeItemAsync(path);
-      const RESTController = CoreManager.getRESTController();
       if (currentUser !== null) {
         const isAnonymous = AnonymousUtils.isLinked(currentUser);
         const currentSession = currentUser.getSessionToken();
diff --git a/src/__tests__/ParseUser-test.js b/src/__tests__/ParseUser-test.js
index ef0fea9e9..7ff19034f 100644
--- a/src/__tests__/ParseUser-test.js
+++ b/src/__tests__/ParseUser-test.js
@@ -137,9 +137,6 @@ describe('ParseUser', () => {
     expect(ParseUser.become.bind(null, 'token')).toThrow(
       'It is not memory-safe to become a user in a server environment'
     );
-    expect(ParseUser.logOut).toThrow(
-      'There is no current user on a node.js server environment.'
-    );
   });
 
   it('can sign up a new user', (done) => {
@@ -675,6 +672,71 @@ describe('ParseUser', () => {
     });
   });
 
+  it('can retreive a user with sessionToken (me)', async () => {
+    ParseUser.disableUnsafeCurrentUser();
+    ParseUser._clearCache();
+    CoreManager.setRESTController({
+      request(method, path, body, options) {
+        expect(method).toBe('GET');
+        expect(path).toBe('users/me');
+        expect(options.sessionToken).toBe('123abc');
+        return Promise.resolve({
+          objectId: 'uid3',
+          username: 'username',
+          sessionToken: '123abc'
+        }, 200);
+      },
+      ajax() {}
+    });
+
+    const user = await ParseUser.me('123abc');
+    expect(user.id).toBe('uid3');
+    expect(user.isCurrent()).toBe(false);
+    expect(user.existed()).toBe(true);
+  });
+
+  it('can retreive a user with sessionToken and masterKey(me)', async () => {
+    ParseUser.disableUnsafeCurrentUser();
+    ParseUser._clearCache();
+    CoreManager.setRESTController({
+      request(method, path, body, options) {
+        expect(method).toBe('GET');
+        expect(path).toBe('users/me');
+        expect(options.sessionToken).toBe('123abc');
+        expect(options.useMasterKey).toBe(true);
+        return Promise.resolve({
+          objectId: 'uid3',
+          username: 'username',
+          sessionToken: '123abc'
+        }, 200);
+      },
+      ajax() {}
+    });
+
+    const user = await ParseUser.me('123abc', { useMasterKey: true });
+    expect(user.id).toBe('uid3');
+    expect(user.isCurrent()).toBe(false);
+    expect(user.existed()).toBe(true);
+  });
+
+  it('can logout user with sessionToken', async () => {
+    ParseUser.disableUnsafeCurrentUser();
+    ParseUser._clearCache();
+    Storage._clear();
+    const RESTController = {
+      request() {
+        return Promise.resolve({}, 200);
+      },
+      ajax() {}
+    };
+    jest.spyOn(RESTController, 'request');
+    CoreManager.setRESTController(RESTController);
+
+    await ParseUser.logOut({ sessionToken: '1234' });
+
+    expect(RESTController.request).toHaveBeenCalledWith('POST', 'logout', {}, { sessionToken: '1234' });
+  });
+
   it('can get error when recursive _linkWith call fails', (done) => {
     CoreManager.setRESTController({
       request(method, path, body) {
diff --git a/src/__tests__/RESTController-test.js b/src/__tests__/RESTController-test.js
index 4d6ce9b38..3d48b351a 100644
--- a/src/__tests__/RESTController-test.js
+++ b/src/__tests__/RESTController-test.js
@@ -263,6 +263,7 @@ describe('RESTController', () => {
       logIn() {},
       become() {},
       logOut() {},
+      me() {},
       requestPasswordReset() {},
       upgradeToRevocableSession() {},
       linkWith() {},
@@ -298,6 +299,7 @@ describe('RESTController', () => {
       logIn() {},
       become() {},
       logOut() {},
+      me() {},
       requestPasswordReset() {},
       upgradeToRevocableSession() {},
       linkWith() {},