diff --git a/core/api/src/main/java/org/onosproject/net/flow/criteria/PiCriterion.java b/core/api/src/main/java/org/onosproject/net/flow/criteria/PiCriterion.java
index 17d1270..3970e76 100644
--- a/core/api/src/main/java/org/onosproject/net/flow/criteria/PiCriterion.java
+++ b/core/api/src/main/java/org/onosproject/net/flow/criteria/PiCriterion.java
@@ -23,6 +23,7 @@
 import org.onosproject.net.pi.runtime.PiExactFieldMatch;
 import org.onosproject.net.pi.runtime.PiFieldMatch;
 import org.onosproject.net.pi.runtime.PiLpmFieldMatch;
+import org.onosproject.net.pi.runtime.PiOptionalFieldMatch;
 import org.onosproject.net.pi.runtime.PiRangeFieldMatch;
 import org.onosproject.net.pi.runtime.PiTernaryFieldMatch;
 
@@ -350,6 +351,54 @@
         }
 
         /**
+         * Adds an optional field match for the given fieldId and value.
+         *
+         * @param fieldId protocol-independent header field Id
+         * @param value   optional match value
+         * @return this
+         */
+        public Builder matchOptional(PiMatchFieldId fieldId, short value) {
+            fieldMatchMapBuilder.put(fieldId, new PiOptionalFieldMatch(fieldId, copyFrom(value)));
+            return this;
+        }
+
+        /**
+         * Adds an optional field match for the given fieldId and value.
+         *
+         * @param fieldId protocol-independent header field Id
+         * @param value   optional match value
+         * @return this
+         */
+        public Builder matchOptional(PiMatchFieldId fieldId, int value) {
+            fieldMatchMapBuilder.put(fieldId, new PiOptionalFieldMatch(fieldId, copyFrom(value)));
+            return this;
+        }
+
+        /**
+         * Adds an optional field match for the given fieldId and value.
+         *
+         * @param fieldId protocol-independent header field Id
+         * @param value   optional match value
+         * @return this
+         */
+        public Builder matchOptional(PiMatchFieldId fieldId, long value) {
+            fieldMatchMapBuilder.put(fieldId, new PiOptionalFieldMatch(fieldId, copyFrom(value)));
+            return this;
+        }
+
+        /**
+         * Adds an optional field match for the given fieldId and value.
+         *
+         * @param fieldId protocol-independent header field Id
+         * @param value   optional match value
+         * @return this
+         */
+        public Builder matchOptional(PiMatchFieldId fieldId, byte[] value) {
+            fieldMatchMapBuilder.put(fieldId, new PiOptionalFieldMatch(fieldId, copyFrom(value)));
+            return this;
+        }
+
+        /**
          * Builds a PiCriterion.
          *
          * @return PiCriterion
diff --git a/core/api/src/main/java/org/onosproject/net/pi/model/PiMatchType.java b/core/api/src/main/java/org/onosproject/net/pi/model/PiMatchType.java
index f4fce3e..a0cb161 100644
--- a/core/api/src/main/java/org/onosproject/net/pi/model/PiMatchType.java
+++ b/core/api/src/main/java/org/onosproject/net/pi/model/PiMatchType.java
@@ -42,5 +42,10 @@
     /**
      * Range match type.
      */
-    RANGE
+    RANGE,
+
+    /**
+     * Optional match type.
+     */
+    OPTIONAL
 }
diff --git a/core/api/src/main/java/org/onosproject/net/pi/runtime/PiOptionalFieldMatch.java b/core/api/src/main/java/org/onosproject/net/pi/runtime/PiOptionalFieldMatch.java
new file mode 100644
index 0000000..cb34981
--- /dev/null
+++ b/core/api/src/main/java/org/onosproject/net/pi/runtime/PiOptionalFieldMatch.java
@@ -0,0 +1,86 @@
+/*
+ * Copyright 2020-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.net.pi.runtime;
+
+import com.google.common.annotations.Beta;
+import com.google.common.base.Objects;
+import org.onlab.util.ImmutableByteSequence;
+import org.onosproject.net.pi.model.PiMatchFieldId;
+import org.onosproject.net.pi.model.PiMatchType;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+
+/**
+ * Instance of an optional field match in a protocol-independent pipeline.
+ * The optional match field behaves like an exact match if specified, otherwise
+ * it is logically equivalent to a wildcard match.
+ */
+@Beta
+public final class PiOptionalFieldMatch extends PiFieldMatch {
+
+    private final ImmutableByteSequence value;
+
+    /**
+     * Creates an optional field match.
+     *
+     * @param fieldId field identifier
+     * @param value   value
+     */
+    public PiOptionalFieldMatch(PiMatchFieldId fieldId, ImmutableByteSequence value) {
+        super(fieldId);
+        this.value = checkNotNull(value);
+        checkArgument(value.size() > 0, "Value can't have size 0");
+    }
+
+    @Override
+    public PiMatchType type() {
+        return PiMatchType.OPTIONAL;
+    }
+
+    /**
+     * Returns the byte sequence value to be matched.
+     *
+     * @return an immutable byte sequence
+     */
+    public ImmutableByteSequence value() {
+        return value;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+        PiOptionalFieldMatch that = (PiOptionalFieldMatch) o;
+        return Objects.equal(this.fieldId(), that.fieldId()) &&
+                Objects.equal(value, that.value);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hashCode(this.fieldId(), value);
+    }
+
+    @Override
+    public String toString() {
+        return this.fieldId().toString() + "=" + value.toString();
+    }
+}
diff --git a/core/api/src/test/java/org/onosproject/net/flow/criteria/PiCriteriaTest.java b/core/api/src/test/java/org/onosproject/net/flow/criteria/PiCriteriaTest.java
index bd11252..fc95e00 100644
--- a/core/api/src/test/java/org/onosproject/net/flow/criteria/PiCriteriaTest.java
+++ b/core/api/src/test/java/org/onosproject/net/flow/criteria/PiCriteriaTest.java
@@ -22,6 +22,7 @@
 import org.onosproject.net.pi.runtime.PiExactFieldMatch;
 import org.onosproject.net.pi.runtime.PiFieldMatch;
 import org.onosproject.net.pi.runtime.PiLpmFieldMatch;
+import org.onosproject.net.pi.runtime.PiOptionalFieldMatch;
 import org.onosproject.net.pi.runtime.PiRangeFieldMatch;
 import org.onosproject.net.pi.runtime.PiTernaryFieldMatch;
 
@@ -74,6 +75,40 @@
     private Criterion matchPiExactLong2 = PiCriterion.builder()
             .matchExact(ethMatchFieldId, matchExactLong2).build();
 
+    private Criterion matchPiOptionalByte1 = PiCriterion.builder()
+            .matchOptional(ethMatchFieldId, matchExactBytes1).build();
+    private Criterion sameAsMatchPiOptionalByte1 = PiCriterion.builder()
+            .matchOptional(ethMatchFieldId, matchExactBytes1).build();
+    private Criterion matchPiOptionalByte2 = PiCriterion.builder()
+            .matchOptional(ethMatchFieldId, matchExactBytes2).build();
+
+    private short matchOptionalShort1 = 0x800;
+    private short matchOptionalShort2 = 0x806;
+    private Criterion matchPiOptionalShort1 = PiCriterion.builder()
+            .matchOptional(ethMatchFieldId, matchOptionalShort1).build();
+    private Criterion sameAsMatchPiOptionalShort1 = PiCriterion.builder()
+            .matchOptional(ethMatchFieldId, matchOptionalShort1).build();
+    private Criterion matchPiOptionalShort2 = PiCriterion.builder()
+            .matchOptional(ethMatchFieldId, matchOptionalShort2).build();
+
+    private int matchOptionalInt1 = 0x800;
+    private int matchOptionalInt2 = 0x806;
+    private Criterion matchPiOptionalInt1 = PiCriterion.builder()
+            .matchOptional(ethMatchFieldId, matchOptionalInt1).build();
+    private Criterion sameAsMatchPiOptionalInt1 = PiCriterion.builder()
+            .matchOptional(ethMatchFieldId, matchOptionalInt1).build();
+    private Criterion matchPiOptionalInt2 = PiCriterion.builder()
+            .matchOptional(ethMatchFieldId, matchOptionalInt2).build();
+
+    private long matchOptionalLong1 = 0x800;
+    private long matchOptionalLong2 = 0x806;
+    private Criterion matchPiOptionalLong1 = PiCriterion.builder()
+            .matchOptional(ethMatchFieldId, matchOptionalLong1).build();
+    private Criterion sameAsMatchPiOptionalLong1 = PiCriterion.builder()
+            .matchOptional(ethMatchFieldId, matchOptionalLong1).build();
+    private Criterion matchPiOptionalLong2 = PiCriterion.builder()
+            .matchOptional(ethMatchFieldId, matchOptionalLong2).build();
+
     private PiMatchFieldId ipv4MatchFieldId = PiMatchFieldId.of("ipv4_t.dstAddr");
     private int mask = 0x00ffffff;
     private byte[] matchLpmBytes1 = {0x0a, 0x01, 0x01, 0x01};
@@ -242,6 +277,37 @@
     }
 
     /**
+     * Test the OptionalMatchPi method.
+     */
+    @Test
+    public void testOptionalMatchPiMethod() {
+
+        Criterion matchPiBytes = PiCriterion.builder().matchOptional(ethMatchFieldId, matchExactBytes1).build();
+        PiCriterion piCriterionBytes = checkAndConvert(matchPiBytes, Criterion.Type.PROTOCOL_INDEPENDENT,
+                                                       PiCriterion.class);
+        PiFieldMatch expectedMatchBytes = new PiOptionalFieldMatch(ethMatchFieldId, copyFrom(matchExactBytes1));
+        assertThat(piCriterionBytes.fieldMatches().iterator().next(), is(expectedMatchBytes));
+
+        Criterion matchPiShort = PiCriterion.builder().matchOptional(ethMatchFieldId, matchExactShort1).build();
+        PiCriterion piCriterionShort = checkAndConvert(matchPiShort, Criterion.Type.PROTOCOL_INDEPENDENT,
+                                                       PiCriterion.class);
+        PiFieldMatch expectedMatchShort = new PiOptionalFieldMatch(ethMatchFieldId, copyFrom(matchExactShort1));
+        assertThat(piCriterionShort.fieldMatches().iterator().next(), is(expectedMatchShort));
+
+        Criterion matchPiInt = PiCriterion.builder().matchOptional(ethMatchFieldId, matchExactInt1).build();
+        PiCriterion piCriterionInt = checkAndConvert(matchPiInt, Criterion.Type.PROTOCOL_INDEPENDENT,
+                                                     PiCriterion.class);
+        PiFieldMatch expectedMatchInt = new PiOptionalFieldMatch(ethMatchFieldId, copyFrom(matchExactInt1));
+        assertThat(piCriterionInt.fieldMatches().iterator().next(), is(expectedMatchInt));
+
+        Criterion matchPiLong = PiCriterion.builder().matchOptional(ethMatchFieldId, matchExactLong1).build();
+        PiCriterion piCriterionLong = checkAndConvert(matchPiLong, Criterion.Type.PROTOCOL_INDEPENDENT,
+                                                      PiCriterion.class);
+        PiFieldMatch expectedMatchLong = new PiOptionalFieldMatch(ethMatchFieldId, copyFrom(matchExactLong1));
+        assertThat(piCriterionLong.fieldMatches().iterator().next(), is(expectedMatchLong));
+    }
+
+    /**
      * Test the LpmMatchPi method.
      */
     @Test
@@ -388,6 +454,32 @@
      * Test the equals() method of the PiCriterion class.
      */
     @Test
+    public void testPiOptionalCriterionEquals() {
+        new EqualsTester()
+                .addEqualityGroup(matchPiOptionalByte1, sameAsMatchPiOptionalByte1)
+                .addEqualityGroup(matchPiOptionalByte2)
+                .testEquals();
+
+        new EqualsTester()
+                .addEqualityGroup(matchPiOptionalShort1, sameAsMatchPiOptionalShort1)
+                .addEqualityGroup(matchPiOptionalShort2)
+                .testEquals();
+
+        new EqualsTester()
+                .addEqualityGroup(matchPiOptionalInt1, sameAsMatchPiOptionalInt1)
+                .addEqualityGroup(matchPiOptionalInt2)
+                .testEquals();
+
+        new EqualsTester()
+                .addEqualityGroup(matchPiOptionalLong1, sameAsMatchPiOptionalLong1)
+                .addEqualityGroup(matchPiOptionalLong2)
+                .testEquals();
+    }
+
+    /**
+     * Test the equals() method of the PiCriterion class.
+     */
+    @Test
     public void testPiLpmCriterionEquals() {
         new EqualsTester()
                 .addEqualityGroup(matchPiLpmByte1, sameAsMatchPiLpmByte1)
diff --git a/core/api/src/test/java/org/onosproject/net/pi/runtime/PiOptionalFieldMatchTest.java b/core/api/src/test/java/org/onosproject/net/pi/runtime/PiOptionalFieldMatchTest.java
new file mode 100644
index 0000000..6e0c3d9
--- /dev/null
+++ b/core/api/src/test/java/org/onosproject/net/pi/runtime/PiOptionalFieldMatchTest.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright 2020-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.net.pi.runtime;
+
+import com.google.common.testing.EqualsTester;
+import org.junit.Test;
+import org.onlab.util.ImmutableByteSequence;
+import org.onosproject.net.pi.model.PiMatchFieldId;
+import org.onosproject.net.pi.model.PiMatchType;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.notNullValue;
+import static org.onlab.junit.ImmutableClassChecker.assertThatClassIsImmutable;
+import static org.onlab.util.ImmutableByteSequence.copyFrom;
+import static org.onosproject.net.pi.runtime.PiConstantsTest.*;
+
+/**
+ * Unit tests for PiOptionalFieldMatch class.
+ */
+public class PiOptionalFieldMatchTest {
+
+    private final ImmutableByteSequence value1 = copyFrom(0x0800);
+    private final ImmutableByteSequence value2 = copyFrom(0x0806);
+    private final PiMatchFieldId piMatchField = PiMatchFieldId.of(ETH_HEADER_NAME + DOT + ETH_TYPE);
+    private PiOptionalFieldMatch piOptionalFieldMatch1 = new PiOptionalFieldMatch(piMatchField, value1);
+    private PiOptionalFieldMatch sameAsPiOptionalFieldMatch1 = new PiOptionalFieldMatch(piMatchField, value1);
+    private PiOptionalFieldMatch piOptionalFieldMatch2 = new PiOptionalFieldMatch(piMatchField, value2);
+
+    /**
+     * Checks that the PiOptionalFieldMatch class is immutable.
+     */
+    @Test
+    public void testImmutability() {
+        assertThatClassIsImmutable(PiOptionalFieldMatch.class);
+    }
+
+    /**
+     * Checks the operation of equals(), hashCode() and toString() methods.
+     */
+    @Test
+    public void testEquals() {
+        new EqualsTester()
+                .addEqualityGroup(piOptionalFieldMatch1, sameAsPiOptionalFieldMatch1)
+                .addEqualityGroup(piOptionalFieldMatch2)
+                .testEquals();
+    }
+
+    /**
+     * Checks the construction of a PiOptionalFieldMatch object.
+     */
+    @Test
+    public void testConstruction() {
+        final ImmutableByteSequence value = copyFrom(0x0806);
+        final PiMatchFieldId piMatchField = PiMatchFieldId.of(ETH_HEADER_NAME + DOT + ETH_TYPE);
+        PiOptionalFieldMatch piOptionalFieldMatch = new PiOptionalFieldMatch(piMatchField, value);
+        assertThat(piOptionalFieldMatch, is(notNullValue()));
+        assertThat(piOptionalFieldMatch.value(), is(value));
+        assertThat(piOptionalFieldMatch.type(), is(PiMatchType.OPTIONAL));
+    }
+}