diff --git a/routing/async_router.cpp b/routing/async_router.cpp
index 4e1165f1e9..66d66517d2 100644
--- a/routing/async_router.cpp
+++ b/routing/async_router.cpp
@@ -257,6 +257,7 @@ void AsyncRouter::CalculateRoute()
   bool adjustToPrevRoute = false;
   shared_ptr<IOnlineFetcher> absentFetcher;
   shared_ptr<IRouter> router;
+  uint64_t routeCounter = m_routeCounter;
 
   {
     unique_lock<mutex> ul(m_guard);
@@ -276,9 +277,10 @@ void AsyncRouter::CalculateRoute()
     delegate = m_delegate;
     router = m_router;
     absentFetcher = m_absentFetcher;
+    routeCounter = ++m_routeCounter;
   }
 
-  Route route(router->GetName());
+  Route route(router->GetName(), routeCounter);
   RouterResultCode code;
 
   my::Timer timer;
diff --git a/routing/async_router.hpp b/routing/async_router.hpp
index 2ca14542dc..6b8318b8d6 100644
--- a/routing/async_router.hpp
+++ b/routing/async_router.hpp
@@ -9,6 +9,7 @@
 
 #include "base/thread.hpp"
 
+#include "std/cstdint.hpp"
 #include "std/condition_variable.hpp"
 #include "std/map.hpp"
 #include "std/mutex.hpp"
@@ -116,6 +117,7 @@ private:
 
   RoutingStatisticsCallback const m_routingStatisticsCallback;
   PointCheckCallback const m_pointCheckCallback;
+  uint64_t m_routeCounter = 0;
 };
 
 }  // namespace routing
diff --git a/routing/route.cpp b/routing/route.cpp
index bc835eb24d..767209a7df 100644
--- a/routing/route.cpp
+++ b/routing/route.cpp
@@ -41,9 +41,13 @@ bool IsNormalTurn(TurnItem const & turn)
 }
 }  //  namespace
 
-Route::Route(string const & router, vector<m2::PointD> const & points, string const & name)
-  : m_router(router), m_routingSettings(GetRoutingSettings(VehicleType::Car)),
-    m_name(name), m_poly(points.begin(), points.end())
+Route::Route(string const & router, vector<m2::PointD> const & points, uint64_t routeId,
+             string const & name)
+  : m_router(router)
+  , m_routingSettings(GetRoutingSettings(VehicleType::Car))
+  , m_name(name)
+  , m_poly(points.begin(), points.end())
+  , m_routeId(routeId)
 {
 }
 
diff --git a/routing/route.hpp b/routing/route.hpp
index c3e7703e62..2c2f7afe7e 100644
--- a/routing/route.hpp
+++ b/routing/route.hpp
@@ -156,16 +156,21 @@ public:
     SubrouteUid const m_id = kInvalidSubrouteId;
   };
 
-  explicit Route(std::string const & router)
-    : m_router(router), m_routingSettings(GetRoutingSettings(VehicleType::Car)) {}
-
-  template <class TIter>
-  Route(std::string const & router, TIter beg, TIter end)
-    : m_router(router), m_routingSettings(GetRoutingSettings(VehicleType::Car)), m_poly(beg, end)
+  explicit Route(std::string const & router, uint64_t routeId)
+    : m_router(router), m_routingSettings(GetRoutingSettings(VehicleType::Car)), m_routeId(routeId)
   {
   }
 
-  Route(std::string const & router, std::vector<m2::PointD> const & points,
+  template <class TIter>
+  Route(std::string const & router, TIter beg, TIter end, uint64_t routeId)
+    : m_router(router)
+    , m_routingSettings(GetRoutingSettings(VehicleType::Car))
+    , m_poly(beg, end)
+    , m_routeId(routeId)
+  {
+  }
+
+  Route(std::string const & router, std::vector<m2::PointD> const & points, uint64_t routeId,
         std::string const & name = std::string());
 
   void Swap(Route & rhs);
@@ -317,6 +322,7 @@ public:
   traffic::SpeedGroup GetTraffic(size_t segmentIdx) const;
 
   void GetTurnsForTesting(std::vector<turns::TurnItem> & turns) const;
+  bool IsRouteId(uint64_t routeId) const { return routeId == m_routeId; }
 
 private:
   friend std::string DebugPrint(Route const & r);
@@ -347,5 +353,7 @@ private:
   SubrouteUid m_subrouteUid = kInvalidSubrouteId;
   size_t m_currentSubrouteIdx = 0;
   std::vector<SubrouteAttrs> m_subrouteAttrs;
+  // Route identifier. It's unique within single program session.
+  uint64_t m_routeId = 0;
 };
 } // namespace routing
diff --git a/routing/routing_benchmarks/helpers.cpp b/routing/routing_benchmarks/helpers.cpp
index 62c93d22ec..dc4fcaefe9 100644
--- a/routing/routing_benchmarks/helpers.cpp
+++ b/routing/routing_benchmarks/helpers.cpp
@@ -34,7 +34,7 @@ void TestRouter(routing::IRouter & router, m2::PointD const & startPos,
 {
   routing::RouterDelegate delegate;
   LOG(LINFO, ("Calculating routing ...", router.GetName()));
-  routing::Route route("");
+  routing::Route route("", 0 /* route id */);
   my::Timer timer;
   auto const resultCode = router.CalculateRoute(routing::Checkpoints(startPos, finalPos),
                                                 m2::PointD::Zero() /* startDirection */,
@@ -105,14 +105,14 @@ RoutingTest::RoutingTest(routing::IRoadGraph::Mode mode, set<string> const & nee
 void RoutingTest::TestRouters(m2::PointD const & startPos, m2::PointD const & finalPos)
 {
   // Find route by A*-bidirectional algorithm.
-  routing::Route routeFoundByAstarBidirectional("");
+  routing::Route routeFoundByAstarBidirectional("", 0 /* route id */);
   {
     auto router = CreateRouter("test-astar-bidirectional");
     TestRouter(*router, startPos, finalPos, routeFoundByAstarBidirectional);
   }
 
   // Find route by A* algorithm.
-  routing::Route routeFoundByAstar("");
+  routing::Route routeFoundByAstar("", 0 /* route id */);
   {
     auto router = CreateRouter("test-astar");
     TestRouter(*router, startPos, finalPos, routeFoundByAstar);
diff --git a/routing/routing_callbacks.hpp b/routing/routing_callbacks.hpp
index 1c31828282..2e9981954c 100644
--- a/routing/routing_callbacks.hpp
+++ b/routing/routing_callbacks.hpp
@@ -8,6 +8,7 @@
 #include <functional>
 #include <map>
 #include <string>
+#include <vector>
 
 namespace routing
 {
@@ -37,6 +38,7 @@ enum class RouterResultCode
   RouteNotFoundRedressRouteError = 15,
 };
 
+using AbsentCountryCallback = std::function<void(uint64_t, std::vector<std::string> const &)>;
 using CheckpointCallback = std::function<void(size_t passedCheckpointIdx)>;
 using ProgressCallback = std::function<void(float)>;
 // @TODO(bykoianko) ReadyCallback and ReadyCallbackOwnership callbacks should be gathered
diff --git a/routing/routing_integration_tests/routing_test_tools.cpp b/routing/routing_integration_tests/routing_test_tools.cpp
index 688115296a..592aa2eda2 100644
--- a/routing/routing_integration_tests/routing_test_tools.cpp
+++ b/routing/routing_integration_tests/routing_test_tools.cpp
@@ -170,7 +170,7 @@ namespace integration
                               m2::PointD const & finalPoint)
   {
     RouterDelegate delegate;
-    shared_ptr<Route> route(new Route("mapsme"));
+    shared_ptr<Route> route = make_shared<Route>("mapsme", 0 /* route id */);
     RouterResultCode result = routerComponents.GetRouter().CalculateRoute(
         Checkpoints(startPoint, finalPoint), startDirection, false /* adjust */, delegate, *route);
     ASSERT(route, ());
diff --git a/routing/routing_session.cpp b/routing/routing_session.cpp
index 281ae32610..afd237615b 100644
--- a/routing/routing_session.cpp
+++ b/routing/routing_session.cpp
@@ -62,7 +62,8 @@ void FormatDistance(double dist, string & value, string & suffix)
 
 RoutingSession::RoutingSession()
   : m_router(nullptr)
-  , m_route(make_shared<Route>(string()))
+    // @TODO |m_route| should be unique_prt<Route> and should be nullptr here.
+  , m_route(make_shared<Route>(string(), 0))
   , m_state(RoutingNotActive)
   , m_isFollowing(false)
   , m_lastWarnedSpeedCameraIndex(0)
@@ -160,7 +161,8 @@ void RoutingSession::RemoveRoute()
   m_moveAwayCounter = 0;
   m_turnNotificationsMgr.Reset();
 
-  m_route = make_shared<Route>(string());
+  // @TODO |m_route| should be unique_prt<Route> and should be nullptr here.
+  m_route = make_shared<Route>(string(), 0);
 }
 
 void RoutingSession::RebuildRouteOnTrafficUpdate()
diff --git a/routing/routing_session.hpp b/routing/routing_session.hpp
index 1434f50740..eab4cb8d56 100644
--- a/routing/routing_session.hpp
+++ b/routing/routing_session.hpp
@@ -208,6 +208,7 @@ private:
 
 private:
   unique_ptr<AsyncRouter> m_router;
+  // @TODO |m_route| should be unique_prt<Route> and may be nullptr.
   shared_ptr<Route> m_route;
   State m_state;
   bool m_isFollowing;
diff --git a/routing/routing_tests/async_router_test.cpp b/routing/routing_tests/async_router_test.cpp
index 0b360b76bc..dbcdac5bde 100644
--- a/routing/routing_tests/async_router_test.cpp
+++ b/routing/routing_tests/async_router_test.cpp
@@ -33,7 +33,8 @@ public:
                             bool adjustToPrevRoute, RouterDelegate const & delegate,
                             Route & route) override
   {
-    route = Route("dummy", checkpoints.GetPoints().cbegin(), checkpoints.GetPoints().cend());
+    route = Route("dummy", checkpoints.GetPoints().cbegin(), checkpoints.GetPoints().cend(),
+                  0 /* route id */);
 
     for (auto const & absent : m_absent)
       route.AddAbsentCountry(absent);
diff --git a/routing/routing_tests/route_tests.cpp b/routing/routing_tests/route_tests.cpp
index e9a7a1e745..6ee3d67656 100644
--- a/routing/routing_tests/route_tests.cpp
+++ b/routing/routing_tests/route_tests.cpp
@@ -77,7 +77,7 @@ location::GpsInfo GetGps(double x, double y)
 
 UNIT_TEST(AddAdsentCountryToRouteTest)
 {
-  Route route("TestRouter");
+  Route route("TestRouter", 0 /* route id */);
   route.AddAbsentCountry("A");
   route.AddAbsentCountry("A");
   route.AddAbsentCountry("B");
@@ -91,7 +91,7 @@ UNIT_TEST(AddAdsentCountryToRouteTest)
 
 UNIT_TEST(DistanceToCurrentTurnTest)
 {
-  Route route("TestRouter");
+  Route route("TestRouter", 0 /* route id */);
   vector<RouteSegment> routeSegments;
   GetTestRouteSegments(kTestGeometry, kTestTurns2, kTestNames2, kTestTimes2, routeSegments);
   route.SetGeometry(kTestGeometry.begin(), kTestGeometry.end());
@@ -129,7 +129,7 @@ UNIT_TEST(DistanceToCurrentTurnTest)
 
 UNIT_TEST(NextTurnTest)
 {
-  Route route("TestRouter");
+  Route route("TestRouter", 0 /* route id */);
   vector<RouteSegment> routeSegments;
   GetTestRouteSegments(kTestGeometry, kTestTurns2, kTestNames2, kTestTimes2, routeSegments);
   route.SetRouteSegments(routeSegments);
@@ -159,7 +159,7 @@ UNIT_TEST(NextTurnTest)
 
 UNIT_TEST(NextTurnsTest)
 {
-  Route route("TestRouter");
+  Route route("TestRouter", 0 /* route id */);
   route.SetGeometry(kTestGeometry.begin(), kTestGeometry.end());
   vector<RouteSegment> routeSegments;
   GetTestRouteSegments(kTestGeometry, kTestTurns2, kTestNames2, kTestTimes2, routeSegments);
@@ -227,7 +227,7 @@ UNIT_TEST(SelfIntersectedRouteMatchingTest)
       {{0.0001, 0.0}, {0.0001, 0.0002}, {0.0002, 0.0002}, {0.0002, 0.0001}, {0.0, 0.0001}});
   double constexpr kRoundingErrorMeters = 0.001;
 
-  Route route("TestRouter");
+  Route route("TestRouter", 0 /* route id */);
   route.SetGeometry(kRouteGeometry.begin(), kRouteGeometry.end());
   
   vector<RouteSegment> routeSegments;
@@ -278,7 +278,7 @@ UNIT_TEST(SelfIntersectedRouteMatchingTest)
 
 UNIT_TEST(RouteNameTest)
 {
-  Route route("TestRouter");
+  Route route("TestRouter", 0 /* route id */);
 
   route.SetGeometry(kTestGeometry.begin(), kTestGeometry.end());
   vector<RouteSegment> routeSegments;
diff --git a/routing/routing_tests/routing_session_test.cpp b/routing/routing_tests/routing_session_test.cpp
index 3c390c3e4c..0f5107eecb 100644
--- a/routing/routing_tests/routing_session_test.cpp
+++ b/routing/routing_tests/routing_session_test.cpp
@@ -97,7 +97,7 @@ UNIT_TEST(TestRouteBuilding)
   RoutingSession session;
   session.Init(nullptr, nullptr);
   vector<m2::PointD> routePoints = kTestRoute;
-  Route masterRoute("dummy", routePoints.begin(), routePoints.end());
+  Route masterRoute("dummy", routePoints.begin(), routePoints.end(), 0 /* route id */);
   size_t counter = 0;
   TimedSignal timedSignal;
   unique_ptr<DummyRouter> router =
@@ -118,7 +118,7 @@ UNIT_TEST(TestRouteRebuilding)
   RoutingSession session;
   session.Init(nullptr, nullptr);
   vector<m2::PointD> routePoints = kTestRoute;
-  Route masterRoute("dummy", routePoints.begin(), routePoints.end());
+  Route masterRoute("dummy", routePoints.begin(), routePoints.end(), 0 /* route id */);
   FillSubroutesInfo(masterRoute);
 
   size_t counter = 0;
@@ -176,7 +176,7 @@ UNIT_TEST(TestFollowRouteFlagPersistence)
   RoutingSession session;
   session.Init(nullptr, nullptr);
   vector<m2::PointD> routePoints = kTestRoute;
-  Route masterRoute("dummy", routePoints.begin(), routePoints.end());
+  Route masterRoute("dummy", routePoints.begin(), routePoints.end(), 0 /* route id */);
   FillSubroutesInfo(masterRoute);
 
   size_t counter = 0;
@@ -252,7 +252,7 @@ UNIT_TEST(TestFollowRoutePercentTest)
   RoutingSession session;
   session.Init(nullptr, nullptr);
   vector<m2::PointD> routePoints = kTestRoute;
-  Route masterRoute("dummy", routePoints.begin(), routePoints.end());
+  Route masterRoute("dummy", routePoints.begin(), routePoints.end(), 0 /* route id */);
   FillSubroutesInfo(masterRoute);
 
   size_t counter = 0;