diff --git a/src/decoder.js b/src/decoder.js
index c773854..f9b449d 100644
--- a/src/decoder.js
+++ b/src/decoder.js
@@ -1,4 +1,5 @@
 var chars = require("./chars").chars;
+var appCharsArr = require("./chars").charsArr;
 
 decoder.prototype._d = function(schema){
     if(ifNil(this.currentChar())){
@@ -85,7 +86,20 @@ decoder.prototype.readFieldValue = function(schemaOfCurrentKey){
             var len = this.dataToDecode.length;
             var start = this.index;
             
-            for(;this.index < len && until.indexOf(this.currentChar()) === -1;this.index++);
+            for(;this.index < len; this.index++){
+                if(this.currentChar() === '\\' &&  this.index+1 < len 
+                    && appCharsArr.indexOf(this.dataToDecode[this.index+1]) !== -1){
+                    // remove the backslash
+                    this.dataToDecode = this.dataToDecode.substr(0,this.index)
+                    + this.dataToDecode.substr(this.index+1,this.dataToDecode.length);
+                    continue;
+                }
+                if(until.indexOf(this.currentChar()) === -1){
+                    // not ending char
+                    continue;
+                }
+                break;
+            };
             return this.dataToDecode.substr(start, this.index-start);
         }
     }else{
@@ -93,7 +107,6 @@ decoder.prototype.readFieldValue = function(schemaOfCurrentKey){
     }    
 }
 
-
 decoder.prototype.decode = function(objStr){
     this.index= 0;
     if(!objStr || typeof objStr !== "string" || objStr.length === 0) throw Error("input should be a valid string");
diff --git a/src/encoder.js b/src/encoder.js
index 1ae4afe..73624d6 100644
--- a/src/encoder.js
+++ b/src/encoder.js
@@ -1,6 +1,8 @@
 var chars = require("./chars").chars;
 var appCharsArr = require("./chars").charsArr;
 
+const appCharRegex = new RegExp(appCharsArr.join('|'), 'g');
+        
 Encoder.prototype._e = function(jObj,e_schema){
     if(typeof e_schema.type === "string"){//premitive
         return this.getValue(jObj,e_schema.type);
@@ -35,7 +37,9 @@ Encoder.prototype._e = function(jObj,e_schema){
 }
 
 Encoder.prototype.processValue= function(str,r){
-    if(!this.isAppChar(r[0]) && !this.isAppChar(str[str.length -1])){
+    if(!this.isAppChar(r[0]) && (!this.isAppChar(str[str.length -1]) 
+        || (this.isAppChar(str[str.length -1]) && str.length>1 
+            && str[str.length - 2] === '\\'))){
         str += chars.boundryChar;
     }
     return str + r;
@@ -43,19 +47,31 @@ Encoder.prototype.processValue= function(str,r){
 
 /**
  * 
- * @param {*} a 
+ * @param {*} value 
  * @param {*} type 
  * @return {string} return either the parsed value or a special char representing the value
  */
-Encoder.prototype.getValue= function(a,type){
-    switch(a){
+Encoder.prototype.getValue= function(value,type){
+    switch(value){
         case undefined: return chars.missingPremitive;
         case null: return chars.nilPremitive;
         case "": return chars.emptyValue;
-        default: return this.dataHandlers[type].parse(a);
+        default: return sanitizeData(this.dataHandlers[type].parse(value));
     }
 }
 
+/**
+ * 
+ * @param {string} data 
+ * @return {string} return the sanitized string by adding backslash to the special chars
+ */
+function sanitizeData(data) {
+    if(typeof data === "string"){
+        data = data.replace(appCharRegex, '\\$&');
+    }
+    return data;
+}
+
 /**
  * Check if the given object is empty, null, or undefined. Returns true otherwise.
  * @param {*} jObj 
diff --git a/tests/encode_arr_backslash_test.js b/tests/encode_arr_backslash_test.js
new file mode 100644
index 0000000..eb3a692
--- /dev/null
+++ b/tests/encode_arr_backslash_test.js
@@ -0,0 +1,60 @@
+var nimn = require("../src/nimn");
+var chars = require("../src/chars").chars;
+var char = require("../src/util").char;
+
+describe('', function(){
+    it("backslash in array should be encoded and decoded correctly", function () {
+        var schema = {
+            "age": "number",
+            "names" : ["string" ],
+            "str": "string",
+            "names2" : ["string" ],
+            "bool": "boolean",
+            "names3" : ["string" ]
+        }
+
+        var nimnEncoder = new nimn();
+        nimnEncoder.addSchema(schema);
+
+         var jData = {
+            age : 32,
+            names : [ chars.arrStart + "amit" + chars.arrayEnd, 
+                chars.boundryChar + "kumar" + chars.emptyChar],
+        }
+        var expected = chars.objStart
+            + "32" 
+            + chars.arrStart + '\\' + chars.arrStart
+            + "amit" + '\\' + chars.arrayEnd + chars.boundryChar 
+            + '\\' + chars.boundryChar + "kumar" 
+            + '\\' + chars.emptyChar + chars.arrayEnd
+            + chars.missingPremitive + chars.missingChar
+            + chars.missingPremitive + chars.missingChar;
+
+        var result = nimnEncoder.encode(jData);
+        expect(result).toEqual(expected); 
+        result = nimnEncoder.decode(result);
+        expect(result).toEqual(jData); 
+
+         var jData = {
+            age : 32,
+            names : [chars.missingChar + "amit" + chars.nilPremitive, 
+                chars.nilChar + "kumar" + chars.arrayEnd],
+            names2 : ["amit2", "kumar2"],
+            bool: false
+        }
+        var expected = chars.objStart + "32" 
+            + chars.arrStart + '\\' + chars.missingChar
+            + "amit" + '\\' + chars.nilPremitive + chars.boundryChar 
+            + '\\' + chars.nilChar + "kumar" + '\\' + chars.arrayEnd + chars.arrayEnd 
+            + chars.missingPremitive
+            + chars.arrStart 
+            + "amit2" + chars.boundryChar + "kumar2" + chars.arrayEnd 
+            + char(183) + chars.missingChar;
+
+        var result = nimnEncoder.encode(jData);
+        expect(result).toEqual(expected); 
+        result = nimnEncoder.decode(result);
+        expect(result).toEqual(jData);   
+    }); 
+
+});
\ No newline at end of file
diff --git a/tests/encode_obj_backslash_test.js b/tests/encode_obj_backslash_test.js
new file mode 100644
index 0000000..26e4648
--- /dev/null
+++ b/tests/encode_obj_backslash_test.js
@@ -0,0 +1,248 @@
+var nimn = require("../src/nimn");
+var chars = require("../src/chars").chars;
+
+/*
+1. chars.nilChar
+2. chars.nilPremitive,
+3. chars.missingChar,
+4. chars.missingPremitive,
+5. chars.boundryChar ,
+6. chars.emptyChar,
+7. chars.emptyValue,
+8. chars.arrayEnd,
+9. chars.objStart,
+10.chars.arrStart
+*/
+describe('backslash in object ',function (){
+
+    it("1. should sanitize the string when nil char exist in the string", function () {
+        var schema = {
+                "name" : "string",
+                "marks" : "number"
+        };
+
+        var nimnEncoder = new nimn();
+
+        var jData = {
+            name : chars.nilChar+ "gupta" + chars.nilChar + "leo" + chars.nilChar,
+            marks : 87.9
+        }
+        var expected = chars.objStart + '\\' + chars.nilChar + 
+            "gupta\\" + chars.nilChar + "leo\\" + chars.nilChar + chars.boundryChar + "87.9";
+
+        nimnEncoder.addSchema(schema);
+        var result = nimnEncoder.encode(jData);
+        expect(result).toEqual(expected);
+        result = nimnEncoder.decode(result);
+        expect(result).toEqual(jData); 
+    });
+
+    it("2. should sanitize the string when nil premitive exist in the string", function () {
+        var schema = {
+                "name" : "string",
+                "marks" : "number"
+        };
+
+        var nimnEncoder = new nimn();
+
+        var jData = {
+            name : chars.nilPremitive+ "gupta" + chars.nilPremitive + "leo" + chars.nilPremitive,
+            marks : 87.9
+        }
+        var expected = chars.objStart + '\\' + chars.nilPremitive + 
+            "gupta\\" + chars.nilPremitive + "leo\\" + chars.nilPremitive + chars.boundryChar + "87.9";
+
+        nimnEncoder.addSchema(schema);
+        var result = nimnEncoder.encode(jData);
+        expect(result).toEqual(expected);
+        result = nimnEncoder.decode(result);
+        expect(result).toEqual(jData); 
+    });
+
+    it("3. should sanitize the string when missing char exist in the string", function () {
+        var schema = {
+                "name" : "string",
+                "marks" : "number"
+        };
+
+        var nimnEncoder = new nimn();
+
+        var jData = {
+            name : chars.missingChar+ "gupta" + chars.missingChar + "leo" + chars.missingChar,
+            marks : 87.9
+        }
+        var expected = chars.objStart + '\\' + chars.missingChar + 
+            "gupta\\" + chars.missingChar + "leo\\" + chars.missingChar + chars.boundryChar + "87.9";
+
+        nimnEncoder.addSchema(schema);
+        var result = nimnEncoder.encode(jData);
+        expect(result).toEqual(expected);
+        result = nimnEncoder.decode(result);
+        expect(result).toEqual(jData); 
+    });
+
+    it("4. should sanitize the string when missing premitive exist in the string", function () {
+        var schema = {
+                "name" : "string",
+                "marks" : "number"
+        };
+
+        var nimnEncoder = new nimn();
+
+        var jData = {
+            name : chars.missingPremitive+ "gupta" + chars.missingPremitive + "leo" + chars.missingPremitive,
+            marks : 87.9
+        }
+        var expected = chars.objStart + '\\' + chars.missingPremitive + 
+            "gupta\\" + chars.missingPremitive + "leo\\" + chars.missingPremitive + chars.boundryChar + "87.9";
+
+        nimnEncoder.addSchema(schema);
+        var result = nimnEncoder.encode(jData);
+        expect(result).toEqual(expected);
+        result = nimnEncoder.decode(result);
+        expect(result).toEqual(jData); 
+    });
+
+    it("5. should sanitize the string when boundary char exist in the string", function () {
+        var schema = {
+                "name" : "string",
+                "marks" : "number"
+        };
+
+        var nimnEncoder = new nimn();
+
+        var jData = {
+            name : chars.boundryChar+ "gupta" + chars.boundryChar + "leo" + chars.boundryChar,
+            marks : 87.9
+        }
+        var expected = chars.objStart + '\\' + chars.boundryChar + 
+            "gupta\\" + chars.boundryChar + "leo\\" + chars.boundryChar + chars.boundryChar + "87.9";
+
+        nimnEncoder.addSchema(schema);
+        var result = nimnEncoder.encode(jData);
+        expect(result).toEqual(expected);
+        result = nimnEncoder.decode(result);
+        expect(result).toEqual(jData); 
+    });
+
+    it("6. should sanitize the string when empty char exist in the string", function () {
+        var schema = {
+                "name" : "string",
+                "marks" : "number"
+        };
+
+        var nimnEncoder = new nimn();
+
+        var jData = {
+            name : chars.emptyChar+ "gupta" + chars.emptyChar + "leo" + chars.emptyChar,
+            marks : 87.9
+        }
+        var expected = chars.objStart + '\\' + chars.emptyChar + 
+            "gupta\\" + chars.emptyChar + "leo\\" + chars.emptyChar + chars.boundryChar + "87.9";
+
+        nimnEncoder.addSchema(schema);
+        var result = nimnEncoder.encode(jData);
+        expect(result).toEqual(expected);
+        result = nimnEncoder.decode(result);
+        expect(result).toEqual(jData); 
+    });
+    
+    it("7. should sanitize the string when empty char exist in the string", function () {
+        var schema = {
+                "name" : "string",
+                "marks" : "number"
+        };
+
+        const testChar = chars.emptyValue;
+
+        var nimnEncoder = new nimn();
+
+        var jData = {
+            name : testChar + "gupta" + testChar + "leo" + testChar,
+            marks : 87.9
+        }
+        var expected = chars.objStart + '\\' + testChar + 
+            "gupta\\" + testChar + "leo\\" + testChar + chars.boundryChar + "87.9";
+
+        nimnEncoder.addSchema(schema);
+        var result = nimnEncoder.encode(jData);
+        expect(result).toEqual(expected);
+        result = nimnEncoder.decode(result);
+        expect(result).toEqual(jData); 
+    });
+
+    
+    it("8. should sanitize the string when arrayend char exist in the string", function () {
+        var schema = {
+                "name" : "string",
+                "marks" : "number"
+        };
+
+        const testChar = chars.arrayEnd;
+
+        var nimnEncoder = new nimn();
+
+        var jData = {
+            name : testChar + "gupta" + testChar + "leo" + testChar,
+            marks : 87.9
+        }
+        var expected = chars.objStart + '\\' + testChar + 
+            "gupta\\" + testChar + "leo\\" + testChar + chars.boundryChar + "87.9";
+
+        nimnEncoder.addSchema(schema);
+        var result = nimnEncoder.encode(jData);
+        expect(result).toEqual(expected);
+        result = nimnEncoder.decode(result);
+        expect(result).toEqual(jData); 
+    });
+
+    
+    it("9. should sanitize the string when obj start char exist in the string", function () {
+        var schema = {
+                "name" : "string",
+                "marks" : "number"
+        };
+
+        const testChar = chars.objStart;
+
+        var nimnEncoder = new nimn();
+
+        var jData = {
+            name : testChar + "gupta" + testChar + "leo" + testChar,
+            marks : 87.9
+        }
+        var expected = chars.objStart + '\\' + testChar + 
+            "gupta\\" + testChar + "leo\\" + testChar + chars.boundryChar + "87.9";
+
+        nimnEncoder.addSchema(schema);
+        var result = nimnEncoder.encode(jData);
+        expect(result).toEqual(expected);
+        result = nimnEncoder.decode(result);
+        expect(result).toEqual(jData); 
+    });
+
+    
+    it("10. should sanitize the string when arraystart char exist in the string", function () {
+        var schema = {
+                "name" : "string",
+                "marks" : "number"
+        };
+
+        const testChar = chars.arrStart;
+
+        var nimnEncoder = new nimn();
+
+        var jData = {
+            name : testChar + "gupta" + testChar + "leo" + testChar,
+            marks : 87.9
+        }
+        var expected = chars.objStart + '\\' + testChar + 
+            "gupta\\" + testChar + "leo\\" + testChar + chars.boundryChar + "87.9";
+
+        nimnEncoder.addSchema(schema);
+        var result = nimnEncoder.encode(jData);
+        expect(result).toEqual(expected);
+        result = nimnEncoder.decode(result);
+        expect(result).toEqual(jData); 
+    });
+});
\ No newline at end of file
diff --git a/tests/encode_test.js b/tests/encode_test.js
index cdacee2..622f802 100644
--- a/tests/encode_test.js
+++ b/tests/encode_test.js
@@ -3,8 +3,6 @@ var chars = require("../src/chars").chars;
 
 describe("Nimn Encoder", function () {
 
-   
-
     it("should append boundry char if last field can have dynamic value", function () {
         var schema = {
                 "name" : "string",