diff --git a/core/api/src/main/java/org/onosproject/net/intent/util/IntentFilter.java b/core/api/src/main/java/org/onosproject/net/intent/util/IntentFilter.java
new file mode 100644
index 0000000..74a0221
--- /dev/null
+++ b/core/api/src/main/java/org/onosproject/net/intent/util/IntentFilter.java
@@ -0,0 +1,177 @@
+/*
+ * Copyright 2016-present Open Networking Laboratory
+ *
+ * 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.intent.util;
+
+import org.onosproject.net.DeviceId;
+import org.onosproject.net.flow.DefaultFlowRule;
+import org.onosproject.net.flow.FlowEntry;
+import org.onosproject.net.flow.FlowRule;
+import org.onosproject.net.flow.FlowRuleService;
+import org.onosproject.net.flowobjective.DefaultForwardingObjective;
+import org.onosproject.net.flowobjective.DefaultNextObjective;
+import org.onosproject.net.flowobjective.ForwardingObjective;
+import org.onosproject.net.flowobjective.NextObjective;
+import org.onosproject.net.flowobjective.Objective;
+import org.onosproject.net.intent.FlowObjectiveIntent;
+import org.onosproject.net.intent.FlowRuleIntent;
+import org.onosproject.net.intent.Intent;
+import org.onosproject.net.intent.IntentService;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+
+/**
+ * Utility to get flow entries corresponding to specified intent.
+ */
+public class IntentFilter {
+
+    private final IntentService intentService;
+    private final FlowRuleService flowRuleService;
+
+    /**
+     * Creates an intent filter.
+     *
+     * @param intentService intent service object
+     * @param flowRuleService flow service object
+     */
+    public IntentFilter(IntentService intentService,
+                        FlowRuleService flowRuleService) {
+        this.intentService = intentService;
+        this.flowRuleService = flowRuleService;
+    }
+
+    //checks whether the collection is empty or not.
+    private boolean nonEmpty(Collection<?> c) {
+        return c != null && !c.isEmpty();
+    }
+
+    /**
+     * Finds all path (flow entries) corresponding to intent installables.
+     *
+     * @param installables set of installables
+     * @return set of flow entries
+     */
+    public List<List<FlowEntry>> readIntentFlows(List<Intent> installables) {
+        List<List<FlowEntry>> paths = new ArrayList<>();
+
+        for (Intent installable : installables) {
+
+            if (installable instanceof FlowRuleIntent) {
+                List<FlowEntry> flowEntries =
+                        getFlowEntries((FlowRuleIntent) installable);
+                if (nonEmpty(flowEntries)) {
+                    paths.add(flowEntries);
+                }
+
+            } else if (installable instanceof FlowObjectiveIntent) {
+                List<FlowEntry> flowEntries = getFlowEntries(
+                        (FlowObjectiveIntent) installable);
+                if (nonEmpty(flowEntries)) {
+                    paths.add(flowEntries);
+                }
+            }
+        }
+        return paths;
+    }
+
+    /**
+     * Finds all flow entries created by FlowRuleIntent.
+     *
+     * @param intent FlowRuleIntent Object
+     * @return set of flow entries created by FlowRuleIntent
+     */
+    private List<FlowEntry> getFlowEntries(FlowRuleIntent intent) {
+        List<FlowEntry> flowEntries = new ArrayList<>();
+        Collection<FlowRule> flowRules = intent.flowRules();
+        FlowEntry flowEntry;
+
+        for (FlowRule flowRule : flowRules) {
+            flowEntry = getFlowEntry(flowRule);
+
+            if (flowEntry != null) {
+                flowEntries.add(flowEntry);
+            }
+        }
+        return flowEntries;
+    }
+
+    /**
+     * Finds all flow entries created by FlowObjectiveIntent.
+     *
+     * @param intent FlowObjectiveIntent Object
+     * @return set of flow entries created by FlowObjectiveIntent
+     */
+    private List<FlowEntry> getFlowEntries(FlowObjectiveIntent intent) {
+        List<FlowEntry> flowEntries = new ArrayList<>();
+        Iterator<Objective> objectives = intent.objectives().iterator();
+        Iterator<DeviceId> devices = intent.devices().iterator();
+        DefaultNextObjective nextObjective = null;
+        DefaultForwardingObjective forwardObjective;
+        Objective objective;
+        DeviceId deviceId;
+        FlowEntry flowEntry;
+
+        while (objectives.hasNext()) {
+            objective = objectives.next();
+            deviceId = devices.next();
+
+            if (objective instanceof NextObjective) {
+                nextObjective = (DefaultNextObjective) objective;
+                continue;
+
+            } else if (objective instanceof ForwardingObjective) {
+                forwardObjective = (DefaultForwardingObjective) objective;
+                FlowRule flowRule = DefaultFlowRule.builder()
+                        .forDevice(deviceId)
+                        .withSelector(forwardObjective.selector())
+                        .withTreatment(nextObjective.next().iterator().next())
+                        .withPriority(intent.priority())
+                        .fromApp(intent.appId())
+                        .makePermanent()
+                        .build();
+                flowEntry = getFlowEntry(flowRule);
+
+                if (flowEntry != null) {
+                    flowEntries.add(flowEntry);
+                }
+            }
+        }
+        return flowEntries;
+    }
+
+    /**
+     * Finds FlowEntry matching with the FlowRule.
+     *
+     * @param flowRule FlowRule object
+     * @return flow entry matching to FlowRule
+     */
+    private FlowEntry getFlowEntry(FlowRule flowRule) {
+        Iterable<FlowEntry> flowEntries =
+                flowRuleService.getFlowEntries(flowRule.deviceId());
+
+        if (flowEntries != null) {
+            for (FlowEntry entry : flowEntries) {
+                if (entry.exactMatch(flowRule)) {
+                    return entry;
+                }
+            }
+        }
+        return null;
+    }
+
+}
diff --git a/core/api/src/main/java/org/onosproject/net/intent/util/package-info.java b/core/api/src/main/java/org/onosproject/net/intent/util/package-info.java
new file mode 100644
index 0000000..d7593ef
--- /dev/null
+++ b/core/api/src/main/java/org/onosproject/net/intent/util/package-info.java
@@ -0,0 +1,20 @@
+/*
+ * Copyright 2016-present Open Networking Laboratory
+ *
+ * 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 supports intent northbound apis providing utility classes.
+ */
+package org.onosproject.net.intent.util;
diff --git a/web/api/src/main/java/org/onosproject/rest/resources/IntentsWebResource.java b/web/api/src/main/java/org/onosproject/rest/resources/IntentsWebResource.java
index e9d1b9b..b3b7752 100644
--- a/web/api/src/main/java/org/onosproject/rest/resources/IntentsWebResource.java
+++ b/web/api/src/main/java/org/onosproject/rest/resources/IntentsWebResource.java
@@ -15,9 +15,12 @@
  */
 package org.onosproject.rest.resources;
 
+import com.fasterxml.jackson.databind.node.ArrayNode;
 import com.fasterxml.jackson.databind.node.ObjectNode;
 import org.onosproject.core.ApplicationId;
 import org.onosproject.core.CoreService;
+import org.onosproject.net.flow.FlowEntry;
+import org.onosproject.net.flow.FlowRuleService;
 import org.onosproject.net.intent.SinglePointToMultiPointIntent;
 import org.onosproject.net.intent.PointToPointIntent;
 import org.onosproject.net.intent.HostToHostIntent;
@@ -27,6 +30,7 @@
 import org.onosproject.net.intent.IntentListener;
 import org.onosproject.net.intent.IntentService;
 import org.onosproject.net.intent.Key;
+import org.onosproject.net.intent.util.IntentFilter;
 import org.onosproject.rest.AbstractWebResource;
 import org.slf4j.Logger;
 
@@ -44,6 +48,7 @@
 import javax.ws.rs.core.UriInfo;
 import java.io.IOException;
 import java.io.InputStream;
+import java.util.List;
 import java.util.Objects;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;
@@ -58,15 +63,25 @@
  */
 @Path("intents")
 public class IntentsWebResource extends AbstractWebResource {
-    @Context
-    private UriInfo uriInfo;
 
     private static final Logger log = getLogger(IntentsWebResource.class);
     private static final int WITHDRAW_EVENT_TIMEOUT_SECONDS = 5;
 
     private static final String APP_ID_NOT_FOUND = "Application Id not found";
+    private static final String HOST_TO_HOST_INTENT = "HostToHostIntent";
+    private static final String POINT_TO_POINT_INTENT = "PointToPointIntent";
+    private static final String SINGLE_TO_MULTI_POINT_INTENT =
+            "SinglePointToMultiPointIntent";
+    private static final String INTENT = "Intent";
+    private static final String APP_ID = "appId";
+    private static final String ID = "id";
+    private static final String INTENT_PATHS = "paths";
+    private static final String INTENT_TYPE = "type";
     private static final String INTENT_NOT_FOUND = "Intent is not found";
 
+    @Context
+    private UriInfo uriInfo;
+
     /**
      * Gets all intents.
      * Returns array containing all the intents in the system.
@@ -119,6 +134,65 @@
     }
 
     /**
+     * Gets all related flow entries created by a particular intent.
+     * Returns all flow entries of the specified intent.
+     *
+     * @param appId application identifier
+     * @param key   intent key
+     * @return 200 OK with intent data
+     * @onos.rsModel Relatedflows
+     */
+    @GET
+    @Produces(MediaType.APPLICATION_JSON)
+    @Path("relatedflows/{appId}/{key}")
+    public Response getIntentFlowsById(@PathParam("appId") String appId,
+                                       @PathParam("key") String key) {
+        ApplicationId applicationId = get(CoreService.class).getAppId(appId);
+        nullIsNotFound(applicationId, APP_ID_NOT_FOUND);
+        IntentService intentService = get(IntentService.class);
+        FlowRuleService flowService = get(FlowRuleService.class);
+
+        Intent intent = intentService.getIntent(Key.of(key, applicationId));
+        if (intent == null) {
+            long numericalKey = Long.decode(key);
+            intent = intentService.getIntent(
+                    Key.of(numericalKey, applicationId));
+        }
+        nullIsNotFound(intent, INTENT_NOT_FOUND);
+
+        ObjectNode root = mapper().createObjectNode();
+        root.put(APP_ID, appId);
+        root.put(ID, key);
+
+        IntentFilter intentFilter = new IntentFilter(intentService, flowService);
+
+        List<Intent> installables =
+                intentService.getInstallableIntents(intent.key());
+
+        if (intent instanceof HostToHostIntent) {
+            root.put(INTENT_TYPE, HOST_TO_HOST_INTENT);
+        } else if (intent instanceof PointToPointIntent) {
+            root.put(INTENT_TYPE, POINT_TO_POINT_INTENT);
+        } else if (intent instanceof SinglePointToMultiPointIntent) {
+            root.put(INTENT_TYPE, SINGLE_TO_MULTI_POINT_INTENT);
+        } else {
+            root.put(INTENT_TYPE, INTENT);
+        }
+
+        ArrayNode pathsNode = root.putArray(INTENT_PATHS);
+
+        for (List<FlowEntry> flowEntries :
+                intentFilter.readIntentFlows(installables)) {
+            ArrayNode flowNode = pathsNode.addArray();
+
+            for (FlowEntry entry : flowEntries) {
+                flowNode.add(codec(FlowEntry.class).encode(entry, this));
+            }
+        }
+        return ok(root).build();
+    }
+
+    /**
      * Internal listener for tracking the intent deletion events.
      */
     private class DeleteListener implements IntentListener {
diff --git a/web/api/src/main/resources/definitions/Relatedflows.json b/web/api/src/main/resources/definitions/Relatedflows.json
new file mode 100644
index 0000000..9e61c58
--- /dev/null
+++ b/web/api/src/main/resources/definitions/Relatedflows.json
@@ -0,0 +1,208 @@
+{
+  "type": "object",
+  "title": "relatedflows",
+  "required": [
+    "id",
+    "appId",
+    "type",
+    "paths"
+  ],
+  "properties": {
+    "id": {
+      "type": "string",
+      "example": "0x5"
+    },
+    "appId": {
+      "type": "string",
+      "example": "org.onosproject.ovsdb"
+    },
+    "type": {
+      "type": "string",
+      "example": "HostToHostIntent"
+    },
+    "paths": {
+      "type": "array",
+      "xml": {
+        "name": "paths",
+        "wrapped": true
+      },
+      "items": {
+        "type": "array",
+        "xml": {
+          "name": "flows",
+          "wrapped": true
+        },
+        "items": {
+          "type": "object",
+          "title": "flow",
+          "required": [
+            "id",
+            "tableId",
+            "appId",
+            "groupId",
+            "priority",
+            "timeout",
+            "isPermanent",
+            "deviceId",
+            "state",
+            "life",
+            "packets",
+            "bytes",
+            "lastSeen"
+          ],
+          "properties": {
+            "id": {
+              "type": "string",
+              "example": "12103425214920339"
+            },
+            "tableId": {
+              "type": "integer",
+              "format": "int32",
+              "example": 3
+            },
+            "appId": {
+              "type": "string",
+              "example": "org.onosproject.core"
+            },
+            "groupId": {
+              "type": "integer",
+              "format": "int64",
+              "example": 0
+            },
+            "priority": {
+              "type": "integer",
+              "format": "int32",
+              "example": 40000
+            },
+            "timeout": {
+              "type": "integer",
+              "format": "int32",
+              "example": 0
+            },
+            "isPermanent": {
+              "type": "boolean",
+              "example": true
+            },
+            "deviceId": {
+              "type": "string",
+              "example": "of:0000000000000003"
+            },
+            "state": {
+              "type": "string",
+              "example": "ADDED"
+            },
+            "life": {
+              "type": "integer",
+              "format": "int64",
+              "example": 69889
+            },
+            "packets": {
+              "type": "integer",
+              "format": "int64",
+              "example": 22546
+            },
+            "bytes": {
+              "type": "integer",
+              "format": "int64",
+              "example": 1826226
+            },
+            "lastSeen": {
+              "type": "integer",
+              "format": "int64",
+              "example": 1447892365670
+            },
+            "treatment": {
+              "type": "object",
+              "title": "treatment",
+              "required": [
+                "instructions",
+                "deferred"
+              ],
+              "properties": {
+                "instructions": {
+                  "type": "array",
+                  "title": "treatment",
+                  "required": [
+                    "properties",
+                    "port"
+                  ],
+                  "items": {
+                    "type": "object",
+                    "title": "instruction",
+                    "required": [
+                      "type",
+                      "port"
+                    ],
+                    "properties": {
+                      "type": {
+                        "type": "string",
+                        "example": "OUTPUT"
+                      },
+                      "port": {
+                        "type": "string",
+                        "example": "CONTROLLER"
+                      }
+                    }
+                  }
+                },
+                "deferred": {
+                  "type": "array",
+                  "xml": {
+                    "name": "deferred",
+                    "wrapped": true
+                  },
+                  "items": {
+                    "type": "string"
+                  }
+                }
+              }
+            },
+            "selector": {
+              "type": "object",
+              "title": "selector",
+              "required": [
+                "criteria"
+              ],
+              "properties": {
+                "criteria": {
+                  "type": "array",
+                  "xml": {
+                    "name": "criteria",
+                    "wrapped": true
+                  },
+                  "items": {
+                    "type": "object",
+                    "title": "criteria",
+                    "properties": {
+                      "type": {
+                        "type": "string",
+                        "description": "Ethernet field name",
+                        "example": "ETH_TYPE"
+                      },
+                      "ethType": {
+                        "type": "int64",
+                        "format": "int64",
+                        "example": "0x88cc",
+                        "description": "Ethernet frame type"
+                      },
+                      "mac": {
+                        "type": "string",
+                        "example": "00:00:11:00:00:01"
+                      },
+                      "port": {
+                        "type": "int64",
+                        "format": "int64",
+                        "example": 1,
+                        "description": "Match port"
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}
diff --git a/web/api/src/test/java/org/onosproject/rest/resources/IntentsResourceTest.java b/web/api/src/test/java/org/onosproject/rest/resources/IntentsResourceTest.java
index e87b94a..a42855b 100644
--- a/web/api/src/test/java/org/onosproject/rest/resources/IntentsResourceTest.java
+++ b/web/api/src/test/java/org/onosproject/rest/resources/IntentsResourceTest.java
@@ -15,17 +15,10 @@
  */
 package org.onosproject.rest.resources;
 
-import java.io.InputStream;
-import java.net.HttpURLConnection;
-import java.util.Collections;
-import java.util.HashSet;
-
-import javax.ws.rs.NotFoundException;
-import javax.ws.rs.client.Entity;
-import javax.ws.rs.client.WebTarget;
-import javax.ws.rs.core.MediaType;
-import javax.ws.rs.core.Response;
-
+import com.eclipsesource.json.Json;
+import com.eclipsesource.json.JsonArray;
+import com.eclipsesource.json.JsonObject;
+import com.eclipsesource.json.JsonValue;
 import org.hamcrest.Description;
 import org.hamcrest.Matchers;
 import org.hamcrest.TypeSafeMatcher;
@@ -34,35 +27,52 @@
 import org.junit.Test;
 import org.onlab.osgi.ServiceDirectory;
 import org.onlab.osgi.TestServiceDirectory;
+import org.onlab.packet.MacAddress;
 import org.onlab.rest.BaseResource;
 import org.onosproject.codec.CodecService;
 import org.onosproject.codec.impl.CodecManager;
 import org.onosproject.core.ApplicationId;
 import org.onosproject.core.CoreService;
 import org.onosproject.core.DefaultApplicationId;
+import org.onosproject.core.DefaultGroupId;
+import org.onosproject.core.GroupId;
 import org.onosproject.core.IdGenerator;
+import org.onosproject.net.DeviceId;
 import org.onosproject.net.NetworkResource;
+import org.onosproject.net.flow.DefaultTrafficSelector;
+import org.onosproject.net.flow.DefaultTrafficTreatment;
+import org.onosproject.net.flow.FlowEntry;
+import org.onosproject.net.flow.FlowId;
+import org.onosproject.net.flow.FlowRule;
+import org.onosproject.net.flow.FlowRuleExtPayLoad;
+import org.onosproject.net.flow.FlowRuleService;
+import org.onosproject.net.flow.TrafficSelector;
+import org.onosproject.net.flow.TrafficTreatment;
+import org.onosproject.net.flow.criteria.Criterion;
+import org.onosproject.net.flow.instructions.Instruction;
 import org.onosproject.net.intent.FakeIntentManager;
+import org.onosproject.net.intent.FlowRuleIntent;
 import org.onosproject.net.intent.Intent;
 import org.onosproject.net.intent.IntentService;
 import org.onosproject.net.intent.IntentState;
 import org.onosproject.net.intent.Key;
 
-import com.eclipsesource.json.Json;
-import com.eclipsesource.json.JsonArray;
-import com.eclipsesource.json.JsonObject;
-import com.eclipsesource.json.JsonValue;
+import javax.ws.rs.NotFoundException;
+import javax.ws.rs.client.Entity;
+import javax.ws.rs.client.WebTarget;
+import javax.ws.rs.core.MediaType;
+import javax.ws.rs.core.Response;
+import java.io.InputStream;
+import java.net.HttpURLConnection;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
 
-import static org.easymock.EasyMock.anyObject;
-import static org.easymock.EasyMock.createMock;
-import static org.easymock.EasyMock.expect;
-import static org.easymock.EasyMock.expectLastCall;
-import static org.easymock.EasyMock.replay;
-import static org.easymock.EasyMock.verify;
-import static org.hamcrest.Matchers.containsString;
-import static org.hamcrest.Matchers.hasSize;
-import static org.hamcrest.Matchers.is;
-import static org.hamcrest.Matchers.notNullValue;
+import static java.util.concurrent.TimeUnit.SECONDS;
+import static org.easymock.EasyMock.*;
+import static org.hamcrest.Matchers.*;
 import static org.junit.Assert.assertThat;
 import static org.junit.Assert.fail;
 import static org.onosproject.net.intent.IntentTestsMocks.MockIntent;
@@ -72,12 +82,51 @@
  * Unit tests for Intents REST APIs.
  */
 public class IntentsResourceTest extends ResourceTest {
+
+
+    private static final String APPID = "appId";
+    private static final String CRITERIA = "criteria";
+    private static final String DEVICE_ID = "deviceId";
+    private static final String ID = "id";
+    private static final String INSTRUCTIONS = "instructions";
+    private static final String PATHS = "paths";
+    private static final String SELECTOR = "selector";
+    private static final String SPACE = " ";
+    private static final String TREATMENT = "treatment";
+    private static final String TYPE = "type";
+
     final IntentService mockIntentService = createMock(IntentService.class);
     final CoreService mockCoreService = createMock(CoreService.class);
+    final FlowRuleService mockFlowService = createMock(FlowRuleService.class);
     final HashSet<Intent> intents = new HashSet<>();
+    final List<org.onosproject.net.intent.Intent> installableIntents = new ArrayList<>();
     private static final ApplicationId APP_ID = new DefaultApplicationId(1, "test");
     private IdGenerator mockGenerator;
 
+    final DeviceId deviceId1 = DeviceId.deviceId("1");
+
+    final TrafficTreatment treatment1 = DefaultTrafficTreatment.builder()
+            .setEthDst(MacAddress.BROADCAST)
+            .build();
+    final TrafficTreatment treatment2 = DefaultTrafficTreatment.builder()
+            .setEthDst(MacAddress.IPV4_MULTICAST)
+            .build();
+
+    final TrafficSelector selector1 = DefaultTrafficSelector.builder()
+            .matchEthType((short) 3)
+            .matchIPProtocol((byte) 9)
+            .build();
+    final TrafficSelector selector2 = DefaultTrafficSelector.builder()
+            .matchEthType((short) 4)
+            .matchIPProtocol((byte) 10)
+            .build();
+
+    final MockFlowEntry flow1 = new MockFlowEntry(deviceId1, 1, treatment1, selector1);
+    final MockFlowEntry flow2 = new MockFlowEntry(deviceId1, 2, treatment2, selector2);
+
+    final MockFlowRule flowRule1 = new MockFlowRule(deviceId1, 1, treatment1, selector1);
+    final MockFlowRule flowRule2 = new MockFlowRule(deviceId1, 2, treatment2, selector2);
+
     private class MockResource implements NetworkResource {
         int id;
 
@@ -92,6 +141,237 @@
     }
 
     /**
+     * Mock class for a flow entry.
+     */
+    private static class MockFlowEntry implements FlowEntry {
+        final DeviceId deviceId;
+        final long baseValue;
+        TrafficTreatment treatment;
+        TrafficSelector selector;
+
+        public MockFlowEntry(DeviceId deviceId, long id,
+                             TrafficTreatment treatment,
+                             TrafficSelector selector) {
+            this.deviceId = deviceId;
+            this.baseValue = id * 100;
+            this.treatment = treatment;
+            this.selector = selector;
+        }
+
+        @Override
+        public FlowEntryState state() {
+            return FlowEntryState.ADDED;
+        }
+
+        @Override
+        public long life() {
+            return life(SECONDS);
+        }
+
+        @Override
+        public long life(TimeUnit timeUnit) {
+            return SECONDS.convert(baseValue + 11, timeUnit);
+        }
+
+        @Override
+        public long packets() {
+            return baseValue + 22;
+        }
+
+        @Override
+        public long bytes() {
+            return baseValue + 33;
+        }
+
+        @Override
+        public long lastSeen() {
+            return baseValue + 44;
+        }
+
+        @Override
+        public int errType() {
+            return 0;
+        }
+
+        @Override
+        public int errCode() {
+            return 0;
+        }
+
+        @Override
+        public FlowId id() {
+            final long id = baseValue + 55;
+            return FlowId.valueOf(id);
+        }
+
+        @Override
+        public GroupId groupId() {
+            return new DefaultGroupId(3);
+        }
+
+        @Override
+        public short appId() {
+            return 1;
+        }
+
+        @Override
+        public int priority() {
+            return (int) (baseValue + 66);
+        }
+
+        @Override
+        public DeviceId deviceId() {
+            return deviceId;
+        }
+
+        @Override
+        public TrafficSelector selector() {
+            return selector;
+        }
+
+        @Override
+        public TrafficTreatment treatment() {
+            return treatment;
+        }
+
+        @Override
+        public int timeout() {
+            return (int) (baseValue + 77);
+        }
+
+        @Override
+        public int hardTimeout() {
+            return 0;
+        }
+
+        @Override
+        public FlowRule.FlowRemoveReason reason() {
+            return  FlowRule.FlowRemoveReason.NO_REASON;
+        }
+
+        @Override
+        public boolean isPermanent() {
+            return false;
+        }
+
+        @Override
+        public int tableId() {
+            return 0;
+        }
+
+        @Override
+        public boolean exactMatch(FlowRule rule) {
+            return this.appId() == rule.appId() &&
+                    this.deviceId().equals(rule.deviceId()) &&
+                    this.id().equals(rule.id()) &&
+                    this.treatment.equals(rule.treatment()) &&
+                    this.selector().equals(rule.selector());
+        }
+
+        @Override
+        public FlowRuleExtPayLoad payLoad() {
+            return null;
+        }
+
+        @Override
+        public String toString() {
+            return id().id().toString();
+        }
+    }
+
+    /**
+     * Mock class for a flow rule.
+     */
+    private static class MockFlowRule implements FlowRule {
+
+        final DeviceId deviceId;
+        final long baseValue;
+        TrafficTreatment treatment;
+        TrafficSelector selector;
+
+        public MockFlowRule(DeviceId deviceId,
+                            long id,
+                            TrafficTreatment treatment,
+                            TrafficSelector selector) {
+            this.deviceId = deviceId;
+            this.baseValue = id * 100;
+            this.treatment = treatment;
+            this.selector = selector;
+        }
+
+        @Override
+        public FlowId id() {
+            long id = baseValue + 55;
+            return FlowId.valueOf(id);
+        }
+
+        @Override
+        public short appId() {
+            return 1;
+        }
+
+        @Override
+        public GroupId groupId() {
+            return new DefaultGroupId(3);
+        }
+
+        @Override
+        public int priority() {
+            return 0;
+        }
+
+        @Override
+        public DeviceId deviceId() {
+            return deviceId;
+        }
+
+        @Override
+        public TrafficSelector selector() {
+            return selector;
+        }
+
+        @Override
+        public TrafficTreatment treatment() {
+            return treatment;
+        }
+
+        @Override
+        public int timeout() {
+            return (int) (baseValue + 77);
+        }
+
+        @Override
+        public int hardTimeout() {
+            return 0;
+        }
+
+        @Override
+        public FlowRemoveReason reason() {
+            return FlowRemoveReason.NO_REASON;
+        }
+
+        @Override
+        public boolean isPermanent() {
+            return false;
+        }
+
+        @Override
+        public int tableId() {
+            return 0;
+        }
+
+        @Override
+        public boolean exactMatch(FlowRule rule) {
+            return false;
+        }
+
+        @Override
+        public FlowRuleExtPayLoad payLoad() {
+            return null;
+        }
+    }
+
+    /**
      * Hamcrest matcher to check that an intent representation in JSON matches
      * the actual intent.
      */
@@ -180,6 +460,195 @@
     }
 
     /**
+     * Factory to allocate an IntentRelatedFlows matcher.
+     *
+     * @param pathEntries list of path conatining flow entries of a particular intent
+     * @param expectedAppId expected app id we are looking for
+     * @return matcher
+     */
+    private static IntentStatsJsonMatcher matchesRelatedFlowEntries(
+            List<List<FlowEntry>> pathEntries,
+            final String expectedAppId) {
+        return new IntentStatsJsonMatcher(pathEntries, expectedAppId);
+    }
+
+    /**
+     * Hamcrest matcher to check that an list of flowEntries in JSON matches
+     * the actual list of flow entries.
+     */
+    public static class IntentStatsJsonMatcher extends
+            TypeSafeMatcher<JsonObject> {
+
+        private final List<List<FlowEntry>> pathEntries;
+        private final String expectedAppId;
+        private String reason = "";
+
+        public IntentStatsJsonMatcher(
+                final List<List<FlowEntry>> pathEntries,
+                final String expectedAppId) {
+            this.pathEntries = pathEntries;
+            this.expectedAppId = expectedAppId;
+        }
+
+        @Override
+        public boolean matchesSafely(JsonObject jsonIntent) {
+            int jsonPathIndex = 0;
+            JsonArray jsonPaths = jsonIntent.get(PATHS).asArray();
+
+            if (pathEntries != null) {
+
+                if (pathEntries.size() != jsonPaths.size()) {
+                    reason = "path entries array size of " +
+                            Integer.toString(pathEntries.size());
+                    return false;
+                }
+
+                for (List<FlowEntry> flowEntries : pathEntries) {
+                    JsonArray jsonFlowEntries = jsonPaths.get(
+                            jsonPathIndex++).asArray();
+
+                    if (flowEntries.size() != jsonFlowEntries.size()) {
+                        reason = "flow entries array size of " +
+                                Integer.toString(pathEntries.size());
+
+                        return false;
+                    }
+
+                    int jsonFlowEntryIndex = 0;
+                    for (FlowEntry flow : flowEntries) {
+
+                        JsonObject jsonFlow = jsonFlowEntries.get(
+                                jsonFlowEntryIndex++).asObject();
+
+                        String jsonId = jsonFlow.get(ID).asString();
+                        String flowId = Long.toString(flow.id().value());
+                        if (!jsonId.equals(flowId)) {
+                            reason = ID + SPACE + flow.id();
+                            return false;
+                        }
+
+                        // check application id
+                        String jsonAppId = jsonFlow.get(APPID).asString();
+                        if (!jsonAppId.equals(expectedAppId)) {
+                            reason = APPID + SPACE + Short.toString(flow.appId());
+                            return false;
+                        }
+
+                        // check device id
+                        String jsonDeviceId =
+                                jsonFlow.get(DEVICE_ID).asString();
+
+                        if (!jsonDeviceId.equals(flow.deviceId().toString())) {
+                            reason = DEVICE_ID + SPACE + flow.deviceId();
+                            return false;
+                        }
+
+                        if (!checkFlowTreatment(flow, jsonFlow)) {
+                            return false;
+                        }
+
+                        if (!checkFlowSelector(flow, jsonFlow)) {
+                            return false;
+                        }
+
+                    }
+
+                }
+            } else if (pathEntries.size() != 0) {
+                reason = "pathEntries array empty";
+                return false;
+            }
+
+            return true;
+        }
+
+        // check treatment and instructions array.
+        private boolean checkFlowTreatment(FlowEntry flow, JsonObject jsonFlow) {
+
+            if (flow.treatment() != null) {
+                JsonObject jsonTreatment =
+                        jsonFlow.get(TREATMENT).asObject();
+                JsonArray jsonInstructions =
+                        jsonTreatment.get(INSTRUCTIONS).asArray();
+
+                if (flow.treatment().immediate().size() !=
+                        jsonInstructions.size()) {
+                    reason = "instructions array size of " +
+                            flow.treatment().immediate().size();
+
+                    return false;
+                }
+                for (Instruction instruction :
+                        flow.treatment().immediate()) {
+                    boolean instructionFound = false;
+                    for (int instructionIndex = 0;
+                         instructionIndex < jsonInstructions.size();
+                         instructionIndex++) {
+                        String jsonType =
+                                jsonInstructions.get(instructionIndex)
+                                        .asObject().get(TYPE).asString();
+
+                        String instructionType =
+                                instruction.type().name();
+
+                        if (jsonType.equals(instructionType)) {
+                            instructionFound = true;
+                        }
+                    }
+                    if (!instructionFound) {
+                        reason = INSTRUCTIONS + SPACE + instruction;
+                        return false;
+                    }
+                }
+            }
+            return true;
+        }
+
+        // check selector and criteria array.
+        private boolean checkFlowSelector(FlowEntry flow, JsonObject jsonFlow) {
+
+            if (flow.selector() != null) {
+                JsonObject jsonTreatment =
+                        jsonFlow.get(SELECTOR).asObject();
+
+                JsonArray jsonCriteria =
+                        jsonTreatment.get(CRITERIA).asArray();
+
+                if (flow.selector().criteria().size() != jsonCriteria.size()) {
+                    reason = CRITERIA + " array size of " +
+                            Integer.toString(flow.selector().criteria().size());
+                    return false;
+                }
+                for (Criterion criterion : flow.selector().criteria()) {
+                    boolean criterionFound = false;
+
+                    for (int criterionIndex = 0;
+                         criterionIndex < jsonCriteria.size();
+                         criterionIndex++) {
+                        String jsonType =
+                                jsonCriteria.get(criterionIndex)
+                                        .asObject().get(TYPE).asString();
+                        String criterionType = criterion.type().name();
+                        if (jsonType.equals(criterionType)) {
+                            criterionFound = true;
+                        }
+                    }
+                    if (!criterionFound) {
+                        reason = "criterion " + criterion;
+                        return false;
+                    }
+                }
+            }
+            return true;
+        }
+
+        @Override
+        public void describeTo(Description description) {
+            description.appendText(reason);
+        }
+    }
+
+    /**
      * Hamcrest matcher to check that an intent is represented properly in a JSON
      * array of intents.
      */
@@ -252,6 +721,7 @@
         ServiceDirectory testDirectory =
                 new TestServiceDirectory()
                         .add(IntentService.class, mockIntentService)
+                        .add(FlowRuleService.class, mockFlowService)
                         .add(CodecService.class, codecService)
                         .add(CoreService.class, mockCoreService);
 
@@ -357,6 +827,69 @@
     }
 
     /**
+     * Tests the result of a rest api GET for related flows for single intent.
+     */
+    @Test
+    public void testRelatedFlowsForIntents() {
+        List<FlowEntry> flowEntries = new ArrayList<>();
+        flowEntries.add(flow1);
+        flowEntries.add(flow2);
+        List<List<FlowEntry>> paths = new ArrayList<>();
+        paths.add(flowEntries);
+        List<FlowRule> flowRules = new ArrayList<>();
+        flowRules.add(flowRule1);
+        flowRules.add(flowRule2);
+        FlowRuleIntent flowRuleIntent = new FlowRuleIntent(
+                APP_ID,
+                flowRules,
+                new HashSet<NetworkResource>());
+        Intent intent = new MockIntent(3L);
+        installableIntents.add(flowRuleIntent);
+        intents.add(intent);
+
+        expect(mockIntentService.getIntent(Key.of(0, APP_ID)))
+                .andReturn(intent)
+                .anyTimes();
+        expect(mockIntentService.getIntent(Key.of("0", APP_ID)))
+                .andReturn(intent)
+                .anyTimes();
+        expect(mockIntentService.getIntent(Key.of(0, APP_ID)))
+                .andReturn(intent)
+                .anyTimes();
+        expect(mockIntentService.getIntent(Key.of("0x0", APP_ID)))
+                .andReturn(null)
+                .anyTimes();
+        expect(mockIntentService.getInstallableIntents(intent.key()))
+                .andReturn(installableIntents)
+                .anyTimes();
+        replay(mockIntentService);
+
+        expect(mockFlowService.getFlowEntries(deviceId1))
+                .andReturn(flowEntries).anyTimes();
+        replay(mockFlowService);
+
+        expect(mockCoreService.getAppId(APP_ID.name()))
+                .andReturn(APP_ID).anyTimes();
+        expect(mockCoreService.getAppId(APP_ID.id()))
+                .andReturn(APP_ID).anyTimes();
+        replay(mockCoreService);
+
+        final WebTarget wt = target();
+
+        // Test get using key string
+        final String response = wt.path("intents/relatedflows/" + APP_ID.name()
+                + "/0").request().get(String.class);
+        final JsonObject result = Json.parse(response).asObject();
+        assertThat(result, matchesRelatedFlowEntries(paths, APP_ID.name()));
+
+        // Test get using numeric value
+        final String responseNumeric = wt.path("intents/relatedflows/" + APP_ID.name()
+                + "/0x0").request().get(String.class);
+        final JsonObject resultNumeric = Json.parse(responseNumeric).asObject();
+        assertThat(resultNumeric, matchesRelatedFlowEntries(paths, APP_ID.name()));
+    }
+
+    /**
      * Tests that a fetch of a non-existent intent object throws an exception.
      */
     @Test