diff --git a/wf_field/src/field_definition_parser.rs b/wf_field/src/field_definition_parser.rs
index 8f45d6c..1662e41 100644
--- a/wf_field/src/field_definition_parser.rs
+++ b/wf_field/src/field_definition_parser.rs
@@ -11,23 +11,23 @@ pub trait FieldDefinitionParser {
 
 pub trait FieldDefinitionParserBase {
     /// parse multiple FieldDefinitions and extract its assoicated values and converts it into Fields
-    fn parse_fields(&mut self, field_defs: Vec<FieldDefinition>) -> Vec<Field>;
+    fn parse_fields(&mut self, field_defs: Vec<FieldDefinition>) -> Result<Vec<Field>, CodecError>;
     /// parses header definitions into an array of Fields
-    fn parse_header(&mut self) -> Vec<Field>;
+    fn parse_header(&mut self) -> Result<Vec<Field>, CodecError>;
 }
 
 impl<T: FieldDefinitionParser> FieldDefinitionParserBase for T {
-    fn parse_fields(&mut self, field_defs: Vec<FieldDefinition>) -> Vec<Field> {
-        field_defs
-            .into_iter()
-            .map(|f| {
-                let value = self.parse(&f).unwrap();
-                Field::new(f, value)
-            })
-            .collect()
+    fn parse_fields(&mut self, field_defs: Vec<FieldDefinition>) -> Result<Vec<Field>, CodecError> {
+        let mut fields: Vec<Field> = Vec::new();
+        for f in field_defs.into_iter() {
+            let value: String = self.parse(&f)?;
+            let field = Field::new(f, value);
+            fields.push(field);
+        }
+        Ok(fields)
     }
 
-    fn parse_header(&mut self) -> Vec<Field> {
+    fn parse_header(&mut self) -> Result<Vec<Field>, CodecError> {
         self.parse_fields(definitions::header::DEFINITIONS.to_vec())
     }
 }
diff --git a/wf_parser/src/parser.rs b/wf_parser/src/parser.rs
index 345af30..17cff95 100644
--- a/wf_parser/src/parser.rs
+++ b/wf_parser/src/parser.rs
@@ -12,7 +12,15 @@ pub struct Parser {
 
 impl Parser {
     pub fn parse<T: FieldDefinitionParser>(mut parser: T) -> Result<Self, wf_field::Error> {
-        let mut header = Header::new(parser.parse_header())?;
+        let parsed_header = parser.parse_header();
+
+        if parsed_header.is_err() {
+            return Err(wf_field::Error::Other(Box::new(parsed_header.err().unwrap())));
+        }
+
+        let parsed_header_vec = parsed_header.unwrap();
+
+        let mut header = Header::new(parsed_header_vec)?;
 
         let mut body = Vec::new();
 
@@ -24,7 +32,15 @@ impl Parser {
         let code = header.code();
 
         let body_defs = code.definitions()?.to_vec();
-        body.append(parser.parse_fields(body_defs).as_mut());
+        
+        let body_defs_parser_result = parser.parse_fields(body_defs);
+        if body_defs_parser_result.is_err() {
+            return Err(wf_field::Error::Other(Box::new(body_defs_parser_result.err().unwrap())));
+        }
+
+        let mut body_defs_parser = body_defs_parser_result.unwrap();
+
+        body.append(body_defs_parser.as_mut());
 
         if code == MessageCodeType::Request {
             body.append(create_request_fields(&mut parser).as_mut());