diff --git a/README.md b/README.md
index a9b080b..095cde9 100644
--- a/README.md
+++ b/README.md
@@ -90,6 +90,7 @@ This will result in:
 # Todo
 
 - [x] Webhook support
+- [x] Forward Type
 - [ ] BulkMessage Type
 - [ ] File Type
 - [ ] Sticker Type
diff --git a/build/index.js b/build/index.js
index 5e6ddbc..4aaaa4b 100644
--- a/build/index.js
+++ b/build/index.js
@@ -172,6 +172,13 @@ var Bot = (function (_EventEmitter) {
     }
   }, {
     key: '_update',
+
+    /**
+     * The internal update event listener, used to parse messages and fire
+     * command/get events - YOU SHOULD NOT USE THIS
+     *
+     * @param  {object} update
+     */
     value: function _update(update) {
       var _this2 = this;
 
diff --git a/build/types/Base.js b/build/types/Base.js
index fd1a0e1..fc2cdfb 100644
--- a/build/types/Base.js
+++ b/build/types/Base.js
@@ -19,16 +19,77 @@ var _events = require('events');
  */
 
 var Base = (function (_EventEmitter) {
-  function Base() {
+  function Base(method) {
     _classCallCheck(this, Base);
 
     _get(Object.getPrototypeOf(Base.prototype), 'constructor', this).call(this);
+
+    this.method = method;
     this.properties = {};
   }
 
   _inherits(Base, _EventEmitter);
 
   _createClass(Base, [{
+    key: 'send',
+
+    /**
+     * Sends the message, you should only use this method yourself if
+     * you are extending this class. Normally you should call bot.send(message)
+     *
+     * Events: message:sent => Emitted after sending the message to API, gets the
+     * 												  API's response
+     *
+     *			message:answer => Emitted when your message gets an answer from
+     *				                 the contact (reply in case of groups)
+     *				                 gets the Update object containing message
+     *
+     * @param  {object} bot
+     * @return {promise} returns a promise, resolved with message:answer
+     */
+    value: function send(bot) {
+      var _this = this;
+
+      if (this._keyboard) {
+        var reply_markup = JSON.stringify(this._keyboard.getProperties());
+        this.properties.reply_markup = reply_markup;
+      }
+
+      var messageId = undefined;
+      return new Promise(function (resolve) {
+        bot.api[_this.method](_this.properties).then(function (response) {
+          messageId = response.result.message_id;
+          _this.emit('message:sent', response);
+        });
+
+        if (_this._keyboard.one_time_keyboard) {
+          _this._keyboard.replyMarkup = '';
+        }
+
+        var chat = _this.properties.chat_id;
+        bot.on('update', function listener(result) {
+          var update = result.find(function (_ref) {
+            var message = _ref.message;
+
+            // if in a group, there will be a reply to this message
+            if (chat < 0) {
+              return message.chat.id === chat && message.reply_to_message && message.reply_to_message.message_id === messageId;
+            } else {
+              return message.chat.id === chat;
+            }
+          });
+
+          if (update) {
+            resolve(update.message);
+
+            this.emit('message:answer', update.message);
+
+            bot.removeListener('update', listener);
+          }
+        });
+      });
+    }
+  }, {
     key: 'getProperties',
 
     /**
diff --git a/build/types/Forward.js b/build/types/Forward.js
new file mode 100644
index 0000000..0dade9d
--- /dev/null
+++ b/build/types/Forward.js
@@ -0,0 +1,104 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+
+var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();
+
+var _get = function get(_x2, _x3, _x4) { var _again = true; _function: while (_again) { var object = _x2, property = _x3, receiver = _x4; desc = parent = getter = undefined; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x2 = parent; _x3 = property; _x4 = receiver; _again = true; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } };
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) subClass.__proto__ = superClass; }
+
+var _Base2 = require('./Base');
+
+var _Base3 = _interopRequireDefault(_Base2);
+
+/**
+ * Forward class, used to forward messages from a chat to another
+ */
+
+var Forward = (function (_Base) {
+  /**
+   * Create a new forward message
+   * @param  {object} properties Forward Message properties, as defined by
+   *                             Telegram API
+   */
+
+  function Forward() {
+    var properties = arguments[0] === undefined ? {} : arguments[0];
+
+    _classCallCheck(this, Forward);
+
+    _get(Object.getPrototypeOf(Forward.prototype), 'constructor', this).call(this, 'forwardMessage');
+
+    this.properties = properties;
+    this._keyboard = new _Base3['default']();
+  }
+
+  _inherits(Forward, _Base);
+
+  _createClass(Forward, [{
+    key: 'to',
+
+    /**
+     * Set chat_id of the message
+     * @param  {number} chat
+     * @return {object} returns the message object
+     */
+    value: function to(chat) {
+      this.properties.chat_id = chat;
+      return this;
+    }
+  }, {
+    key: 'from',
+
+    /**
+     * Set from_chat_id, source of message's chat's id
+     * @param  {number} chat Source chat id
+     * @return {object} returns the message object
+     */
+    value: function from(chat) {
+      this.properties.from_chat_id = chat;
+      return this;
+    }
+  }, {
+    key: 'message',
+
+    /**
+     * Sets message_id, the message to forward from source to target chat
+     * @param  {number} message ID of the message to forward
+     * @return {object} returns the message object
+     */
+    value: function message(_message) {
+      this.properties.message_id = _message;
+      return this;
+    }
+  }, {
+    key: 'keyboard',
+
+    /**
+     * Sets keyboard of the message
+     * The value of reply_markup is set to the sanitized keyboard properties
+     * i.e. reply_markup = JSON.stringify(kb.getProperties())
+     * @param  {object} kb A Keyboard instance
+     * @return {object} returns the message object
+     */
+    value: function keyboard(kb) {
+      this._keyboard = kb;
+      return this;
+    }
+
+    // This class inherits Base's send method
+
+  }]);
+
+  return Forward;
+})(_Base3['default']);
+
+exports['default'] = Forward;
+module.exports = exports['default'];
diff --git a/build/types/Message.js b/build/types/Message.js
index 0641ab4..11ace9c 100644
--- a/build/types/Message.js
+++ b/build/types/Message.js
@@ -33,7 +33,7 @@ var Message = (function (_Base) {
 
     _classCallCheck(this, Message);
 
-    _get(Object.getPrototypeOf(Message.prototype), 'constructor', this).call(this);
+    _get(Object.getPrototypeOf(Message.prototype), 'constructor', this).call(this, 'sendMessage');
 
     this.properties = properties;
     this._keyboard = new _Base3['default']();
@@ -91,65 +91,9 @@ var Message = (function (_Base) {
       this._keyboard = kb;
       return this;
     }
-  }, {
-    key: 'send',
 
-    /**
-     * Sends the message, you should only use this method yourself if
-     * you are extending this class. Normally you should call bot.send(message)
-     *
-     * Events: message:sent => Emitted after sending the message to API, gets the
-     * 												  API's response
-     *
-     *			message:answer => Emitted when your message gets an answer from
-     *				                 the contact (reply in case of groups)
-     *				                 gets the Update object containing message
-     *
-     * @param  {object} bot
-     * @return {promise} returns a promise, resolved with message:answer
-     */
-    value: function send(bot) {
-      var _this = this;
+    // This class inherits Base's send method
 
-      console.log('sending message');
-
-      var messageId = undefined;
-      var reply_markup = JSON.stringify(this._keyboard.getProperties());
-      this.properties.reply_markup = reply_markup;
-
-      return new Promise(function (resolve) {
-        bot.api.sendMessage(_this.properties).then(function (response) {
-          messageId = response.result.message_id;
-          _this.emit('message:sent', response);
-        });
-
-        if (_this._keyboard.one_time_keyboard) {
-          _this._keyboard.replyMarkup = '';
-        }
-
-        var chat = _this.properties.chat_id;
-        bot.on('update', function listener(result) {
-          var update = result.find(function (_ref) {
-            var message = _ref.message;
-
-            // if in a group, there will be a reply to this message
-            if (chat < 0) {
-              return message.chat.id === chat && message.reply_to_message && message.reply_to_message.message_id === messageId;
-            } else {
-              return message.chat.id === chat;
-            }
-          });
-
-          if (update) {
-            resolve(update.message);
-
-            this.emit('message:answer', update.message);
-
-            bot.removeListener('update', listener);
-          }
-        });
-      });
-    }
   }]);
 
   return Message;
diff --git a/demo.js b/demo.js
index a4527dc..66e0a65 100644
--- a/demo.js
+++ b/demo.js
@@ -5,7 +5,7 @@ var Message = require('telegram-api/types/Message');
 var Question = require('telegram-api/types/Question');
 
 var bot = new Bot({
-  token: '121143906:AAE6pcpBoARNZZjr3fUpvKuLInJ5Eee5Ajk'
+  token: 'YOUR_KEY'
 });
 
 bot.start().catch(err => {
@@ -42,6 +42,7 @@ bot.command('start', message => {
 });
 
 const test = new Message().text('Test Command');
+
 bot.command('test', message => {
   bot.send(test.to(message.chat.id));
 });
diff --git a/lib/types/Base.js b/lib/types/Base.js
index f31a596..e777c4e 100644
--- a/lib/types/Base.js
+++ b/lib/types/Base.js
@@ -4,11 +4,68 @@ import {EventEmitter} from 'events';
  * Base class of all classes
  */
 export default class Base extends EventEmitter {
-  constructor() {
+  constructor(method) {
     super();
+
+    this.method = method;
     this.properties = {};
   }
 
+  /**
+   * Sends the message, you should only use this method yourself if
+   * you are extending this class. Normally you should call bot.send(message)
+   *
+   * Events: message:sent => Emitted after sending the message to API, gets the
+   * 												  API's response
+   *
+   *			message:answer => Emitted when your message gets an answer from
+   *				                 the contact (reply in case of groups)
+   *				                 gets the Update object containing message
+   *
+   * @param  {object} bot
+   * @return {promise} returns a promise, resolved with message:answer
+   */
+  send(bot) {
+    if (this._keyboard) {
+      const reply_markup = JSON.stringify(this._keyboard.getProperties());
+      this.properties.reply_markup = reply_markup;
+    }
+
+    let messageId;
+    return new Promise(resolve => {
+      bot.api[this.method](this.properties).then(response => {
+        messageId = response.result.message_id;
+        this.emit('message:sent', response);
+      });
+
+      if (this._keyboard.one_time_keyboard) {
+        this._keyboard.replyMarkup = '';
+      }
+
+      const chat = this.properties.chat_id;
+      bot.on('update', function listener(result) {
+        const update = result.find(({message}) => {
+          // if in a group, there will be a reply to this message
+          if (chat < 0) {
+            return message.chat.id === chat
+                   && message.reply_to_message
+                   && message.reply_to_message.message_id === messageId;
+          } else {
+            return message.chat.id === chat;
+          }
+        });
+
+        if (update) {
+          resolve(update.message);
+
+          this.emit('message:answer', update.message);
+
+          bot.removeListener('update', listener);
+        }
+      });
+    });
+  }
+
   /**
    * Returns properties of the object
    * @return {object} properties of object
diff --git a/lib/types/Forward.js b/lib/types/Forward.js
new file mode 100644
index 0000000..26d3bef
--- /dev/null
+++ b/lib/types/Forward.js
@@ -0,0 +1,62 @@
+import Base from './Base';
+
+/**
+ * Forward class, used to forward messages from a chat to another
+ */
+export default class Forward extends Base {
+  /**
+   * Create a new forward message
+   * @param  {object} properties Forward Message properties, as defined by
+   *                             Telegram API
+   */
+  constructor(properties = {}) {
+    super('forwardMessage');
+
+    this.properties = properties;
+    this._keyboard = new Base();
+  }
+
+  /**
+   * Set chat_id of the message
+   * @param  {number} chat
+   * @return {object} returns the message object
+   */
+  to(chat) {
+    this.properties.chat_id = chat;
+    return this;
+  }
+
+  /**
+   * Set from_chat_id, source of message's chat's id
+   * @param  {number} chat Source chat id
+   * @return {object} returns the message object
+   */
+  from(chat) {
+    this.properties.from_chat_id = chat;
+    return this;
+  }
+
+  /**
+   * Sets message_id, the message to forward from source to target chat
+   * @param  {number} message ID of the message to forward
+   * @return {object} returns the message object
+   */
+  message(message) {
+    this.properties.message_id = message;
+    return this;
+  }
+
+  /**
+   * Sets keyboard of the message
+   * The value of reply_markup is set to the sanitized keyboard properties
+   * i.e. reply_markup = JSON.stringify(kb.getProperties())
+   * @param  {object} kb A Keyboard instance
+   * @return {object} returns the message object
+   */
+  keyboard(kb) {
+    this._keyboard = kb;
+    return this;
+  }
+
+  // This class inherits Base's send method
+}
diff --git a/lib/types/Message.js b/lib/types/Message.js
index 8862593..15e5b63 100644
--- a/lib/types/Message.js
+++ b/lib/types/Message.js
@@ -9,7 +9,7 @@ export default class Message extends Base {
    * @param  {object} properties Message properties, as defined by Telegram API
    */
   constructor(properties = {}) {
-    super();
+    super('sendMessage');
 
     this.properties = properties;
     this._keyboard = new Base();
@@ -57,58 +57,5 @@ export default class Message extends Base {
     return this;
   }
 
-  /**
-   * Sends the message, you should only use this method yourself if
-   * you are extending this class. Normally you should call bot.send(message)
-   *
-   * Events: message:sent => Emitted after sending the message to API, gets the
-   * 												  API's response
-   *
-   *			message:answer => Emitted when your message gets an answer from
-   *				                 the contact (reply in case of groups)
-   *				                 gets the Update object containing message
-   *
-   * @param  {object} bot
-   * @return {promise} returns a promise, resolved with message:answer
-   */
-  send(bot) {
-    console.log('sending message');
-
-    let messageId;
-    const reply_markup = JSON.stringify(this._keyboard.getProperties());
-    this.properties.reply_markup = reply_markup;
-
-    return new Promise(resolve => {
-      bot.api.sendMessage(this.properties).then(response => {
-        messageId = response.result.message_id;
-        this.emit('message:sent', response);
-      });
-
-      if (this._keyboard.one_time_keyboard) {
-        this._keyboard.replyMarkup = '';
-      }
-
-      const chat = this.properties.chat_id;
-      bot.on('update', function listener(result) {
-        const update = result.find(({message}) => {
-          // if in a group, there will be a reply to this message
-          if (chat < 0) {
-            return message.chat.id === chat
-                   && message.reply_to_message
-                   && message.reply_to_message.message_id === messageId;
-          } else {
-            return message.chat.id === chat;
-          }
-        });
-
-        if (update) {
-          resolve(update.message);
-
-          this.emit('message:answer', update.message);
-
-          bot.removeListener('update', listener);
-        }
-      });
-    });
-  }
+  // This class inherits Base's send method
 }
diff --git a/package.json b/package.json
index 18e374c..c96f02f 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "telegram-api",
-  "version": "0.3.2",
+  "version": "0.3.3",
   "description": "Control Telegram bots easily using the new Telegram API",
   "main": "index.js",
   "scripts": {
diff --git a/types/Forward.js b/types/Forward.js
new file mode 120000
index 0000000..3202592
--- /dev/null
+++ b/types/Forward.js
@@ -0,0 +1 @@
+../build/types/Forward.js
\ No newline at end of file