diff --git a/modules/fieldClassifier/src/fieldClassifier.cpp b/modules/fieldClassifier/src/fieldClassifier.cpp
index 0b4e2ac..3125d90 100644
--- a/modules/fieldClassifier/src/fieldClassifier.cpp
+++ b/modules/fieldClassifier/src/fieldClassifier.cpp
@@ -281,6 +281,143 @@ void FieldClassifier::loadIP(
 			+ ex.what());
 	}
 }
+void FieldClassifier::fillInputFieldsToOutput(
+	std::optional<Nemea::UnirecRecordView>& input,
+	std::optional<Nemea::UnirecRecord>& output,
+	std::string& templateStr)
+
+{
+	// split template to vector by commas
+	std::vector<std::string> templateFields;
+	size_t pos = 0;
+	std::string strCopy = templateStr;
+	if (templateStr.back() != ',') {
+		strCopy += ','; // Add a trailing comma to ensure the last field is processed
+	}
+	while ((pos = strCopy.find(',')) != std::string::npos) {
+		// Extract the field
+		std::string field = strCopy.substr(0, pos);
+		strCopy.erase(0, pos + 1);
+		if (!field.empty()) { // ignore empty fields
+			templateFields.push_back(field);
+		}
+	}
+	// for each field, get data from input and set to output
+	for (const auto& field : templateFields) {
+		// split field by space to get field name
+		size_t spacePos = field.find(' ');
+		if (spacePos == std::string::npos) {
+			throw std::runtime_error(
+				"FieldClassifier: Invalid Unirec field format in template: " + field);
+		}
+		std::string fieldName = field.substr(spacePos + 1);
+		std::string fieldType = field.substr(0, spacePos);
+
+		auto fieldId = static_cast<ur_field_id_t>(ur_get_id_by_name(fieldName.c_str()));
+		if (fieldId == UR_E_INVALID_NAME) {
+			throw std::runtime_error("FieldClassifier: Invalid Unirec field name: " + fieldName);
+		}
+		try {
+			if (fieldType == "string") {
+				auto value = input->getFieldAsType<std::string>(fieldId);
+				output->setFieldFromType<std::string>(value, fieldId);
+			} else if (fieldType == "uint8") {
+				auto value = input->getFieldAsType<uint8_t>(fieldId);
+				output->setFieldFromType<uint8_t>(value, fieldId);
+			} else if (fieldType == "uint16") {
+				auto value = input->getFieldAsType<uint16_t>(fieldId);
+				output->setFieldFromType<uint16_t>(value, fieldId);
+			} else if (fieldType == "uint32") {
+				auto value = input->getFieldAsType<uint32_t>(fieldId);
+				output->setFieldFromType<uint32_t>(value, fieldId);
+			} else if (fieldType == "uint64") {
+				auto value = input->getFieldAsType<uint64_t>(fieldId);
+				output->setFieldFromType<uint64_t>(value, fieldId);
+			} else if (fieldType == "ipaddr") {
+				auto value = input->getFieldAsType<Nemea::IpAddress>(fieldId);
+				output->setFieldFromType<Nemea::IpAddress>(value, fieldId);
+			} else if (fieldType == "int8") {
+				auto value = input->getFieldAsType<int8_t>(fieldId);
+				output->setFieldFromType<int8_t>(value, fieldId);
+			} else if (fieldType == "int16") {
+				auto value = input->getFieldAsType<int16_t>(fieldId);
+				output->setFieldFromType<int16_t>(value, fieldId);
+			} else if (fieldType == "int32") {
+				auto value = input->getFieldAsType<int32_t>(fieldId);
+				output->setFieldFromType<int32_t>(value, fieldId);
+			} else if (fieldType == "int64") {
+				auto value = input->getFieldAsType<int64_t>(fieldId);
+				output->setFieldFromType<int64_t>(value, fieldId);
+			} else if (fieldType == "char") {
+				auto value = input->getFieldAsType<char>(fieldId);
+				output->setFieldFromType<char>(value, fieldId);
+			} else if (fieldType == "float") {
+				auto value = input->getFieldAsType<float>(fieldId);
+				output->setFieldFromType<float>(value, fieldId);
+			} else if (fieldType == "double") {
+				auto value = input->getFieldAsType<double>(fieldId);
+				output->setFieldFromType<double>(value, fieldId);
+			} else if (fieldType == "macaddr") {
+				auto value = input->getFieldAsType<Nemea::MacAddress>(fieldId);
+				output->setFieldFromType<Nemea::MacAddress>(value, fieldId);
+			} else if (fieldType == "time") {
+				auto value = input->getFieldAsType<Nemea::UrTime>(fieldId);
+				output->setFieldFromType<Nemea::UrTime>(value, fieldId);
+			} else if (fieldType == "bytes") {
+				Nemea::UnirecArray<std::byte> const arr
+					= input->getFieldAsUnirecArray<std::byte>(fieldId);
+				output->setFieldFromUnirecArray<std::byte>(arr, fieldId);
+			} else if (fieldType == "int8*") {
+				Nemea::UnirecArray<int8_t> const arr
+					= input->getFieldAsUnirecArray<int8_t>(fieldId);
+				output->setFieldFromUnirecArray<int8_t>(arr, fieldId);
+			} else if (fieldType == "int16*") {
+				Nemea::UnirecArray<int16_t> const arr
+					= input->getFieldAsUnirecArray<int16_t>(fieldId);
+				output->setFieldFromUnirecArray<int16_t>(arr, fieldId);
+			} else if (fieldType == "int32*") {
+				Nemea::UnirecArray<int32_t> const arr
+					= input->getFieldAsUnirecArray<int32_t>(fieldId);
+				output->setFieldFromUnirecArray<int32_t>(arr, fieldId);
+			} else if (fieldType == "int64*") {
+				Nemea::UnirecArray<int64_t> const arr
+					= input->getFieldAsUnirecArray<int64_t>(fieldId);
+				output->setFieldFromUnirecArray<int64_t>(arr, fieldId);
+			} else if (fieldType == "uint8*") {
+				Nemea::UnirecArray<uint8_t> const arr
+					= input->getFieldAsUnirecArray<uint8_t>(fieldId);
+				output->setFieldFromUnirecArray<uint8_t>(arr, fieldId);
+			} else if (fieldType == "uint16*") {
+				Nemea::UnirecArray<uint16_t> const arr
+					= input->getFieldAsUnirecArray<uint16_t>(fieldId);
+				output->setFieldFromUnirecArray<uint16_t>(arr, fieldId);
+			} else if (fieldType == "uint32*") {
+				Nemea::UnirecArray<uint32_t> const arr
+					= input->getFieldAsUnirecArray<uint32_t>(fieldId);
+				output->setFieldFromUnirecArray<uint32_t>(arr, fieldId);
+			} else if (fieldType == "uint64*") {
+				Nemea::UnirecArray<uint64_t> const arr
+					= input->getFieldAsUnirecArray<uint64_t>(fieldId);
+				output->setFieldFromUnirecArray<uint64_t>(arr, fieldId);
+			} else if (fieldType == "float*") {
+				Nemea::UnirecArray<float> const arr = input->getFieldAsUnirecArray<float>(fieldId);
+				output->setFieldFromUnirecArray<float>(arr, fieldId);
+			} else if (fieldType == "double*") {
+				Nemea::UnirecArray<double> const arr
+					= input->getFieldAsUnirecArray<double>(fieldId);
+				output->setFieldFromUnirecArray<double>(arr, fieldId);
+			} else {
+				throw std::runtime_error(
+					"FieldClassifier: Unsupported Unirec field type in template: " + fieldType);
+			}
+
+		} catch (const std::exception& ex) {
+			throw std::runtime_error(
+				std::string("FieldClassifier: Unable to copy field '") + field
+				+ "' from input to output Unirec record: " + ex.what());
+		}
+	}
+}
 
 void FieldClassifier::getDataFromPlugins(std::optional<Nemea::UnirecRecordView>& unirecView)
 {
diff --git a/modules/fieldClassifier/src/fieldClassifier.hpp b/modules/fieldClassifier/src/fieldClassifier.hpp
index 5dc4ef3..7ed2f8d 100644
--- a/modules/fieldClassifier/src/fieldClassifier.hpp
+++ b/modules/fieldClassifier/src/fieldClassifier.hpp
@@ -76,6 +76,11 @@ class FieldClassifier {
 	 */
 	void handleParams(int argc, char** argv, argparse::ArgumentParser& parser);
 
+	void fillInputFieldsToOutput(
+		std::optional<Nemea::UnirecRecordView>& input,
+		std::optional<Nemea::UnirecRecord>& output,
+		std::string& templateStr);
+
 private:
 	std::vector<class Plugin*> m_plugins = g_PLUGINS;
 
diff --git a/modules/fieldClassifier/src/main.cpp b/modules/fieldClassifier/src/main.cpp
index 31de888..4045d88 100644
--- a/modules/fieldClassifier/src/main.cpp
+++ b/modules/fieldClassifier/src/main.cpp
@@ -62,6 +62,15 @@ static void processNextRecord(
 		throw std::runtime_error(std::string("Unable to create output Unirec record"));
 		return;
 	}
+	auto* templateDef = input.getTemplate();
+	if (templateDef == nullptr) {
+		throw std::runtime_error(std::string("Unable to get template from trap input"));
+	}
+
+	// convert template to string and append new fileds
+	std::string stringTemp = static_cast<std::string>(ur_template_string(templateDef));
+
+	fieldClassifier.fillInputFieldsToOutput(inputUnirecView, unirecRecord, stringTemp);
 
 	// populate Unirec record with data from modules
 	try {
diff --git a/modules/fieldClassifier/src/plugins/plugin.hpp b/modules/fieldClassifier/src/plugins/plugin.hpp
index be8eef8..43e16d0 100644
--- a/modules/fieldClassifier/src/plugins/plugin.hpp
+++ b/modules/fieldClassifier/src/plugins/plugin.hpp
@@ -58,11 +58,11 @@ enum DataType : uint8_t {
 	CHAR,
 	FLOAT,
 	DOUBLE,
-	// IPADDR,
-	// MACADDR,
-	// TIME,
+	IPADDR,
+	MACADDR,
+	TIME,
 	STRING,
-	// BYTES
+	BYTES
 };
 
 /**