diff --git a/backend/src/plugins/action/action_service_impl.h b/backend/src/plugins/action/action_service_impl.h
index 28835d3135..039dbde92b 100644
--- a/backend/src/plugins/action/action_service_impl.h
+++ b/backend/src/plugins/action/action_service_impl.h
@@ -198,6 +198,49 @@ class ActionServiceImpl final : public rpc::action::ActionService::Service {
         return grpc::Status::OK;
     }
 
+    grpc::Status
+    GetReturnToLaunchAltitude(grpc::ServerContext * /* context */,
+                              const rpc::action::GetReturnToLaunchAltitudeRequest * /* request */,
+                              rpc::action::GetReturnToLaunchAltitudeResponse *response) override
+    {
+        if (response != nullptr) {
+            auto result_pair = _action.get_return_to_launch_return_altitude();
+
+            auto *rpc_action_result = new rpc::action::ActionResult();
+            rpc_action_result->set_result(
+                static_cast<rpc::action::ActionResult::Result>(result_pair.first));
+            rpc_action_result->set_result_str(action_result_str(result_pair.first));
+
+            response->set_allocated_action_result(rpc_action_result);
+            response->set_relative_altitude_m(result_pair.second);
+        }
+
+        return grpc::Status::OK;
+    }
+
+    grpc::Status
+    SetReturnToLaunchAltitude(grpc::ServerContext * /* context */,
+                              const rpc::action::SetReturnToLaunchAltitudeRequest *request,
+                              rpc::action::SetReturnToLaunchAltitudeResponse *response) override
+    {
+        if (request != nullptr) {
+            const auto requested_altitude = request->relative_altitude_m();
+            const auto action_result =
+                _action.set_return_to_launch_return_altitude(requested_altitude);
+
+            if (response != nullptr) {
+                auto *rpc_action_result = new rpc::action::ActionResult();
+                rpc_action_result->set_result(
+                    static_cast<rpc::action::ActionResult::Result>(action_result));
+                rpc_action_result->set_result_str(action_result_str(action_result));
+
+                response->set_allocated_action_result(rpc_action_result);
+            }
+        }
+
+        return grpc::Status::OK;
+    }
+
 private:
     Action &_action;
 };
diff --git a/backend/test/action_service_impl_test.cpp b/backend/test/action_service_impl_test.cpp
index 8db96a8375..a70c8465cd 100644
--- a/backend/test/action_service_impl_test.cpp
+++ b/backend/test/action_service_impl_test.cpp
@@ -32,6 +32,10 @@ std::string
 transitionToFWAndGetTranslatedResult(const dronecode_sdk::ActionResult transition_to_fw_result);
 std::string
 transitionToMCAndGetTranslatedResult(const dronecode_sdk::ActionResult transition_to_fw_result);
+std::string
+getReturnToLaunchAltitudeAndGetTranslatedResult(const dronecode_sdk::ActionResult action_result);
+std::string
+setReturnToLaunchAltitudeAndGetTranslatedResult(const dronecode_sdk::ActionResult action_result);
 
 class ActionServiceImplTest : public ::testing::TestWithParam<InputPair> {};
 
@@ -388,6 +392,109 @@ TEST_F(ActionServiceImplTest, setMaxSpeedSetsRightValue)
     actionService.SetMaximumSpeed(nullptr, &request, nullptr);
 }
 
+TEST_P(ActionServiceImplTest, getReturnToLaunchAltitudeResultIsTranslatedCorrectly)
+{
+    const auto rpc_result = getReturnToLaunchAltitudeAndGetTranslatedResult(GetParam().second);
+    EXPECT_EQ(rpc_result, GetParam().first);
+}
+
+std::string
+getReturnToLaunchAltitudeAndGetTranslatedResult(const dronecode_sdk::ActionResult action_result)
+{
+    MockAction action;
+    const auto return_pair = std::make_pair<>(action_result, ARBITRARY_ALTITUDE);
+    ON_CALL(action, get_return_to_launch_return_altitude()).WillByDefault(Return(return_pair));
+    ActionServiceImpl actionService(action);
+    dronecode_sdk::rpc::action::GetReturnToLaunchAltitudeResponse response;
+
+    actionService.GetReturnToLaunchAltitude(nullptr, nullptr, &response);
+
+    return ActionResult::Result_Name(response.action_result().result());
+}
+
+TEST_F(ActionServiceImplTest, getReturnToLaunchAltitudeCallsGetter)
+{
+    MockAction action;
+    ActionServiceImpl actionService(action);
+    EXPECT_CALL(action, get_return_to_launch_return_altitude()).Times(1);
+    dronecode_sdk::rpc::action::GetReturnToLaunchAltitudeResponse response;
+
+    actionService.GetReturnToLaunchAltitude(nullptr, nullptr, &response);
+}
+
+TEST_P(ActionServiceImplTest, getsCorrectReturnToLaunchAltitude)
+{
+    MockAction action;
+    ActionServiceImpl actionService(action);
+    const auto expected_pair = std::make_pair<>(GetParam().second, ARBITRARY_ALTITUDE);
+    ON_CALL(action, get_return_to_launch_return_altitude()).WillByDefault(Return(expected_pair));
+    dronecode_sdk::rpc::action::GetReturnToLaunchAltitudeResponse response;
+
+    actionService.GetReturnToLaunchAltitude(nullptr, nullptr, &response);
+
+    EXPECT_EQ(GetParam().first, ActionResult::Result_Name(response.action_result().result()));
+    EXPECT_EQ(expected_pair.second, response.relative_altitude_m());
+}
+
+TEST_F(ActionServiceImplTest, getReturnToLaunchAltitudeDoesNotCrashWithNullResponse)
+{
+    MockAction action;
+    ActionServiceImpl actionService(action);
+
+    actionService.GetReturnToLaunchAltitude(nullptr, nullptr, nullptr);
+}
+
+TEST_P(ActionServiceImplTest, setReturnToLaunchAltitudeResultIsTranslatedCorrectly)
+{
+    const auto rpc_result = setReturnToLaunchAltitudeAndGetTranslatedResult(GetParam().second);
+    EXPECT_EQ(rpc_result, GetParam().first);
+}
+
+std::string
+setReturnToLaunchAltitudeAndGetTranslatedResult(const dronecode_sdk::ActionResult action_result)
+{
+    MockAction action;
+    ON_CALL(action, set_return_to_launch_return_altitude(_)).WillByDefault(Return(action_result));
+    ActionServiceImpl actionService(action);
+    dronecode_sdk::rpc::action::SetReturnToLaunchAltitudeRequest request;
+    request.set_relative_altitude_m(ARBITRARY_ALTITUDE);
+    dronecode_sdk::rpc::action::SetReturnToLaunchAltitudeResponse response;
+
+    actionService.SetReturnToLaunchAltitude(nullptr, &request, &response);
+
+    return ActionResult::Result_Name(response.action_result().result());
+}
+
+TEST_F(ActionServiceImplTest, setReturnToLaunchAltitudeDoesNotCrashWithNullParams)
+{
+    MockAction action;
+    ActionServiceImpl actionService(action);
+
+    actionService.SetReturnToLaunchAltitude(nullptr, nullptr, nullptr);
+}
+
+TEST_F(ActionServiceImplTest, setReturnToLaunchAltitudeCallsSetter)
+{
+    MockAction action;
+    ActionServiceImpl actionService(action);
+    EXPECT_CALL(action, set_return_to_launch_return_altitude(_)).Times(1);
+    dronecode_sdk::rpc::action::SetReturnToLaunchAltitudeRequest request;
+
+    actionService.SetReturnToLaunchAltitude(nullptr, &request, nullptr);
+}
+
+TEST_P(ActionServiceImplTest, setReturnToLaunchAltitudeSetsRightValue)
+{
+    MockAction action;
+    ActionServiceImpl actionService(action);
+    float expected_altitude = ARBITRARY_ALTITUDE;
+    EXPECT_CALL(action, set_return_to_launch_return_altitude(expected_altitude)).Times(1);
+    dronecode_sdk::rpc::action::SetReturnToLaunchAltitudeRequest request;
+    request.set_relative_altitude_m(expected_altitude);
+
+    actionService.SetReturnToLaunchAltitude(nullptr, &request, nullptr);
+}
+
 INSTANTIATE_TEST_CASE_P(ActionResultCorrespondences,
                         ActionServiceImplTest,
                         ::testing::ValuesIn(generateInputPairs()));
diff --git a/plugins/action/mocks/action_mock.h b/plugins/action/mocks/action_mock.h
index fd71501e85..a5ec81bbbe 100644
--- a/plugins/action/mocks/action_mock.h
+++ b/plugins/action/mocks/action_mock.h
@@ -19,6 +19,8 @@ class MockAction {
     MOCK_CONST_METHOD1(set_takeoff_altitude, ActionResult(float));
     MOCK_CONST_METHOD0(get_max_speed, std::pair<ActionResult, float>());
     MOCK_CONST_METHOD1(set_max_speed, ActionResult(float));
+    MOCK_CONST_METHOD0(get_return_to_launch_return_altitude, std::pair<ActionResult, float>());
+    MOCK_CONST_METHOD1(set_return_to_launch_return_altitude, ActionResult(float));
 };
 
 } // namespace testing