diff --git a/apps/cfm/src/main/java/org/onosproject/soam/web/LossMeasurementThresholdCodec.java b/apps/cfm/src/main/java/org/onosproject/soam/web/LossMeasurementThresholdCodec.java
new file mode 100644
index 0000000..3a17f94
--- /dev/null
+++ b/apps/cfm/src/main/java/org/onosproject/soam/web/LossMeasurementThresholdCodec.java
@@ -0,0 +1,192 @@
+/*
+ * Copyright 2017-present Open Networking Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.onosproject.soam.web;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.node.ArrayNode;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import org.onosproject.codec.CodecContext;
+import org.onosproject.codec.JsonCodec;
+import org.onosproject.incubator.net.l2monitoring.soam.MilliPct;
+import org.onosproject.incubator.net.l2monitoring.soam.SoamId;
+import org.onosproject.incubator.net.l2monitoring.soam.loss.LossMeasurementThreshold;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static org.onlab.util.Tools.nullIsIllegal;
+import static org.onosproject.incubator.net.l2monitoring.soam.loss.DefaultLmThreshold.*;
+
+/**
+ * Encode and decode to/from JSON to LossMeasurementThreshold object.
+ */
+public class LossMeasurementThresholdCodec extends JsonCodec<LossMeasurementThreshold> {
+    static final String MEASUREDFLRFORWARD = "measuredFlrForward";
+    static final String MAXFLRFORWARD = "maxFlrForward";
+    static final String AVERAGEFLRFORWARD = "averageFlrForward";
+    static final String MEASUREDFLRBACKWARD = "measuredFlrBackward";
+    static final String MAXFLRBACKWARD = "maxFlrBackward";
+    static final String AVERAGEFLRBACKWARD = "averageFlrBackward";
+    static final String FORWARDHIGHLOSS = "forwardHighLoss";
+    static final String FORWARDCONSECUTIVEHIGHLOSS = "forwardConsecutiveHighLoss";
+    static final String BACKWARDHIGHLOSS = "backwardHighLoss";
+    static final String BACKWARDCONSECUTIVEHIGHLOSS = "backwardConsecutiveHighLoss";
+    static final String FORWARDUNAVAILABLECOUNT = "forwardUnavailableCount";
+    static final String FORWARDAVAILABLERATIO = "forwardAvailableRatio";
+    static final String BACKWARDUNAVAILABLECOUNT = "backwardUnavailableCount";
+    static final String BACKWARDAVAILABLERATIO = "backwardAvailableRatio";
+    static final String THRESHOLDOPTIONS = "thresholdOptions";
+
+    @Override
+    public ObjectNode encode(LossMeasurementThreshold lmt, CodecContext context) {
+        checkNotNull(lmt, "LM thresholds cannot be null");
+        ObjectNode result = context.mapper().createObjectNode()
+                .put("id", lmt.thresholdId().value());
+
+        if (lmt.thresholds() != null) {
+            result.set(THRESHOLDOPTIONS, new LmThresholdOptionCodec()
+                    .encode(lmt.thresholds(), context));
+        }
+
+        if (lmt.measuredFlrForward() != null) {
+            result.put(MEASUREDFLRFORWARD, lmt.measuredFlrForward().percentValue());
+        }
+        if (lmt.maxFlrForward() != null) {
+            result.put(MAXFLRFORWARD, lmt.maxFlrForward().percentValue());
+        }
+        if (lmt.averageFlrForward() != null) {
+            result.put(AVERAGEFLRFORWARD, lmt.averageFlrForward().percentValue());
+        }
+        if (lmt.measuredFlrBackward() != null) {
+            result.put(MEASUREDFLRBACKWARD, lmt.measuredFlrBackward().percentValue());
+        }
+        if (lmt.maxFlrBackward() != null) {
+            result.put(MAXFLRBACKWARD, lmt.maxFlrBackward().percentValue());
+        }
+        if (lmt.averageFlrBackward() != null) {
+            result.put(AVERAGEFLRBACKWARD, lmt.averageFlrBackward().percentValue());
+        }
+        if (lmt.forwardHighLoss() != null) {
+            result.put(FORWARDHIGHLOSS, lmt.forwardHighLoss().longValue());
+        }
+        if (lmt.forwardConsecutiveHighLoss() != null) {
+            result.put(FORWARDCONSECUTIVEHIGHLOSS, lmt.measuredFlrForward().longValue());
+        }
+        if (lmt.backwardHighLoss() != null) {
+            result.put(BACKWARDHIGHLOSS, lmt.backwardHighLoss().longValue());
+        }
+        if (lmt.backwardConsecutiveHighLoss() != null) {
+            result.put(BACKWARDCONSECUTIVEHIGHLOSS, lmt.backwardConsecutiveHighLoss().longValue());
+        }
+        if (lmt.forwardUnavailableCount() != null) {
+            result.put(FORWARDUNAVAILABLECOUNT, lmt.forwardUnavailableCount().longValue());
+        }
+        if (lmt.forwardAvailableRatio() != null) {
+            result.put(FORWARDAVAILABLERATIO, lmt.forwardAvailableRatio().percentValue());
+        }
+        if (lmt.backwardUnavailableCount() != null) {
+            result.put(BACKWARDUNAVAILABLECOUNT, lmt.backwardUnavailableCount().longValue());
+        }
+        if (lmt.backwardAvailableRatio() != null) {
+            result.put(BACKWARDAVAILABLERATIO, lmt.backwardAvailableRatio().percentValue());
+        }
+
+        return result;
+    }
+
+    @Override
+    public List<LossMeasurementThreshold> decode(ArrayNode json, CodecContext context) {
+        if (json == null) {
+            return null;
+        }
+        List<LossMeasurementThreshold> thrList = new ArrayList<>();
+        json.forEach(node -> thrList.add(decode((ObjectNode) node, context)));
+        return thrList;
+    }
+
+    @Override
+    public LossMeasurementThreshold decode(ObjectNode json, CodecContext context) {
+        if (json == null || !json.isObject()) {
+            return null;
+        }
+
+        JsonNode thrNode = json.get("threshold");
+
+        SoamId thresholdId = SoamId.valueOf(nullIsIllegal(thrNode.get("id"),
+                "thresholdId must not be null").asInt());
+        LossMeasurementThreshold.LmThresholdBuilder builder = builder(thresholdId);
+
+        if (thrNode.get("thresholds") != null) {
+            context.codec(ThresholdOption.class)
+                    .decode((ArrayNode) (thrNode.get("thresholds")), context)
+                    .forEach(builder::addToThreshold);
+        }
+
+        if (thrNode.get(MEASUREDFLRFORWARD) != null) {
+            builder.measuredFlrForward(MilliPct.ofPercent(
+                    (float) thrNode.get(MEASUREDFLRFORWARD).asDouble()));
+        }
+        if (thrNode.get(MAXFLRFORWARD) != null) {
+            builder.maxFlrForward(MilliPct.ofPercent(
+                    (float) thrNode.get(MAXFLRFORWARD).asDouble()));
+        }
+        if (thrNode.get(AVERAGEFLRFORWARD) != null) {
+            builder.averageFlrForward(MilliPct.ofPercent(
+                    (float) thrNode.get(AVERAGEFLRFORWARD).asDouble()));
+        }
+        if (thrNode.get(MEASUREDFLRBACKWARD) != null) {
+            builder.measuredFlrBackward(MilliPct.ofPercent(
+                    (float) thrNode.get(MEASUREDFLRBACKWARD).asDouble()));
+        }
+        if (thrNode.get(MAXFLRBACKWARD) != null) {
+            builder.maxFlrBackward(MilliPct.ofPercent(
+                    (float) thrNode.get(MAXFLRBACKWARD).asDouble()));
+        }
+        if (thrNode.get(AVERAGEFLRBACKWARD) != null) {
+            builder.averageFlrBackward(MilliPct.ofPercent(
+                    (float) thrNode.get(AVERAGEFLRBACKWARD).asDouble()));
+        }
+        if (thrNode.get(FORWARDHIGHLOSS) != null) {
+            builder.forwardHighLoss(thrNode.get(FORWARDHIGHLOSS).asLong());
+        }
+        if (thrNode.get(FORWARDCONSECUTIVEHIGHLOSS) != null) {
+            builder.forwardConsecutiveHighLoss(thrNode.get(FORWARDCONSECUTIVEHIGHLOSS).asLong());
+        }
+        if (thrNode.get(BACKWARDHIGHLOSS) != null) {
+            builder.backwardHighLoss(thrNode.get(BACKWARDHIGHLOSS).asLong());
+        }
+        if (thrNode.get(BACKWARDCONSECUTIVEHIGHLOSS) != null) {
+            builder.backwardConsecutiveHighLoss(thrNode.get(BACKWARDCONSECUTIVEHIGHLOSS).asLong());
+        }
+        if (thrNode.get(FORWARDUNAVAILABLECOUNT) != null) {
+            builder.forwardUnavailableCount(thrNode.get(FORWARDUNAVAILABLECOUNT).asLong());
+        }
+        if (thrNode.get(FORWARDAVAILABLERATIO) != null) {
+            builder.forwardAvailableRatio(MilliPct.ofPercent(
+                    (float) thrNode.get(FORWARDAVAILABLERATIO).asDouble()));
+        }
+        if (thrNode.get(BACKWARDUNAVAILABLECOUNT) != null) {
+            builder.backwardUnavailableCount(thrNode.get(BACKWARDUNAVAILABLECOUNT).asLong());
+        }
+        if (thrNode.get(BACKWARDAVAILABLERATIO) != null) {
+            builder.backwardAvailableRatio(MilliPct.ofPercent(
+                    (float) thrNode.get(BACKWARDAVAILABLERATIO).asDouble()));
+        }
+
+        return builder.build();
+    }
+}