diff --git a/configure.sh b/configure.sh
index 64ca1b4ccb..069b80d90d 100755
--- a/configure.sh
+++ b/configure.sh
@@ -104,6 +104,8 @@ else
 #define PARTNER4_BANNER_PLACEMENT_ID ""
 #define PARTNER5_NAME ""
 #define PARTNER5_BANNER_PLACEMENT_ID ""
+#define MAXIM_CLIENT_ID ""
+#define MAXIM_SERVER_TOKEN ""
 
 ' > "$PRIVATE_HEADER"
     echo 'ext {
diff --git a/partners_api/CMakeLists.txt b/partners_api/CMakeLists.txt
index d1171690ae..d1ee5226b2 100644
--- a/partners_api/CMakeLists.txt
+++ b/partners_api/CMakeLists.txt
@@ -19,6 +19,8 @@ set(
   google_ads.hpp
   locals_api.cpp
   locals_api.hpp
+  maxim_api.cpp
+  maxim_api.hpp
   mopub_ads.cpp
   mopub_ads.hpp
   opentable_api.cpp
diff --git a/partners_api/maxim_api.cpp b/partners_api/maxim_api.cpp
new file mode 100644
index 0000000000..536eccc2de
--- /dev/null
+++ b/partners_api/maxim_api.cpp
@@ -0,0 +1,151 @@
+#include "partners_api/maxim_api.hpp"
+
+#include "platform/http_client.hpp"
+#include "platform/platform.hpp"
+
+#include "geometry/latlon.hpp"
+
+#include "base/logging.hpp"
+
+#include "std/target_os.hpp"
+
+#include <iomanip>
+#include <limits>
+#include <sstream>
+
+#include "3party/jansson/myjansson.hpp"
+
+#include "private.h"
+
+namespace
+{
+double const kSecInMinute = 60.;
+
+bool RunSimpleHttpRequest(std::string const & url, std::string & result)
+{
+  platform::HttpClient request(url);
+  return request.RunHttpRequest(result);
+}
+}  // namespace
+
+namespace taxi
+{
+namespace maxim
+{
+std::string const kTaxiInfoUrl = "http://cabinet.taximaxim.ru/Services/Public.svc";
+
+bool RawApi::GetTaxiInfo(ms::LatLon const & from, ms::LatLon const & to, std::string & result,
+                         std::string const & baseUrl /* = kTaxiInfoUrl */)
+{
+  std::ostringstream url;
+  url << std::fixed << std::setprecision(6) << baseUrl
+      << "/CalculateByCoords?version=1.0&platform=WEB&RefOrgId="
+      << MAXIM_CLIENT_ID << "&access-token=" << MAXIM_SERVER_TOKEN
+      << "&startLatitude=" << from.lat << "&startLongitude=" << from.lon
+      << "&endLatitude=" << to.lat << "&endLongitude=" << to.lon;
+
+  return RunSimpleHttpRequest(url.str(), result);
+}
+
+/// Requests list of available products from Maxim.
+void Api::GetAvailableProducts(ms::LatLon const & from, ms::LatLon const & to,
+                               ProductsCallback const & successFn,
+                               ErrorProviderCallback const & errorFn)
+{
+  ASSERT(successFn, ());
+  ASSERT(errorFn, ());
+
+  // TODO(a): Add ErrorCode::FarDistance and provide this error code.
+  if (!IsDistanceSupported(from, to))
+  {
+    errorFn(ErrorCode::NoProducts);
+    return;
+  }
+
+  auto const baseUrl = m_baseUrl;
+
+  GetPlatform().RunTask(Platform::Thread::Network, [from, to, baseUrl, successFn, errorFn]()
+  {
+    std::string result;
+    if (!RawApi::GetTaxiInfo(from, to, result, baseUrl))
+    {
+      errorFn(ErrorCode::RemoteError);
+      return;
+    }
+
+    std::vector<Product> products;
+    try
+    {
+      MakeFromJson(result, products);
+    }
+    catch (my::Json::Exception const & e)
+    {
+      LOG(LERROR, (e.what(), result));
+      products.clear();
+    }
+
+    if (products.empty())
+      errorFn(ErrorCode::NoProducts);
+    else
+      successFn(products);
+
+  });
+}
+
+/// Returns link which allows you to launch the Maxim app.
+RideRequestLinks Api::GetRideRequestLinks(std::string const & productId, ms::LatLon const & from,
+                                          ms::LatLon const & to) const
+{
+  std::ostringstream orderLink;
+  std::ostringstream firebaseLink;
+
+  orderLink << "order?refOrgId=" << MAXIM_CLIENT_ID << "&startLatitude=" << from.lat
+            << "&startLongitude=" << from.lon << "&endLatitude=" << to.lat
+            << "&endLongitude=" << to.lon;
+
+#if defined(OMIM_OS_IPHONE)
+  firebaseLink << "https://qau86.app.goo.gl/?link=" << orderLink.str()
+               << "&ibi=com.taxsee.Taxsee&isi=579985456&ius=maximzakaz";
+#elif defined(OMIM_OS_ANDROID)
+  firebaseLink << "https://qau86.app.goo.gl/?link=" << orderLink.str() << "&apn=com.taxsee.taxsee";
+#endif
+
+  return {"maximzakaz://" + orderLink.str(), firebaseLink.str()};
+}
+
+void MakeFromJson(std::string const & src, std::vector<taxi::Product> & products)
+{
+  products.clear();
+
+  my::Json root(src.c_str());
+  if (!json_is_object(root.get()))
+    return;
+
+  bool success = false;
+  FromJSONObject(root.get(), "Success", success);
+
+  if (!success)
+    return;
+
+  auto const price = json_object_get(root.get(), "Price");
+  if (price == nullptr)
+    return;
+
+  double p = 0.0;
+  FromJSON(price, p);
+  if (p == 0.0)
+    return;
+
+  taxi::Product product;
+
+  FromJSONObject(root.get(), "PriceString", product.m_price);
+  FromJSONObject(root.get(), "CurrencyCode", product.m_currency);
+
+  double time = 0.0;
+  FromJSONObject(root.get(), "FeedTime", time);
+  product.m_time = strings::to_string(static_cast<int64_t>(time * kSecInMinute));
+
+  products.push_back(move(product));
+}
+}  // namespace maxim
+}  // namespace taxi
diff --git a/partners_api/maxim_api.hpp b/partners_api/maxim_api.hpp
new file mode 100644
index 0000000000..d525f11563
--- /dev/null
+++ b/partners_api/maxim_api.hpp
@@ -0,0 +1,43 @@
+#pragma once
+
+#include "partners_api/taxi_base.hpp"
+
+#include <string>
+
+namespace ms
+{
+class LatLon;
+}
+
+namespace taxi
+{
+namespace maxim
+{
+extern std::string const kTaxiInfoUrl;
+/// Maxim api wrapper is based on synchronous http requests.
+class RawApi
+{
+public:
+  static bool GetTaxiInfo(ms::LatLon const & from, ms::LatLon const & to, std::string & result,
+                          std::string const & url = kTaxiInfoUrl);
+};
+
+/// Class which is used for making products from http requests results.
+class Api : public ApiBase
+{
+public:
+  explicit Api(std::string const & baseUrl = kTaxiInfoUrl) : ApiBase(baseUrl) {}
+  // ApiBase overrides:
+  /// Requests list of available products from Maxim.
+  void GetAvailableProducts(ms::LatLon const & from, ms::LatLon const & to,
+                            ProductsCallback const & successFn,
+                            ErrorProviderCallback const & errorFn) override;
+
+  /// Returns link which allows you to launch the Maxim app.
+  RideRequestLinks GetRideRequestLinks(std::string const & productId, ms::LatLon const & from,
+                                       ms::LatLon const & to) const override;
+};
+
+void MakeFromJson(std::string const & src, std::vector<taxi::Product> & products);
+}  // namespace maxim
+}  // namespace taxi
diff --git a/partners_api/partners_api_tests/CMakeLists.txt b/partners_api/partners_api_tests/CMakeLists.txt
index 72d83548be..adc97a6073 100644
--- a/partners_api/partners_api_tests/CMakeLists.txt
+++ b/partners_api/partners_api_tests/CMakeLists.txt
@@ -8,6 +8,7 @@ set(
   booking_tests.cpp
   facebook_tests.cpp
   google_tests.cpp
+  maxim_tests.cpp
   mopub_tests.cpp
   rb_tests.cpp
   taxi_engine_tests.cpp
diff --git a/partners_api/partners_api_tests/maxim_tests.cpp b/partners_api/partners_api_tests/maxim_tests.cpp
new file mode 100644
index 0000000000..f1413558e8
--- /dev/null
+++ b/partners_api/partners_api_tests/maxim_tests.cpp
@@ -0,0 +1,102 @@
+#include "testing/testing.hpp"
+
+#include "partners_api/maxim_api.hpp"
+
+#include "geometry/latlon.hpp"
+
+#include "platform/platform.hpp"
+
+namespace
+{
+string const kTestResponse = R"(
+{
+  "ButtonText": null,
+  "Message": null,
+  "PaymentMethods": null,
+  "Prices": null,
+  "ShowFrom": false,
+  "Success": true,
+  "TypeId": 2,
+  "CurrencyCode": "RUB",
+  "FeedTime": 9,
+  "Price": 244,
+  "PriceString": "244.00 ₽"
+}
+)";
+
+using Runner = Platform::ThreadRunner;
+
+UNIT_TEST(Maxim_GetTaxiInfo)
+{
+  ms::LatLon const from(55.796918, 37.537859);
+  ms::LatLon const to(55.758213, 37.616093);
+  string result;
+
+  taxi::maxim::RawApi::GetTaxiInfo(from, to, result);
+
+  TEST(!result.empty(), ());
+}
+
+UNIT_TEST(Maxim_MakeFromJson)
+{
+  std::vector<taxi::Product> products;
+
+  taxi::maxim::MakeFromJson(kTestResponse, products);
+
+  TEST(!products.empty(), ());
+  TEST_EQUAL(products.size(), 1, ());
+  TEST_EQUAL(products[0].m_price, "244.00 ₽", ());
+  TEST_EQUAL(products[0].m_time, "540", ());
+  TEST_EQUAL(products[0].m_currency, "RUB", ());
+}
+
+UNIT_CLASS_TEST(Runner, Maxim_GetAvailableProducts)
+{
+  taxi::maxim::Api api("http://localhost:34568/partners");
+  ms::LatLon const from(55.796918, 37.537859);
+  ms::LatLon const to(55.758213, 37.616093);
+
+  std::vector<taxi::Product> resultProducts;
+
+  api.GetAvailableProducts(from, to,
+                           [&resultProducts](std::vector<taxi::Product> const & products) {
+                             resultProducts = products;
+                             testing::Notify();
+                           },
+                           [](taxi::ErrorCode const code) { TEST(false, (code)); });
+
+  testing::Wait();
+
+  TEST(!resultProducts.empty(), ());
+
+  taxi::ErrorCode errorCode = taxi::ErrorCode::RemoteError;
+  ms::LatLon const farPos(56.838197, 35.908507);
+  api.GetAvailableProducts(from, farPos,
+                           [](std::vector<taxi::Product> const & products) { TEST(false, ()); },
+                           [&errorCode](taxi::ErrorCode const code) {
+                             errorCode = code;
+                             testing::Notify();
+                           });
+
+  testing::Wait();
+
+  TEST_EQUAL(errorCode, taxi::ErrorCode::NoProducts, ());
+}
+
+UNIT_CLASS_TEST(Runner, Maxim_NoTaxi)
+{
+  taxi::maxim::Api api;
+  taxi::ErrorCode errorCode = taxi::ErrorCode::RemoteError;
+  ms::LatLon const noTaxiFrom(-66.876016, 53.241745);
+  ms::LatLon const noTaxiTo(-66.878029, 53.323667);
+  api.GetAvailableProducts(noTaxiFrom, noTaxiTo,
+                           [](std::vector<taxi::Product> const & products) { TEST(false, ()); },
+                           [&errorCode](taxi::ErrorCode const code) {
+                             errorCode = code;
+                             testing::Notify();
+                           });
+
+  testing::Wait();
+  TEST_EQUAL(errorCode, taxi::ErrorCode::NoProducts, ());
+}
+}  // namespace
diff --git a/partners_api/partners_api_tests/taxi_engine_tests.cpp b/partners_api/partners_api_tests/taxi_engine_tests.cpp
index 630de3601a..e868dbd1ab 100644
--- a/partners_api/partners_api_tests/taxi_engine_tests.cpp
+++ b/partners_api/partners_api_tests/taxi_engine_tests.cpp
@@ -2,6 +2,7 @@
 
 #include "partners_api/partners_api_tests/async_gui_thread.hpp"
 
+#include "partners_api/maxim_api.hpp"
 #include "partners_api/taxi_engine.hpp"
 #include "partners_api/uber_api.hpp"
 #include "partners_api/yandex_api.hpp"
@@ -34,6 +35,14 @@ public:
   std::string GetCityName(ms::LatLon const & latlon) override { return "Odessa"; }
 };
 
+class UkraineMariupolDelegate : public taxi::Delegate
+{
+public:
+  storage::TCountriesVec GetCountryIds(ms::LatLon const & latlon) override { return {"Ukraine"}; }
+
+  std::string GetCityName(ms::LatLon const & latlon) override { return "Mariupol"; }
+};
+
 class BulgariaSofiaDelegate : public taxi::Delegate
 {
 public:
@@ -100,6 +109,19 @@ std::vector<taxi::Product> GetYandexSynchronous(ms::LatLon const & from, ms::Lat
   return yandexProducts;
 }
 
+std::vector<taxi::Product> GetMaximSynchronous(ms::LatLon const & from, ms::LatLon const & to,
+                                               std::string const & url)
+{
+  std::string maximAnswer;
+  std::vector<taxi::Product> maximProducts;
+
+  TEST(taxi::maxim::RawApi::GetTaxiInfo(from, to, maximAnswer, url), ());
+
+  taxi::maxim::MakeFromJson(maximAnswer, maximProducts);
+
+  return maximProducts;
+}
+
 taxi::ProvidersContainer GetProvidersSynchronous(taxi::Engine const & engine,
                                                  ms::LatLon const & from, ms::LatLon const & to,
                                                  std::string const & url)
@@ -116,6 +138,8 @@ taxi::ProvidersContainer GetProvidersSynchronous(taxi::Engine const & engine,
     case taxi::Provider::Type::Yandex:
       providers.emplace_back(taxi::Provider::Type::Yandex, GetYandexSynchronous(from, to, url));
       break;
+    case taxi::Provider::Type::Maxim:
+      providers.emplace_back(taxi::Provider::Type::Maxim, GetMaximSynchronous(from, to, url));
     }
   }
 
@@ -206,8 +230,8 @@ UNIT_CLASS_TEST(AsyncGuiThread, TaxiEngine_ResultMaker)
     TEST(false, ("errorNotPossibleCallback", requestId, errors));
   };
 
-  // Try to image what products1 and products2 are lists of products for different taxi providers.
-  // Only product id is important for us, all other fields are empty.
+  // Try to image what products1, products2 and products3 are lists of products for different taxi
+  // providers. Only product id is important for us, all other fields are empty.
   std::vector<taxi::Product> products1 =
   {
     {"1", "", "", "", ""},
@@ -222,58 +246,90 @@ UNIT_CLASS_TEST(AsyncGuiThread, TaxiEngine_ResultMaker)
     {"6", "", "", "", ""},
   };
 
-  maker.Reset(reqId, 2, successCallback, errorNotPossibleCallback);
-  maker.ProcessProducts(reqId, taxi::Provider::Type::Uber, products1);
-  maker.ProcessProducts(reqId, taxi::Provider::Type::Yandex, products2);
-
-  TEST(providers.empty(), ());
-  TEST(errors.empty(), ());
+  std::vector<taxi::Product> products3 =
+  {
+    {"7", "", "", "", ""},
+  };
 
   maker.Reset(reqId, 3, successCallback, errorNotPossibleCallback);
   maker.ProcessProducts(reqId, taxi::Provider::Type::Uber, products1);
   maker.ProcessProducts(reqId, taxi::Provider::Type::Yandex, products2);
+  maker.ProcessProducts(reqId, taxi::Provider::Type::Maxim, products3);
+
+  TEST(providers.empty(), ());
+  TEST(errors.empty(), ());
+
+  maker.Reset(reqId, 4, successCallback, errorNotPossibleCallback);
+  maker.ProcessProducts(reqId, taxi::Provider::Type::Uber, products1);
+  maker.ProcessProducts(reqId, taxi::Provider::Type::Yandex, products2);
+  maker.ProcessProducts(reqId, taxi::Provider::Type::Maxim, products3);
   maker.DecrementRequestCount(reqId);
   maker.MakeResult(reqId);
 
   testing::Wait();
 
-  TEST_EQUAL(providers.size(), 2, ());
+  TEST_EQUAL(providers.size(), 3, ());
   TEST_EQUAL(providers[0].GetType(), taxi::Provider::Type::Uber, ());
   TEST_EQUAL(providers[1].GetType(), taxi::Provider::Type::Yandex, ());
+  TEST_EQUAL(providers[2].GetType(), taxi::Provider::Type::Maxim, ());
   TEST_EQUAL(providers[0][0].m_productId, "1", ());
   TEST_EQUAL(providers[0][1].m_productId, "2", ());
   TEST_EQUAL(providers[0][2].m_productId, "3", ());
   TEST_EQUAL(providers[1][0].m_productId, "4", ());
   TEST_EQUAL(providers[1][1].m_productId, "5", ());
   TEST_EQUAL(providers[1][2].m_productId, "6", ());
+  TEST_EQUAL(providers[2][0].m_productId, "7", ());
 
-  maker.Reset(reqId, 2, successCallback, errorNotPossibleCallback);
+  maker.Reset(reqId, 3, successCallback, errorNotPossibleCallback);
   maker.ProcessError(reqId, taxi::Provider::Type::Uber, taxi::ErrorCode::NoProducts);
   maker.ProcessProducts(reqId, taxi::Provider::Type::Yandex, products2);
+  maker.ProcessProducts(reqId, taxi::Provider::Type::Maxim, products3);
   maker.MakeResult(reqId);
 
   testing::Wait();
 
-  TEST_EQUAL(providers.size(), 1, ());
+  TEST_EQUAL(providers.size(), 2, ());
   TEST_EQUAL(providers[0].GetType(), taxi::Provider::Type::Yandex, ());
+  TEST_EQUAL(providers[1].GetType(), taxi::Provider::Type::Maxim, ());
   TEST_EQUAL(providers[0][0].m_productId, "4", ());
   TEST_EQUAL(providers[0][1].m_productId, "5", ());
   TEST_EQUAL(providers[0][2].m_productId, "6", ());
+  TEST_EQUAL(providers[1][0].m_productId, "7", ());
 
-  maker.Reset(reqId, 2, successNotPossibleCallback, errorCallback);
-  maker.ProcessError(reqId, taxi::Provider::Type::Uber, taxi::ErrorCode::NoProducts);
-  maker.ProcessError(reqId, taxi::Provider::Type::Yandex, taxi::ErrorCode::RemoteError);
+  maker.Reset(reqId, 3, successCallback, errorNotPossibleCallback);
+  maker.ProcessProducts(reqId, taxi::Provider::Type::Uber, products1);
+  maker.ProcessError(reqId, taxi::Provider::Type::Yandex, taxi::ErrorCode::NoProducts);
+  maker.ProcessProducts(reqId, taxi::Provider::Type::Maxim, products3);
   maker.MakeResult(reqId);
 
   testing::Wait();
 
-  TEST_EQUAL(errors.size(), 2, ());
+  TEST_EQUAL(providers.size(), 2, ());
+  TEST_EQUAL(providers[0].GetType(), taxi::Provider::Type::Uber, ());
+  TEST_EQUAL(providers[1].GetType(), taxi::Provider::Type::Maxim, ());
+  TEST_EQUAL(providers[0][0].m_productId, "1", ());
+  TEST_EQUAL(providers[0][1].m_productId, "2", ());
+  TEST_EQUAL(providers[0][2].m_productId, "3", ());
+  TEST_EQUAL(providers[1][0].m_productId, "7", ());
+
+  maker.Reset(reqId, 3, successNotPossibleCallback, errorCallback);
+  maker.ProcessError(reqId, taxi::Provider::Type::Uber, taxi::ErrorCode::NoProducts);
+  maker.ProcessError(reqId, taxi::Provider::Type::Yandex, taxi::ErrorCode::RemoteError);
+  maker.ProcessError(reqId, taxi::Provider::Type::Maxim, taxi::ErrorCode::NoProducts);
+  maker.MakeResult(reqId);
+
+  testing::Wait();
+
+  TEST_EQUAL(errors.size(), 3, ());
   TEST_EQUAL(errors[0].m_type, taxi::Provider::Type::Uber, ());
   TEST_EQUAL(errors[0].m_code, taxi::ErrorCode::NoProducts, ());
   TEST_EQUAL(errors[1].m_type, taxi::Provider::Type::Yandex, ());
   TEST_EQUAL(errors[1].m_code, taxi::ErrorCode::RemoteError, ());
+  TEST_EQUAL(errors[2].m_type, taxi::Provider::Type::Maxim, ());
+  TEST_EQUAL(errors[2].m_code, taxi::ErrorCode::NoProducts, ());
 
-  maker.Reset(reqId, 2, successCallback, errorNotPossibleCallback);
+  maker.Reset(reqId, 3, successCallback, errorNotPossibleCallback);
+  maker.DecrementRequestCount(reqId);
   maker.DecrementRequestCount(reqId);
   maker.DecrementRequestCount(reqId);
   maker.MakeResult(reqId);
@@ -316,8 +372,9 @@ UNIT_CLASS_TEST(AsyncGuiThread, TaxiEngine_Smoke)
     testing::StopEventLoop();
   };
 
-  taxi::Engine engine(
-      {{taxi::Provider::Type::Uber, kTesturl}, {taxi::Provider::Type::Yandex, kTesturl}});
+  taxi::Engine engine({{taxi::Provider::Type::Uber, kTesturl},
+                       {taxi::Provider::Type::Yandex, kTesturl},
+                       {taxi::Provider::Type::Maxim, kTesturl}});
 
   engine.SetDelegate(my::make_unique<BelarusMinskDelegate>());
 
@@ -374,10 +431,15 @@ UNIT_TEST(TaxiEngine_GetProvidersAtPos)
   TEST_EQUAL(providers.size(), 1, ());
   TEST_EQUAL(providers[0], taxi::Provider::Type::Yandex, ());
 
+  engine.SetDelegate(my::make_unique<UkraineMariupolDelegate>());
+  providers = engine.GetProvidersAtPos(latlon);
+  TEST_EQUAL(providers.size(), 1, ());
+  TEST_EQUAL(providers[0], taxi::Provider::Type::Maxim, ());
+
   engine.SetDelegate(my::make_unique<BulgariaSofiaDelegate>());
   providers = engine.GetProvidersAtPos(latlon);
   TEST_EQUAL(providers.size(), 1, ());
-  TEST_EQUAL(providers[0], taxi::Provider::Type::Uber, ());
+  TEST_EQUAL(providers[0], taxi::Provider::Type::Maxim, ());
 
   engine.SetDelegate(my::make_unique<UsaDelegate>());
   providers = engine.GetProvidersAtPos(latlon);
diff --git a/partners_api/taxi_engine.cpp b/partners_api/taxi_engine.cpp
index 500384186f..a2b90748cc 100644
--- a/partners_api/taxi_engine.cpp
+++ b/partners_api/taxi_engine.cpp
@@ -1,4 +1,5 @@
 #include "partners_api/taxi_engine.hpp"
+#include "partners_api/maxim_api.hpp"
 #include "partners_api/taxi_places.hpp"
 #include "partners_api/uber_api.hpp"
 #include "partners_api/yandex_api.hpp"
@@ -115,6 +116,7 @@ Engine::Engine(std::vector<ProviderUrl> urls /* = {} */)
 {
   AddApi<yandex::Api>(urls, Provider::Type::Yandex, places::kYandexEnabledPlaces, {{}});
   AddApi<uber::Api>(urls, Provider::Type::Uber, {{}}, places::kUberDisabledPlaces);
+  AddApi<maxim::Api>(urls, Provider::Type::Maxim, places::kMaximEnabledPlaces, {{}});
 }
 
 void Engine::SetDelegate(std::unique_ptr<Delegate> delegate) { m_delegate = std::move(delegate); }
diff --git a/partners_api/taxi_places.hpp b/partners_api/taxi_places.hpp
index c3fd8e630b..3f625404cf 100644
--- a/partners_api/taxi_places.hpp
+++ b/partners_api/taxi_places.hpp
@@ -7,13 +7,21 @@ namespace taxi
 namespace places
 {
 // Places which are enabled for yandex taxi and in the same time are disabled for uber taxi.
-Countries const kUberDisabledPlaces = {{{"Armenia", {}},
-                                        {"Belarus", {}},
-                                        {"Georgia Region", {}},
-                                        {"Kazakhstan", {}},
-                                        {"Russian Federation", {}},
-                                        {"Ukraine", {}},
-                                        {"Moldova", {}}}};
+Countries const kUberDisabledPlaces = {
+    {{"Armenia", {}},
+     {"Azerbaijan Region", {"Baku"}},
+     {"Belarus", {}},
+     {"Bulgaria", {"Varna", "Plovdiv", "Sofia"}},
+     {"Georgia Region", {}},
+     {"Kazakhstan", {}},
+     {"Russian Federation", {}},
+     {"Ukraine", {}},
+     {"Moldova", {}},
+     {"Iran",
+      {"`Abbas",  "Ardabil",     "Ahvaz",   "Bandar", "Borujerd", "Qods",   "Gorgan", "Dezful",
+       "Zahedan", "Eslamshahr",  "Isfahan", "Qazvin", "Kashan",   "Karaj",  "Kerman", "Kermanshah",
+       "Qom",     "Malard",      "Mashhad", "Rasht",  "Sari",     "Tabriz", "Tehran", "Urmia",
+       "Hamedan", "Khorramabad", "Shiraz",  "Arak",   "Yazd"}}}};
 
 Countries const kYandexEnabledPlaces = {
     {{"Armenia", {"Vanadzor", "Gyumri", "Yerevan"}},
@@ -159,5 +167,20 @@ Countries const kYandexEnabledPlaces = {
        "Elektrostal",
        "Elektrougli",
        "Yaroslavl"}}}};
+
+Countries const kMaximEnabledPlaces = {
+    {{"Azerbaijan Region", {"Baku"}},
+     {"Belarus", {"Baranovichi", "Brest", "Vitebsk", "Mahilyow"}},
+     {"Bulgaria", {"Varna", "Plovdiv", "Sofia"}},
+     {"Georgia Region", {"Batumi", "Gori", "Zugdidi", "Kutaisi", "Poti"}},
+     {"Kazakhstan",
+      {"Aktobe", "Almaty", "Astana", "Karaganda", "Kokshetau", "Kostanay", "Petropavl", "Semey",
+       "Temirtau", "Oral", "Oskemen"}},
+     {"Ukraine", {"Kremenchuk", "Mariupol", "Poltava", "Sumy", "Kharkiv", "Cherkasy", "Chernihiv"}},
+     {"Iran",
+      {"`Abbas",  "Ardabil",     "Ahvaz",   "Bandar", "Borujerd", "Qods",   "Gorgan", "Dezful",
+       "Zahedan", "Eslamshahr",  "Isfahan", "Qazvin", "Kashan",   "Karaj",  "Kerman", "Kermanshah",
+       "Qom",     "Malard",      "Mashhad", "Rasht",  "Sari",     "Tabriz", "Tehran", "Urmia",
+       "Hamedan", "Khorramabad", "Shiraz",  "Arak",   "Yazd"}}}};
 }  // namespace places
 }  // namespace taxi
diff --git a/partners_api/taxi_provider.hpp b/partners_api/taxi_provider.hpp
index b3a3194b8d..62a8697a1b 100644
--- a/partners_api/taxi_provider.hpp
+++ b/partners_api/taxi_provider.hpp
@@ -22,7 +22,8 @@ public:
   enum Type
   {
     Uber,
-    Yandex
+    Yandex,
+    Maxim
   };
 
   using Iter = std::vector<Product>::iterator;
@@ -77,6 +78,7 @@ inline std::string DebugPrint(Provider::Type type)
   {
   case Provider::Type::Uber: return "Uber";
   case Provider::Type::Yandex: return "Yandex";
+  case Provider::Type::Maxim: return "Maxim";
   }
 }
 
diff --git a/partners_api/yandex_api.cpp b/partners_api/yandex_api.cpp
index f5794129af..1faced3f7e 100644
--- a/partners_api/yandex_api.cpp
+++ b/partners_api/yandex_api.cpp
@@ -55,8 +55,6 @@ namespace yandex
 {
 std::string const kTaxiInfoUrl = "https://taxi-routeinfo.taxi.yandex.net";
 
-Countries const kEnabledCountries = {{{}}};
-
 bool RawApi::GetTaxiInfo(ms::LatLon const & from, ms::LatLon const & to, std::string & result,
                          std::string const & baseUrl /* = kTaxiInfoUrl */)
 {
diff --git a/tools/python/ResponseProvider.py b/tools/python/ResponseProvider.py
index 681af67c0f..a1e8c50418 100644
--- a/tools/python/ResponseProvider.py
+++ b/tools/python/ResponseProvider.py
@@ -146,6 +146,7 @@ class ResponseProvider:
                 "/booking/min_price/hotelAvailability": self.partners_hotel_availability,
                 "/partners/taxi_info": self.partners_yandex_taxi_info,
                 "/partners/get-offers-in-bbox/": self.partners_rent_nearby,
+                "/partners/CalculateByCoords": self.partners_calculate_by_coords,
             }[url]()
         except:
             return self.test_404()
@@ -233,6 +234,9 @@ class ResponseProvider:
     def partners_rent_nearby(self):
         return Payload(jsons.PARTNERS_RENT_NEARBY)
 
+    def partners_calculate_by_coords(self):
+        return Payload(jsons.PARTNERS_CALCULATE_BY_COORDS)
+
     def kill(self):
         logging.debug("Kill called in ResponseProvider")
         self.delegate.kill()
diff --git a/tools/python/jsons.py b/tools/python/jsons.py
index 03040fc966..0637d77874 100644
--- a/tools/python/jsons.py
+++ b/tools/python/jsons.py
@@ -437,3 +437,19 @@ PARTNERS_RENT_NEARBY = """
   ]
 }
 """
+
+PARTNERS_CALCULATE_BY_COORDS = """
+{
+  "ButtonText": null,
+  "Message": null,
+  "PaymentMethods": null,
+  "Prices": null,
+  "ShowFrom": false,
+  "Success": true,
+  "TypeId": 2,
+  "CurrencyCode": "RUB",
+  "FeedTime": 9,
+  "Price": 244,
+  "PriceString": "244.00 ₽"
+}
+"""