diff --git a/cmd/cgr-console/cgr-console.go b/cmd/cgr-console/cgr-console.go
index 205fda21a..b7e90abdb 100644
--- a/cmd/cgr-console/cgr-console.go
+++ b/cmd/cgr-console/cgr-console.go
@@ -76,19 +76,23 @@ func executeCommand(command string) {
 		fmt.Println(cmdErr)
 		return
 	}
-	res := cmd.RpcResult()
-	param := cmd.RpcParams()
-	//log.Print(reflect.TypeOf(param))
-	switch param.(type) {
-	case *console.StringWrapper:
-		param = param.(*console.StringWrapper).Item
-	}
-	//log.Printf("Param: %+v", param)
-	if rpcErr := client.Call(cmd.RpcMethod(), param, res); rpcErr != nil {
-		fmt.Println("Error executing command: " + rpcErr.Error())
+	if cmd.RpcMethod() != "" {
+		res := cmd.RpcResult()
+		param := cmd.RpcParams()
+		//log.Print(reflect.TypeOf(param))
+		switch param.(type) {
+		case *console.StringWrapper:
+			param = param.(*console.StringWrapper).Item
+		}
+		//log.Printf("Param: %+v", param)
+		if rpcErr := client.Call(cmd.RpcMethod(), param, res); rpcErr != nil {
+			fmt.Println("Error executing command: " + rpcErr.Error())
+		} else {
+			result, _ := json.MarshalIndent(res, "", " ")
+			fmt.Println(string(result))
+		}
 	} else {
-		result, _ := json.MarshalIndent(res, "", " ")
-		fmt.Println(string(result))
+		fmt.Println(cmd.LocalExecute())
 	}
 }
 
diff --git a/console/command.go b/console/command.go
index d81b658cc..52d9e7e49 100644
--- a/console/command.go
+++ b/console/command.go
@@ -37,6 +37,7 @@ type Commander interface {
 	RpcResult() interface{}                   // Only requirement is to have a String method to print on console
 	ClientArgs() []string                     // for autocompletion
 	Name() string
+	LocalExecute() string
 }
 
 func GetCommands() map[string]Commander {
diff --git a/console/command_executer.go b/console/command_executer.go
index d3bd1d174..f0535e107 100644
--- a/console/command_executer.go
+++ b/console/command_executer.go
@@ -65,6 +65,11 @@ func (ce *CommandExecuter) ClientArgs() (args []string) {
 	return
 }
 
+// To be overwritten by commands that do not need a rpc call
+func (ce *CommandExecuter) LocalExecute() string {
+	return ""
+}
+
 func ToJSON(line string) (jsn []byte) {
 	if !strings.Contains(line, "=") {
 		line = fmt.Sprintf("Item=\"%s\"", line)
diff --git a/console/parse.go b/console/parse.go
new file mode 100644
index 000000000..0860fc80a
--- /dev/null
+++ b/console/parse.go
@@ -0,0 +1,75 @@
+/*
+Rating system designed to be used in VoIP Carriers World
+Copyright (C) 2013 ITsysCOM
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>
+*/
+
+package console
+
+import "github.com/cgrates/cgrates/utils"
+
+func init() {
+	c := &CmdParse{
+		name:      "parse",
+		rpcParams: &AttrParse{},
+	}
+	commands[c.Name()] = c
+	c.CommandExecuter = &CommandExecuter{c}
+}
+
+type AttrParse struct {
+	Expression string
+	Value      string
+}
+
+type CmdParse struct {
+	name      string
+	rpcMethod string
+	rpcParams *AttrParse
+	*CommandExecuter
+}
+
+func (self *CmdParse) Name() string {
+	return self.name
+}
+
+func (self *CmdParse) RpcMethod() string {
+	return ""
+}
+
+func (self *CmdParse) RpcParams() interface{} {
+	if self.rpcParams == nil {
+		self.rpcParams = &AttrParse{}
+	}
+	return self.rpcParams
+}
+
+func (self *CmdParse) RpcResult() interface{} {
+	return nil
+}
+
+func (self *CmdParse) LocalExecute() string {
+	if self.rpcParams.Expression == "" {
+		return "Empty expression error"
+	}
+	if self.rpcParams.Value == "" {
+		return "Empty value error"
+	}
+	if rsrField, err := utils.NewRSRField(self.rpcParams.Expression); err == nil {
+		return rsrField.ParseValue(self.rpcParams.Value)
+	} else {
+		return err.Error()
+	}
+}