diff --git a/examples/custom-apps/ndn-api-app.cc b/examples/custom-apps/ndn-api-app.cc
index 3346b52..db55bb6 100644
--- a/examples/custom-apps/ndn-api-app.cc
+++ b/examples/custom-apps/ndn-api-app.cc
@@ -61,6 +61,10 @@
   Ptr<Interest> interest = Create<Interest> ();
   interest->SetName (m_name);
   interest->SetInterestLifetime (m_interestLifetime);
+
+  Ptr<Exclude> exclude = Create<Exclude> ();
+  exclude->excludeOne (name::Component ("unique"));
+  interest->SetExclude (exclude);
   
   m_face->ExpressInterest (interest,
                            MakeCallback (&ApiApp::GotData, this),
@@ -80,6 +84,7 @@
   m_face = CreateObject<ApiFace> (GetNode ());
   
   Simulator::Schedule (Seconds (1), &::ns3::ndn::ApiApp::RequestData, this);
+  Simulator::Schedule (Seconds (10), &::ns3::ndn::ApiApp::RequestData, this);
 }
 
 void
diff --git a/examples/ndn-simple-api.cc b/examples/ndn-simple-api.cc
index 5fb4dd9..6580fbe 100644
--- a/examples/ndn-simple-api.cc
+++ b/examples/ndn-simple-api.cc
@@ -77,7 +77,7 @@
   ndn::AppHelper consumerHelper ("ns3::ndn::ApiApp");
   consumerHelper.SetPrefix ("/prefix");
   ApplicationContainer app = consumerHelper.Install (nodes.Get (0)); // first node
-  app.Stop (Seconds (10.0));
+  app.Stop (Seconds (15.0));
 
   // Producer
   ndn::AppHelper producerHelper ("ns3::ndn::Producer");
