diff --git a/src/components/data-external-tool/ExternalToolApi.composable.ts b/src/components/data-external-tool/ExternalToolApi.composable.ts
new file mode 100644
index 0000000000..9848ede046
--- /dev/null
+++ b/src/components/data-external-tool/ExternalToolApi.composable.ts
@@ -0,0 +1,32 @@
+import {
+	ToolApiFactory,
+	ToolApiInterface,
+	ToolLaunchRequestResponse,
+} from "@/serverApi/v3";
+import { ToolLaunchRequest } from "@/store/external-tool";
+import { ExternalToolMapper } from "@/store/external-tool/mapper";
+import { $axios } from "@/utils/api";
+import { AxiosResponse } from "axios";
+
+export const useExternalToolApi = () => {
+	const toolApi: ToolApiInterface = ToolApiFactory(undefined, "/v3", $axios);
+
+	const fetchLaunchDataCall = async (
+		contextExternalToolId: string
+	): Promise<ToolLaunchRequest> => {
+		const response: AxiosResponse<ToolLaunchRequestResponse> =
+			await toolApi.toolLaunchControllerGetToolLaunchRequest(
+				contextExternalToolId
+			);
+
+		const mapped: ToolLaunchRequest = ExternalToolMapper.mapToToolLaunchRequest(
+			response.data
+		);
+
+		return mapped;
+	};
+
+	return {
+		fetchLaunchDataCall,
+	};
+};
diff --git a/src/components/data-external-tool/ExternalToolApi.composable.unit.ts b/src/components/data-external-tool/ExternalToolApi.composable.unit.ts
new file mode 100644
index 0000000000..b025e3da78
--- /dev/null
+++ b/src/components/data-external-tool/ExternalToolApi.composable.unit.ts
@@ -0,0 +1,65 @@
+import * as serverApi from "@/serverApi/v3/api";
+import { ToolLaunchRequestResponse } from "@/serverApi/v3/api";
+import {
+	ToolLaunchRequest,
+	ToolLaunchRequestMethodEnum,
+} from "@/store/external-tool";
+import {
+	mockApiResponse,
+	toolLaunchRequestResponseFactory,
+} from "@@/tests/test-utils";
+import { createMock, DeepMocked } from "@golevelup/ts-jest";
+import { useExternalToolApi } from "./ExternalToolApi.composable";
+
+describe("ExternalToolApi.composable", () => {
+	let toolApi: DeepMocked<serverApi.ToolApiInterface>;
+
+	beforeEach(() => {
+		toolApi = createMock<serverApi.ToolApiInterface>();
+
+		jest.spyOn(serverApi, "ToolApiFactory").mockReturnValue(toolApi);
+	});
+
+	afterEach(() => {
+		jest.clearAllMocks();
+	});
+
+	describe("fetchLaunchDataCall", () => {
+		const setup = () => {
+			const launchRequest: ToolLaunchRequestResponse =
+				toolLaunchRequestResponseFactory.build();
+
+			toolApi.toolLaunchControllerGetToolLaunchRequest.mockResolvedValue(
+				mockApiResponse({ data: launchRequest })
+			);
+
+			return {
+				launchRequest,
+			};
+		};
+
+		it("should call the api for a tool launch request", async () => {
+			setup();
+
+			await useExternalToolApi().fetchLaunchDataCall("contextExternalToolId");
+
+			expect(
+				toolApi.toolLaunchControllerGetToolLaunchRequest
+			).toHaveBeenCalledWith("contextExternalToolId");
+		});
+
+		it("should return launch request data", async () => {
+			const { launchRequest } = setup();
+
+			const result: ToolLaunchRequest =
+				await useExternalToolApi().fetchLaunchDataCall("contextExternalToolId");
+
+			expect(result).toEqual<ToolLaunchRequest>({
+				url: launchRequest.url,
+				payload: launchRequest.payload,
+				method: ToolLaunchRequestMethodEnum.Get,
+				openNewTab: launchRequest.openNewTab,
+			});
+		});
+	});
+});
diff --git a/src/components/data-external-tool/ExternalToolElementDisplayState.composable.unit.ts b/src/components/data-external-tool/ExternalToolElementDisplayState.composable.unit.ts
index 1fe5ff37ed..1a9b629b0d 100644
--- a/src/components/data-external-tool/ExternalToolElementDisplayState.composable.unit.ts
+++ b/src/components/data-external-tool/ExternalToolElementDisplayState.composable.unit.ts
@@ -2,10 +2,10 @@ import { ExternalToolDisplayData } from "@/store/external-tool";
 import { externalToolDisplayDataFactory } from "@@/tests/test-utils";
 import { createMock, DeepMocked } from "@golevelup/ts-jest";
 import { useErrorHandler } from "../error-handling/ErrorHandler.composable";
+import { useContextExternalToolApi } from "./ContextExternalToolApi.composable";
 import { useExternalToolElementDisplayState } from "./ExternalToolElementDisplayState.composable";
-import { useContextExternalToolApi } from "./index";
 
-jest.mock("@data-external-tool");
+jest.mock("@data-external-tool/ContextExternalToolApi.composable");
 jest.mock("@/components/error-handling/ErrorHandler.composable");
 
 describe("ExternalToolElementDisplayState.composable", () => {
diff --git a/src/components/data-external-tool/ExternalToolLaunchState.composable.ts b/src/components/data-external-tool/ExternalToolLaunchState.composable.ts
new file mode 100644
index 0000000000..d4b8b61673
--- /dev/null
+++ b/src/components/data-external-tool/ExternalToolLaunchState.composable.ts
@@ -0,0 +1,101 @@
+import {
+	ToolLaunchRequest,
+	ToolLaunchRequestMethodEnum,
+} from "@/store/external-tool";
+import { BusinessError } from "@/store/types/commons";
+import { HttpStatusCode } from "@/store/types/http-status-code.enum";
+import { mapAxiosErrorToResponseError } from "@/utils/api";
+import { ref, Ref } from "vue";
+import { useExternalToolApi } from "./ExternalToolApi.composable";
+
+export const useExternalToolLaunchState = () => {
+	const { fetchLaunchDataCall } = useExternalToolApi();
+
+	const isLoading: Ref<boolean> = ref(false);
+	const error: Ref<BusinessError | undefined> = ref();
+	const toolLaunchRequest: Ref<ToolLaunchRequest | undefined> = ref();
+
+	const fetchLaunchRequest = async (
+		contextExternalToolId: string
+	): Promise<void> => {
+		isLoading.value = true;
+		error.value = undefined;
+
+		try {
+			toolLaunchRequest.value = await fetchLaunchDataCall(
+				contextExternalToolId
+			);
+		} catch (axiosError: unknown) {
+			const apiError = mapAxiosErrorToResponseError(axiosError);
+
+			error.value = {
+				error: apiError,
+				message: apiError.message,
+				statusCode: apiError.code,
+			};
+		}
+
+		isLoading.value = false;
+	};
+
+	const launchTool = () => {
+		if (!toolLaunchRequest.value) {
+			return;
+		}
+
+		switch (toolLaunchRequest.value.method) {
+			case ToolLaunchRequestMethodEnum.Get:
+				handleGetLaunchRequest(toolLaunchRequest.value);
+				break;
+			case ToolLaunchRequestMethodEnum.Post:
+				handlePostLaunchRequest(toolLaunchRequest.value);
+				break;
+			default:
+				error.value = {
+					message: "Unknown launch method",
+					statusCode: HttpStatusCode.UnprocessableEntity,
+				};
+				break;
+		}
+	};
+
+	const handleGetLaunchRequest = (toolLaunch: ToolLaunchRequest) => {
+		if (toolLaunch.openNewTab) {
+			window.open(toolLaunch.url, "_blank");
+			return;
+		}
+		window.location.href = toolLaunch.url;
+	};
+
+	const handlePostLaunchRequest = (toolLaunch: ToolLaunchRequest) => {
+		const form: HTMLFormElement = document.createElement("form");
+		form.method = "POST";
+		form.action = toolLaunch.url;
+		form.target = toolLaunch.openNewTab ? "_blank" : "_self";
+		form.id = "launch-form";
+
+		const payload = JSON.parse(toolLaunch.payload || "{}");
+
+		for (const key in payload) {
+			if (Object.prototype.hasOwnProperty.call(payload, key)) {
+				const hiddenField = document.createElement("input");
+				hiddenField.type = "hidden";
+				hiddenField.name = key;
+				hiddenField.value = payload[key];
+
+				form.appendChild(hiddenField);
+			}
+		}
+
+		document.body.appendChild(form);
+		form.submit();
+	};
+
+	return {
+		toolLaunchRequest,
+		error,
+		isLoading,
+		fetchLaunchRequest,
+		launchTool,
+	};
+};
diff --git a/src/components/data-external-tool/ExternalToolLaunchState.composable.unit.ts b/src/components/data-external-tool/ExternalToolLaunchState.composable.unit.ts
new file mode 100644
index 0000000000..053a45bb3d
--- /dev/null
+++ b/src/components/data-external-tool/ExternalToolLaunchState.composable.unit.ts
@@ -0,0 +1,270 @@
+import {
+	ToolLaunchRequest,
+	ToolLaunchRequestMethodEnum,
+} from "@/store/external-tool";
+import { BusinessError } from "@/store/types/commons";
+import { HttpStatusCode } from "@/store/types/http-status-code.enum";
+import { toolLaunchRequestFactory } from "@@/tests/test-utils/factory/toolLaunchRequestFactory";
+import { createMock, DeepMocked } from "@golevelup/ts-jest";
+import { axiosErrorFactory } from "../../../tests/test-utils";
+import { mapAxiosErrorToResponseError } from "../../utils/api";
+import { useExternalToolApi } from "./ExternalToolApi.composable";
+import { useExternalToolLaunchState } from "./ExternalToolLaunchState.composable";
+
+jest.mock("@data-external-tool/ExternalToolApi.composable");
+
+describe("ExternalToolLaunchState.composable", () => {
+	let useExternalToolApiMock: DeepMocked<ReturnType<typeof useExternalToolApi>>;
+
+	beforeEach(() => {
+		useExternalToolApiMock =
+			createMock<ReturnType<typeof useExternalToolApi>>();
+
+		jest.mocked(useExternalToolApi).mockReturnValue(useExternalToolApiMock);
+	});
+
+	afterEach(() => {
+		jest.clearAllMocks();
+
+		window.location.href = "";
+	});
+
+	describe("fetchLaunchRequest", () => {
+		describe("when fetching a tool", () => {
+			const setup = () => {
+				const response = toolLaunchRequestFactory.build();
+
+				useExternalToolApiMock.fetchLaunchDataCall.mockResolvedValue(response);
+
+				return {
+					...useExternalToolLaunchState(),
+					response,
+				};
+			};
+
+			it("should load the launch data from the store", async () => {
+				const { fetchLaunchRequest } = setup();
+
+				await fetchLaunchRequest("contextExternalToolId");
+
+				expect(useExternalToolApiMock.fetchLaunchDataCall).toHaveBeenCalledWith(
+					"contextExternalToolId"
+				);
+			});
+
+			it("should save the loaded request in a state", async () => {
+				const { fetchLaunchRequest, toolLaunchRequest, response } = setup();
+
+				await fetchLaunchRequest("contextExternalToolId");
+
+				expect(toolLaunchRequest.value).toEqual<ToolLaunchRequest>({
+					method: ToolLaunchRequestMethodEnum.Get,
+					url: response.url,
+					payload: response.payload,
+					openNewTab: response.openNewTab,
+				});
+			});
+
+			it("should not have an error", async () => {
+				const { fetchLaunchRequest, error } = setup();
+
+				await fetchLaunchRequest("contextExternalToolId");
+
+				expect(error.value).toBeUndefined();
+			});
+		});
+
+		describe("when an error occurs", () => {
+			const setup = () => {
+				const axiosError = axiosErrorFactory.build();
+				const apiError = mapAxiosErrorToResponseError(axiosError);
+
+				useExternalToolApiMock.fetchLaunchDataCall.mockRejectedValue(
+					axiosError
+				);
+
+				return {
+					...useExternalToolLaunchState(),
+					apiError,
+				};
+			};
+
+			it("should load the launch data from the store", async () => {
+				const { fetchLaunchRequest, error, apiError } = setup();
+
+				await fetchLaunchRequest("contextExternalToolId");
+
+				expect(error.value).toEqual<BusinessError>({
+					message: apiError.message,
+					statusCode: apiError.code,
+					error: apiError,
+				});
+			});
+		});
+	});
+
+	describe("launchTool", () => {
+		describe("when launching without loading", () => {
+			it("should do nothing", () => {
+				const { launchTool } = useExternalToolLaunchState();
+
+				launchTool();
+
+				expect(window.location.href).toEqual("");
+			});
+		});
+
+		describe("when launching a tool with get method", () => {
+			describe("when opening in the same tab", () => {
+				const setup = () => {
+					const launchRequest = toolLaunchRequestFactory.build({
+						method: ToolLaunchRequestMethodEnum.Get,
+						openNewTab: false,
+					});
+
+					const composable = useExternalToolLaunchState();
+					composable.toolLaunchRequest.value = launchRequest;
+
+					return {
+						...composable,
+						launchRequest,
+					};
+				};
+
+				it("should set the location", () => {
+					const { launchRequest, launchTool } = setup();
+
+					launchTool();
+
+					expect(window.location.href).toEqual(launchRequest.url);
+				});
+			});
+
+			describe("when opening in a new tab", () => {
+				const setup = () => {
+					jest.spyOn(window, "open");
+					const launchRequest = toolLaunchRequestFactory.build({
+						method: ToolLaunchRequestMethodEnum.Get,
+						openNewTab: true,
+					});
+
+					const composable = useExternalToolLaunchState();
+					composable.toolLaunchRequest.value = launchRequest;
+
+					return {
+						...composable,
+						launchRequest,
+					};
+				};
+
+				it("should open in a new tab", () => {
+					const { launchRequest, launchTool } = setup();
+
+					launchTool();
+
+					expect(window.open).toHaveBeenCalledWith(launchRequest.url, "_blank");
+				});
+			});
+		});
+
+		describe("when launching a tool with post method", () => {
+			afterEach(() => {
+				document.getElementById("launch-form")?.remove();
+			});
+
+			describe("when opening in the same tab", () => {
+				const setup = () => {
+					const launchRequest = toolLaunchRequestFactory.build({
+						method: ToolLaunchRequestMethodEnum.Post,
+						openNewTab: false,
+					});
+
+					const composable = useExternalToolLaunchState();
+					composable.toolLaunchRequest.value = launchRequest;
+
+					return {
+						...composable,
+						launchRequest,
+					};
+				};
+
+				it("should create a launch form with target _self", () => {
+					const { launchRequest, launchTool } = setup();
+
+					launchTool();
+
+					const form = document.getElementById("launch-form");
+
+					expect(form?.outerHTML).toEqual(
+						`<form method="POST" action="${launchRequest.url}" target="_self" id="launch-form"><input type="hidden" name="key" value="value"></form>`
+					);
+				});
+			});
+
+			describe("when opening in a new tab", () => {
+				const setup = () => {
+					const launchRequest = toolLaunchRequestFactory.build({
+						method: ToolLaunchRequestMethodEnum.Post,
+						openNewTab: true,
+						payload: "",
+					});
+
+					const composable = useExternalToolLaunchState();
+					composable.toolLaunchRequest.value = launchRequest;
+
+					return {
+						...composable,
+						launchRequest,
+					};
+				};
+
+				it("should create a launch form with target _blank", () => {
+					const { launchRequest, launchTool } = setup();
+
+					launchTool();
+
+					const form = document.getElementById("launch-form");
+
+					expect(form?.outerHTML).toEqual(
+						`<form method="POST" action="${launchRequest.url}" target="_blank" id="launch-form"></form>`
+					);
+				});
+			});
+		});
+
+		describe("when the launch method is unknown", () => {
+			const setup = () => {
+				const launchRequest = toolLaunchRequestFactory.build({
+					method: "unknown" as unknown as ToolLaunchRequestMethodEnum,
+				});
+
+				const composable = useExternalToolLaunchState();
+				composable.toolLaunchRequest.value = launchRequest;
+
+				return {
+					...composable,
+					launchRequest,
+				};
+			};
+
+			it("should set an error", () => {
+				const { error, launchTool } = setup();
+
+				launchTool();
+
+				expect(error.value).toEqual<BusinessError>({
+					message: "Unknown launch method",
+					statusCode: HttpStatusCode.UnprocessableEntity,
+				});
+			});
+
+			it("should not redirect", () => {
+				const { launchTool } = setup();
+
+				launchTool();
+
+				expect(window.location.href).toEqual("");
+			});
+		});
+	});
+});
diff --git a/src/components/data-external-tool/index.ts b/src/components/data-external-tool/index.ts
index f64b0c1f8f..9c9d3f1c8e 100644
--- a/src/components/data-external-tool/index.ts
+++ b/src/components/data-external-tool/index.ts
@@ -1,2 +1,3 @@
 export * from "./ContextExternalToolApi.composable";
 export * from "./ExternalToolElementDisplayState.composable";
+export * from "./ExternalToolLaunchState.composable";
diff --git a/src/components/external-tools/configuration/ExternalToolConfigSettings.unit.ts b/src/components/external-tools/configuration/ExternalToolConfigSettings.unit.ts
index f62f4c04b1..189942b31a 100644
--- a/src/components/external-tools/configuration/ExternalToolConfigSettings.unit.ts
+++ b/src/components/external-tools/configuration/ExternalToolConfigSettings.unit.ts
@@ -1,9 +1,5 @@
 import { ExternalToolConfigurationTemplate } from "@/store/external-tool";
-import ExternalToolsModule from "@/store/external-tools";
-import { EXTERNAL_TOOLS_MODULE_KEY, I18N_KEY } from "@/utils/inject";
-import { createModuleMocks } from "@/utils/mock-store-module";
 import {
-	i18nMock,
 	schoolExternalToolConfigurationTemplateFactory,
 	toolParameterFactory,
 } from "@@/tests/test-utils";
@@ -20,26 +16,16 @@ describe("ExternalToolConfigSettings", () => {
 		} = {
 			template: schoolExternalToolConfigurationTemplateFactory.build(),
 			value: [],
-		},
-		getter: Partial<ExternalToolsModule> = {}
+		}
 	) => {
 		document.body.setAttribute("data-app", "true");
 
-		const externalToolsModule = createModuleMocks(ExternalToolsModule, {
-			getLoading: false,
-			...getter,
-		}) as jest.Mocked<ExternalToolsModule>;
-
 		const wrapper: Wrapper<Vue> = shallowMount(
 			ExternalToolConfigSettings as MountOptions<Vue>,
 			{
 				...createComponentMocks({
 					i18n: true,
 				}),
-				provide: {
-					[I18N_KEY.valueOf()]: i18nMock,
-					[EXTERNAL_TOOLS_MODULE_KEY.valueOf()]: externalToolsModule,
-				},
 				propsData: {
 					...props,
 				},
@@ -48,7 +34,6 @@ describe("ExternalToolConfigSettings", () => {
 
 		return {
 			wrapper,
-			externalToolsModule,
 		};
 	};
 
@@ -62,40 +47,6 @@ describe("ExternalToolConfigSettings", () => {
 		});
 	});
 
-	describe("progressbar", () => {
-		it("should display progressbar when loading in store is set", () => {
-			const { wrapper } = getWrapper(
-				{
-					template: schoolExternalToolConfigurationTemplateFactory.build(),
-					value: [],
-				},
-				{
-					getLoading: true,
-				}
-			);
-
-			const progressbar = wrapper.find("v-progress-linear-stub");
-
-			expect(progressbar.attributes().active).toBeTruthy();
-		});
-
-		it("should not display progressbar when loading in store is not set", () => {
-			const { wrapper } = getWrapper(
-				{
-					template: schoolExternalToolConfigurationTemplateFactory.build(),
-					value: [],
-				},
-				{
-					getLoading: false,
-				}
-			);
-
-			const progressbar = wrapper.find("v-progress-linear-stub");
-
-			expect(progressbar.attributes().active).toBeFalsy();
-		});
-	});
-
 	describe("parameters", () => {
 		const setup = () => {
 			const template = schoolExternalToolConfigurationTemplateFactory.build({
diff --git a/src/components/external-tools/configuration/ExternalToolConfigSettings.vue b/src/components/external-tools/configuration/ExternalToolConfigSettings.vue
index 816068dcce..61c023a6f0 100644
--- a/src/components/external-tools/configuration/ExternalToolConfigSettings.vue
+++ b/src/components/external-tools/configuration/ExternalToolConfigSettings.vue
@@ -6,24 +6,14 @@
 				v-model="inputValues[index]"
 			/>
 		</div>
-		<v-progress-linear :active="loading" indeterminate />
 	</div>
 </template>
 
 <script lang="ts">
 import { SchoolExternalToolConfigurationTemplate } from "@/store/external-tool";
-import {
-	computed,
-	ComputedRef,
-	defineComponent,
-	PropType,
-	WritableComputedRef,
-} from "vue";
-import ExternalToolsModule from "@/store/external-tools";
+import { computed, defineComponent, PropType, WritableComputedRef } from "vue";
 import ExternalToolConfigParameter from "./ExternalToolConfigParameter.vue";
-import { EXTERNAL_TOOLS_MODULE_KEY, injectStrict } from "@/utils/inject";
 
-// eslint-disable-next-line vue/require-direct-export
 export default defineComponent({
 	name: "ExternalToolConfigSettings",
 	components: { ExternalToolConfigParameter },
@@ -38,10 +28,6 @@ export default defineComponent({
 		},
 	},
 	setup(props, { emit }) {
-		const externalToolsModule: ExternalToolsModule = injectStrict(
-			EXTERNAL_TOOLS_MODULE_KEY
-		);
-
 		const inputValues: WritableComputedRef<(string | undefined)[]> = computed({
 			get() {
 				return props.value;
@@ -51,12 +37,7 @@ export default defineComponent({
 			},
 		});
 
-		const loading: ComputedRef<boolean> = computed(
-			() => externalToolsModule.getLoading
-		);
-
 		return {
-			loading,
 			inputValues,
 		};
 	},
diff --git a/src/components/feature-board-external-tool-element/ExternalToolElement.unit.ts b/src/components/feature-board-external-tool-element/ExternalToolElement.unit.ts
index 54651ab219..994a80d0bc 100644
--- a/src/components/feature-board-external-tool-element/ExternalToolElement.unit.ts
+++ b/src/components/feature-board-external-tool-element/ExternalToolElement.unit.ts
@@ -2,7 +2,10 @@ import {
 	ContentElementType,
 	ExternalToolElementResponse,
 } from "@/serverApi/v3";
-import { ExternalToolDisplayData } from "@/store/external-tool";
+import {
+	ExternalToolDisplayData,
+	ToolConfigurationStatus,
+} from "@/store/external-tool";
 import { ContextExternalTool } from "@/store/external-tool/context-external-tool";
 import { I18N_KEY } from "@/utils/inject";
 import {
@@ -13,7 +16,10 @@ import {
 } from "@@/tests/test-utils";
 import createComponentMocks from "@@/tests/test-utils/componentMocks";
 import { useBoardFocusHandler, useContentElementState } from "@data-board";
-import { useExternalToolElementDisplayState } from "@data-external-tool";
+import {
+	useExternalToolElementDisplayState,
+	useExternalToolLaunchState,
+} from "@data-external-tool";
 import { createMock, DeepMocked } from "@golevelup/ts-jest";
 import { mdiPuzzleOutline } from "@mdi/js";
 import { useDeleteConfirmationDialog } from "@ui-confirmation-dialog";
@@ -44,6 +50,9 @@ describe("ExternalToolElement", () => {
 	let useSharedExternalToolElementDisplayStateMock: DeepMocked<
 		ReturnType<typeof useExternalToolElementDisplayState>
 	>;
+	let useExternalToolLaunchStateMock: DeepMocked<
+		ReturnType<typeof useExternalToolLaunchState>
+	>;
 
 	beforeEach(() => {
 		useContentElementStateMock =
@@ -52,6 +61,8 @@ describe("ExternalToolElement", () => {
 			createMock<ReturnType<typeof useBoardFocusHandler>>();
 		useSharedExternalToolElementDisplayStateMock =
 			createMock<ReturnType<typeof useExternalToolElementDisplayState>>();
+		useExternalToolLaunchStateMock =
+			createMock<ReturnType<typeof useExternalToolLaunchState>>();
 
 		jest
 			.mocked(useContentElementState)
@@ -60,6 +71,9 @@ describe("ExternalToolElement", () => {
 		jest
 			.mocked(useExternalToolElementDisplayState)
 			.mockReturnValue(useSharedExternalToolElementDisplayStateMock);
+		jest
+			.mocked(useExternalToolLaunchState)
+			.mockReturnValue(useExternalToolLaunchStateMock);
 	});
 
 	afterEach(() => {
@@ -118,32 +132,98 @@ describe("ExternalToolElement", () => {
 
 	describe("when the element is mounted", () => {
 		describe("when the element has a tool attached", () => {
-			it("should load the display data", () => {
-				getWrapper({
-					element: {
-						...EMPTY_TEST_ELEMENT,
-						content: { contextExternalToolId: "contextExternalToolId" },
+			it("should load the display data", async () => {
+				getWrapper(
+					{
+						element: {
+							...EMPTY_TEST_ELEMENT,
+							content: { contextExternalToolId: "contextExternalToolId" },
+						},
+						isEditMode: false,
 					},
-					isEditMode: false,
-				});
+					externalToolDisplayDataFactory.build({
+						status: ToolConfigurationStatus.Latest,
+					})
+				);
+
+				await Vue.nextTick();
 
 				expect(
 					useSharedExternalToolElementDisplayStateMock.fetchDisplayData
 				).toHaveBeenCalledWith("contextExternalToolId");
 			});
+
+			it("should load the launch request", async () => {
+				getWrapper(
+					{
+						element: {
+							...EMPTY_TEST_ELEMENT,
+							content: { contextExternalToolId: "contextExternalToolId" },
+						},
+						isEditMode: false,
+					},
+					externalToolDisplayDataFactory.build({
+						status: ToolConfigurationStatus.Latest,
+					})
+				);
+
+				await Vue.nextTick();
+
+				expect(
+					useExternalToolLaunchStateMock.fetchLaunchRequest
+				).toHaveBeenCalledWith("contextExternalToolId");
+			});
 		});
 
-		describe("when the element deos not have a tool attached", () => {
-			it("should not load the display data", () => {
+		describe("when the element has a tool attached, but it is outdated", () => {
+			it("should not load the launch request", async () => {
+				getWrapper(
+					{
+						element: {
+							...EMPTY_TEST_ELEMENT,
+							content: { contextExternalToolId: "contextExternalToolId" },
+						},
+						isEditMode: false,
+					},
+					externalToolDisplayDataFactory.build({
+						status: ToolConfigurationStatus.Outdated,
+					})
+				);
+
+				await Vue.nextTick();
+
+				expect(
+					useExternalToolLaunchStateMock.fetchLaunchRequest
+				).not.toHaveBeenCalled();
+			});
+		});
+
+		describe("when the element does not have a tool attached", () => {
+			it("should not load the display data", async () => {
 				getWrapper({
 					element: EMPTY_TEST_ELEMENT,
 					isEditMode: false,
 				});
 
+				await Vue.nextTick();
+
 				expect(
 					useSharedExternalToolElementDisplayStateMock.fetchDisplayData
 				).not.toHaveBeenCalled();
 			});
+
+			it("should not load the launch request", async () => {
+				getWrapper({
+					element: EMPTY_TEST_ELEMENT,
+					isEditMode: false,
+				});
+
+				await Vue.nextTick();
+
+				expect(
+					useExternalToolLaunchStateMock.fetchLaunchRequest
+				).not.toHaveBeenCalled();
+			});
 		});
 	});
 
@@ -538,4 +618,35 @@ describe("ExternalToolElement", () => {
 			});
 		});
 	});
+
+	describe("Launch", () => {
+		describe("when clicking on a configured tool card", () => {
+			const setup = () => {
+				const { wrapper } = getWrapper({
+					element: {
+						...EMPTY_TEST_ELEMENT,
+						content: { contextExternalToolId: "contextExternalToolId" },
+					},
+					isEditMode: false,
+				});
+
+				return {
+					wrapper,
+				};
+			};
+
+			it("should launch the tool", async () => {
+				const { wrapper } = setup();
+
+				const card = wrapper.findComponent({
+					ref: "externalToolElement",
+				});
+
+				card.vm.$emit("click");
+				await Vue.nextTick();
+
+				expect(useExternalToolLaunchStateMock.launchTool).toHaveBeenCalled();
+			});
+		});
+	});
 });
diff --git a/src/components/feature-board-external-tool-element/ExternalToolElement.vue b/src/components/feature-board-external-tool-element/ExternalToolElement.vue
index a33d959f6f..b1db816beb 100644
--- a/src/components/feature-board-external-tool-element/ExternalToolElement.vue
+++ b/src/components/feature-board-external-tool-element/ExternalToolElement.vue
@@ -56,9 +56,13 @@
 <script lang="ts">
 import { useI18n } from "@/composables/i18n.composable";
 import { ExternalToolElementResponse } from "@/serverApi/v3";
+import { ToolConfigurationStatus } from "@/store/external-tool";
 import { ContextExternalTool } from "@/store/external-tool/context-external-tool";
 import { useBoardFocusHandler, useContentElementState } from "@data-board";
-import { useExternalToolElementDisplayState } from "@data-external-tool";
+import {
+	useExternalToolElementDisplayState,
+	useExternalToolLaunchState,
+} from "@data-external-tool";
 import { mdiPuzzleOutline } from "@mdi/js";
 import {
 	computed,
@@ -101,6 +105,7 @@ export default defineComponent({
 			displayData,
 			isLoading: isDisplayDataLoading,
 		} = useExternalToolElementDisplayState();
+		const { launchTool, fetchLaunchRequest } = useExternalToolLaunchState();
 
 		const autofocus: Ref<boolean> = ref(false);
 		const element: Ref<ExternalToolElementResponse> = toRef(props, "element");
@@ -116,6 +121,10 @@ export default defineComponent({
 			() => displayData.value?.name ?? "..."
 		);
 
+		const isToolOutdated: ComputedRef<boolean> = computed(
+			() => displayData.value?.status === ToolConfigurationStatus.Outdated
+		);
+
 		const isLoading = computed(
 			() =>
 				hasLinkedTool.value && !displayData.value && isDisplayDataLoading.value
@@ -145,12 +154,12 @@ export default defineComponent({
 		};
 
 		const onClickElement = () => {
-			if (props.isEditMode) {
-				if (!hasLinkedTool.value) {
-					isConfigurationDialogOpen.value = true;
-				}
-			} else {
-				// TODO N21-1285: launch tool
+			if (hasLinkedTool.value && !props.isEditMode) {
+				launchTool();
+			}
+
+			if (!hasLinkedTool.value && props.isEditMode) {
+				isConfigurationDialogOpen.value = true;
 			}
 		};
 
@@ -161,14 +170,20 @@ export default defineComponent({
 		const onConfigurationDialogSave = async (tool: ContextExternalTool) => {
 			modelValue.value.contextExternalToolId = tool.id;
 
-			await fetchDisplayData(modelValue.value.contextExternalToolId);
+			await loadCardData();
 		};
 
-		onMounted(async () => {
+		const loadCardData = async () => {
 			if (modelValue.value.contextExternalToolId) {
 				await fetchDisplayData(modelValue.value.contextExternalToolId);
+
+				if (!isToolOutdated.value) {
+					await fetchLaunchRequest(modelValue.value.contextExternalToolId);
+				}
 			}
-		});
+		};
+
+		onMounted(loadCardData);
 
 		return {
 			t,
diff --git a/src/components/rooms/RoomExternalToolCard.unit.ts b/src/components/rooms/RoomExternalToolCard.unit.ts
index f465dbc31e..8ed6ad9adb 100644
--- a/src/components/rooms/RoomExternalToolCard.unit.ts
+++ b/src/components/rooms/RoomExternalToolCard.unit.ts
@@ -1,28 +1,39 @@
-import { mount, MountOptions, Wrapper } from "@vue/test-utils";
-import createComponentMocks from "@@/tests/test-utils/componentMocks";
-import Vue from "vue";
-import { ExternalToolDisplayData } from "@/store/external-tool/external-tool-display-data";
-import { externalToolDisplayDataFactory } from "@@/tests/test-utils/factory/externalToolDisplayDataFactory";
 import EnvConfigModule from "@/store/env-config";
-import { createModuleMocks } from "@/utils/mock-store-module";
-import RoomExternalToolCard from "./RoomExternalToolCard.vue";
-import {
-	ENV_CONFIG_MODULE_KEY,
-	EXTERNAL_TOOLS_MODULE_KEY,
-	I18N_KEY,
-} from "@/utils/inject";
 import { ToolConfigurationStatus } from "@/store/external-tool";
-import ExternalToolsModule from "@/store/external-tools";
+import { ExternalToolDisplayData } from "@/store/external-tool/external-tool-display-data";
+import { ENV_CONFIG_MODULE_KEY, I18N_KEY } from "@/utils/inject";
+import { createModuleMocks } from "@/utils/mock-store-module";
+import createComponentMocks from "@@/tests/test-utils/componentMocks";
+import { externalToolDisplayDataFactory } from "@@/tests/test-utils/factory/externalToolDisplayDataFactory";
+import { toolLaunchRequestFactory } from "@@/tests/test-utils/factory/toolLaunchRequestFactory";
+import { useExternalToolLaunchState } from "@data-external-tool";
+import { createMock, DeepMocked } from "@golevelup/ts-jest";
+import { mount, MountOptions, Wrapper } from "@vue/test-utils";
 import flushPromises from "flush-promises";
-import { toolLaunchRequestResponseFactory } from "@@/tests/test-utils";
-import { ToolLaunchRequestResponse } from "@/serverApi/v3";
+import Vue from "vue";
+import RoomExternalToolCard from "./RoomExternalToolCard.vue";
+
+jest.mock("@data-external-tool");
 
 describe("RoomExternalToolCard", () => {
-	const getWrapper = (
-		tool: ExternalToolDisplayData,
-		canEdit: boolean,
-		externalToolsModuleMock = createModuleMocks(ExternalToolsModule)
-	) => {
+	let useExternalToolLaunchStateMock: DeepMocked<
+		ReturnType<typeof useExternalToolLaunchState>
+	>;
+
+	beforeEach(() => {
+		useExternalToolLaunchStateMock =
+			createMock<ReturnType<typeof useExternalToolLaunchState>>();
+
+		jest
+			.mocked(useExternalToolLaunchState)
+			.mockReturnValue(useExternalToolLaunchStateMock);
+	});
+
+	afterEach(() => {
+		jest.resetAllMocks();
+	});
+
+	const getWrapper = (tool: ExternalToolDisplayData, canEdit: boolean) => {
 		document.body.setAttribute("data-app", "true");
 
 		const envConfigModule = createModuleMocks(EnvConfigModule, {
@@ -45,7 +56,6 @@ describe("RoomExternalToolCard", () => {
 						tc: (key: string): string => key,
 					},
 					[ENV_CONFIG_MODULE_KEY.valueOf()]: envConfigModule,
-					[EXTERNAL_TOOLS_MODULE_KEY.valueOf()]: externalToolsModuleMock,
 				},
 			}
 		);
@@ -55,8 +65,21 @@ describe("RoomExternalToolCard", () => {
 		};
 	};
 
-	afterEach(() => {
-		jest.resetAllMocks();
+	describe("when the component is mounted and the tool is not outdated", () => {
+		it("should load the launch request", async () => {
+			getWrapper(
+				externalToolDisplayDataFactory.build({
+					status: ToolConfigurationStatus.Latest,
+				}),
+				false
+			);
+
+			await Vue.nextTick();
+
+			expect(
+				useExternalToolLaunchStateMock.fetchLaunchRequest
+			).toHaveBeenCalled();
+		});
 	});
 
 	describe("tool status", () => {
@@ -112,71 +135,75 @@ describe("RoomExternalToolCard", () => {
 	});
 
 	describe("when the user clicks the card", () => {
-		describe("when there was no error while loading launch request", () => {
+		describe("when the tool is outdated", () => {
 			const setup = async () => {
 				const toolDisplayData: ExternalToolDisplayData =
-					externalToolDisplayDataFactory.build();
+					externalToolDisplayDataFactory.build({
+						status: ToolConfigurationStatus.Outdated,
+					});
 
-				const launchRequest: ToolLaunchRequestResponse =
-					toolLaunchRequestResponseFactory.build();
+				const { wrapper } = getWrapper(toolDisplayData, true);
 
-				const externalToolsModuleMock = createModuleMocks(ExternalToolsModule);
-				externalToolsModuleMock.loadToolLaunchData.mockResolvedValueOnce(
-					launchRequest
-				);
+				await flushPromises();
 
-				const { wrapper } = getWrapper(
+				return {
+					wrapper,
 					toolDisplayData,
-					true,
-					externalToolsModuleMock
-				);
+				};
+			};
+
+			it("should emit the error event", async () => {
+				const { wrapper, toolDisplayData } = await setup();
+
+				await wrapper.trigger("click");
+
+				expect(wrapper.emitted("error")).toEqual([[toolDisplayData]]);
+			});
+		});
+
+		describe("when there was no error while loading launch request", () => {
+			const setup = async () => {
+				const toolDisplayData: ExternalToolDisplayData =
+					externalToolDisplayDataFactory.build();
+
+				useExternalToolLaunchStateMock.toolLaunchRequest.value =
+					toolLaunchRequestFactory.build();
+
+				const { wrapper } = getWrapper(toolDisplayData, true);
 
 				await flushPromises();
 
 				return {
 					wrapper,
-					toolDisplayData,
-					launchRequest,
 				};
 			};
 
-			it("should emit the click event", async () => {
-				const { wrapper, toolDisplayData, launchRequest } = await setup();
+			it("should launch the tool", async () => {
+				const { wrapper } = await setup();
 
 				await wrapper.trigger("click");
 
-				expect(wrapper.emitted("click")).toContainEqual([
-					launchRequest,
-					toolDisplayData,
-				]);
+				expect(useExternalToolLaunchStateMock.launchTool).toHaveBeenCalled();
 			});
 		});
 
-		describe("when loading error is set", () => {
+		describe("when the launch failed and an error is set", () => {
 			const setup = async () => {
 				const toolDisplayData: ExternalToolDisplayData =
 					externalToolDisplayDataFactory.build();
 
-				const launchRequest: ToolLaunchRequestResponse =
-					toolLaunchRequestResponseFactory.build();
-
-				const externalToolsModuleMock = createModuleMocks(ExternalToolsModule);
-				externalToolsModuleMock.loadToolLaunchData.mockRejectedValueOnce(
-					new Error()
-				);
+				useExternalToolLaunchStateMock.error.value = {
+					message: "mock error",
+					statusCode: 400,
+				};
 
-				const { wrapper } = getWrapper(
-					toolDisplayData,
-					true,
-					externalToolsModuleMock
-				);
+				const { wrapper } = getWrapper(toolDisplayData, true);
 
 				await flushPromises();
 
 				return {
 					wrapper,
 					toolDisplayData,
-					launchRequest,
 				};
 			};
 
@@ -185,7 +212,7 @@ describe("RoomExternalToolCard", () => {
 
 				await wrapper.trigger("click");
 
-				expect(wrapper.emitted("error")).toContainEqual([toolDisplayData]);
+				expect(wrapper.emitted("error")).toEqual([[toolDisplayData]]);
 			});
 		});
 	});
diff --git a/src/components/rooms/RoomExternalToolCard.vue b/src/components/rooms/RoomExternalToolCard.vue
index a6f0a9fee1..aae81dfd0f 100644
--- a/src/components/rooms/RoomExternalToolCard.vue
+++ b/src/components/rooms/RoomExternalToolCard.vue
@@ -33,38 +33,20 @@
 </template>
 
 <script lang="ts">
-import {
-	computed,
-	ComputedRef,
-	defineComponent,
-	onMounted,
-	PropType,
-	ref,
-	Ref,
-} from "vue";
 import RoomDotMenu from "@/components/molecules/RoomDotMenu.vue";
+import EnvConfigModule from "@/store/env-config";
+import { ToolConfigurationStatus } from "@/store/external-tool";
 import { ExternalToolDisplayData } from "@/store/external-tool/external-tool-display-data";
-import {
-	ENV_CONFIG_MODULE_KEY,
-	EXTERNAL_TOOLS_MODULE_KEY,
-	I18N_KEY,
-	injectStrict,
-} from "@/utils/inject";
+import { ENV_CONFIG_MODULE_KEY, I18N_KEY, injectStrict } from "@/utils/inject";
+import { useExternalToolLaunchState } from "@data-external-tool";
 import { mdiAlert, mdiPencilOutline, mdiTrashCanOutline } from "@mdi/js";
-import {
-	ToolConfigurationStatus,
-	ToolLaunchRequest,
-} from "@/store/external-tool";
-import EnvConfigModule from "@/store/env-config";
+import { computed, ComputedRef, defineComponent, PropType, watch } from "vue";
 import RoomBaseCard from "./RoomBaseCard.vue";
-import ExternalToolsModule from "@/store/external-tools";
-import { ExternalToolMapper } from "@/store/external-tool/mapper";
-import { ToolLaunchRequestResponse } from "@/serverApi/v3";
 
 export default defineComponent({
 	name: "RoomExternalToolCard",
 	components: { RoomBaseCard, RoomDotMenu },
-	emits: ["edit", "delete", "click", "error"],
+	emits: ["edit", "delete", "error"],
 	props: {
 		tool: {
 			type: Object as PropType<ExternalToolDisplayData>,
@@ -80,19 +62,25 @@ export default defineComponent({
 		const envConfigModule: EnvConfigModule = injectStrict(
 			ENV_CONFIG_MODULE_KEY
 		);
-		const externalToolsModule: ExternalToolsModule = injectStrict(
-			EXTERNAL_TOOLS_MODULE_KEY
-		);
+
+		const {
+			fetchLaunchRequest,
+			launchTool,
+			error: launchError,
+		} = useExternalToolLaunchState();
 
 		const t = (key: string): string => i18n.tc(key, 0);
 
 		const handleClick = () => {
-			if (loadingError.value) {
+			if (isToolOutdated.value) {
 				emit("error", props.tool);
-				return;
 			}
 
-			emit("click", toolLaunchRequest.value, props.tool);
+			launchTool();
+
+			if (launchError.value) {
+				emit("error", props.tool);
+			}
 		};
 
 		const handleEdit = () => {
@@ -125,30 +113,15 @@ export default defineComponent({
 			() => props.tool.status === ToolConfigurationStatus.Outdated
 		);
 
-		const toolLaunchRequest: Ref<ToolLaunchRequest | undefined> = ref();
-
-		const loadingError: Ref<boolean> = ref(false);
 		const loadLaunchRequest = async () => {
-			loadingError.value = false;
-			try {
-				const response: ToolLaunchRequestResponse | undefined =
-					await externalToolsModule.loadToolLaunchData(
-						props.tool.contextExternalToolId
-					);
-				toolLaunchRequest.value = response
-					? ExternalToolMapper.mapToToolLaunchRequest(response)
-					: undefined;
-			} catch (e: unknown) {
-				loadingError.value = true;
-			}
-		};
-
-		onMounted(async () => {
 			if (isToolOutdated.value) {
 				return;
 			}
-			await loadLaunchRequest();
-		});
+
+			await fetchLaunchRequest(props.tool.contextExternalToolId);
+		};
+
+		watch(() => props.tool, loadLaunchRequest, { immediate: true });
 
 		return {
 			t,
diff --git a/src/main.ts b/src/main.ts
index b7ab0d05c4..d61922524c 100644
--- a/src/main.ts
+++ b/src/main.ts
@@ -1,3 +1,7 @@
+// NUXT_REMOVAL change how global components are handled
+import "@/components/base/_globals";
+import "@/plugins/directives";
+import "@/plugins/polyfills";
 import {
 	accountsModule,
 	applicationErrorModule,
@@ -8,7 +12,6 @@ import {
 	contextExternalToolsModule,
 	copyModule,
 	envConfigModule,
-	externalToolsModule,
 	filePathsModule,
 	finishedTasksModule,
 	groupModule,
@@ -17,7 +20,6 @@ import {
 	newsModule,
 	notifierModule,
 	privacyPolicyModule,
-	termsOfUseModule,
 	roomModule,
 	roomsModule,
 	schoolExternalToolsModule,
@@ -26,33 +28,30 @@ import {
 	statusAlertsModule,
 	systemsModule,
 	tasksModule,
+	termsOfUseModule,
 	userLoginMigrationModule,
 	videoConferenceModule,
 } from "@/store";
-import Vue from "vue";
-import App from "./App.vue";
-import { createI18n } from "./plugins/i18n";
-import store from "./plugins/store";
-import vuetify from "./plugins/vuetify";
-import router from "./router";
+
+import "@/styles/global.scss";
 // NUXT_REMOVAL set this based on the tenant theme
 import themeConfig from "@/theme.config";
+import { htmlConfig } from "@feature-render-html";
+import axios from "axios";
+import Cookies from "universal-cookie";
+import Vue from "vue";
+import VueDOMPurifyHTML from "vue-dompurify-html";
 // NUXT_REMOVAL try to solve without vue-mq dependency
 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
 // @ts-ignore
 import VueMq from "vue-mq";
 import Vuelidate from "vuelidate";
-import { htmlConfig } from "@feature-render-html";
-import VueDOMPurifyHTML from "vue-dompurify-html";
-// NUXT_REMOVAL change how global components are handled
-import "@/components/base/_globals";
-import "@/plugins/directives";
-import "@/plugins/polyfills";
-
-import "@/styles/global.scss";
-import axios from "axios";
-import Cookies from "universal-cookie";
+import App from "./App.vue";
 import { handleApplicationError } from "./plugins/application-error-handler";
+import { createI18n } from "./plugins/i18n";
+import store from "./plugins/store";
+import vuetify from "./plugins/vuetify";
+import router from "./router";
 import { initializeAxios } from "./utils/api";
 
 import {
@@ -60,19 +59,18 @@ import {
 	AUTH_MODULE_KEY,
 	CONTEXT_EXTERNAL_TOOLS_MODULE_KEY,
 	ENV_CONFIG_MODULE_KEY,
-	EXTERNAL_TOOLS_MODULE_KEY,
 	GROUP_MODULE_KEY,
 	I18N_KEY,
 	NOTIFIER_MODULE_KEY,
+	PRIVACY_POLICY_MODULE_KEY,
 	ROOM_MODULE_KEY,
 	SCHOOL_EXTERNAL_TOOLS_MODULE_KEY,
 	SCHOOLS_MODULE_KEY,
 	STATUS_ALERTS_MODULE_KEY,
 	SYSTEMS_MODULE_KEY,
+	TERMS_OF_USE_MODULE_KEY,
 	USER_LOGIN_MIGRATION_MODULE_KEY,
 	VIDEO_CONFERENCE_MODULE_KEY,
-	PRIVACY_POLICY_MODULE_KEY,
-	TERMS_OF_USE_MODULE_KEY,
 } from "./utils/inject";
 
 Vue.config.productionTip = false;
@@ -152,7 +150,6 @@ Vue.use(VueDOMPurifyHTML, {
 			[CONTEXT_EXTERNAL_TOOLS_MODULE_KEY.valueOf()]: contextExternalToolsModule,
 			copyModule,
 			[ENV_CONFIG_MODULE_KEY.valueOf()]: envConfigModule,
-			[EXTERNAL_TOOLS_MODULE_KEY.valueOf()]: externalToolsModule,
 			filePathsModule,
 			finishedTasksModule,
 			[GROUP_MODULE_KEY.valueOf()]: groupModule,
diff --git a/src/pages/rooms/tools/RoomExternalToolsSection.unit.ts b/src/pages/rooms/tools/RoomExternalToolsSection.unit.ts
index 79f37703d8..73b84a401c 100644
--- a/src/pages/rooms/tools/RoomExternalToolsSection.unit.ts
+++ b/src/pages/rooms/tools/RoomExternalToolsSection.unit.ts
@@ -6,26 +6,17 @@ import {
 	ExternalToolDisplayData,
 	ToolConfigurationStatus,
 } from "@/store/external-tool";
-import ExternalToolsModule from "@/store/external-tools";
-import { BusinessError } from "@/store/types/commons";
 import {
 	AUTH_MODULE_KEY,
 	CONTEXT_EXTERNAL_TOOLS_MODULE_KEY,
 	ENV_CONFIG_MODULE_KEY,
-	EXTERNAL_TOOLS_MODULE_KEY,
 	I18N_KEY,
 } from "@/utils/inject";
 import { createModuleMocks } from "@/utils/mock-store-module";
 import createComponentMocks from "@@/tests/test-utils/componentMocks";
-import {
-	businessErrorFactory,
-	externalToolDisplayDataFactory,
-	toolLaunchRequestResponseFactory,
-} from "@@/tests/test-utils/factory";
+import { externalToolDisplayDataFactory } from "@@/tests/test-utils/factory";
 import { createMock, DeepMocked } from "@golevelup/ts-jest";
 import { mount, MountOptions, Wrapper } from "@vue/test-utils";
-import { AxiosError } from "axios";
-import flushPromises from "flush-promises";
 import Vue from "vue";
 import VueRouter from "vue-router";
 import * as routerComposables from "vue-router/composables";
@@ -34,13 +25,10 @@ import RoomExternalToolsSection from "./RoomExternalToolsSection.vue";
 describe("RoomExternalToolsSection", () => {
 	let router: DeepMocked<VueRouter>;
 
-	const getWrapper = (
-		props: {
-			tools: ExternalToolDisplayData[];
-			roomId: string;
-		},
-		externalToolsModuleMock = createModuleMocks(ExternalToolsModule)
-	) => {
+	const getWrapper = (props: {
+		tools: ExternalToolDisplayData[];
+		roomId: string;
+	}) => {
 		document.body.setAttribute("data-app", "true");
 
 		const contextExternalToolsModule = createModuleMocks(
@@ -74,7 +62,6 @@ describe("RoomExternalToolsSection", () => {
 					},
 					[CONTEXT_EXTERNAL_TOOLS_MODULE_KEY.valueOf()]:
 						contextExternalToolsModule,
-					[EXTERNAL_TOOLS_MODULE_KEY.valueOf()]: externalToolsModuleMock,
 					[AUTH_MODULE_KEY.valueOf()]: authModule,
 					[ENV_CONFIG_MODULE_KEY.valueOf()]: envConfigModule,
 				},
@@ -251,133 +238,34 @@ describe("RoomExternalToolsSection", () => {
 		});
 	});
 
-	describe("when clicking on a tool", () => {
-		describe("when the tool has missing auto parameters and loading requestData throw an error", () => {
-			const setup = async () => {
-				const tool: ExternalToolDisplayData =
-					externalToolDisplayDataFactory.build({
-						status: ToolConfigurationStatus.Latest,
-					});
-
-				const error: BusinessError = businessErrorFactory.build({
-					error: new AxiosError("this error is expected"),
-					message: "MISSING_TOOL_PARAMETER_VALUE some value is missing",
-				});
-
-				const externalToolsModule = createModuleMocks(ExternalToolsModule);
-				externalToolsModule.loadToolLaunchData.mockRejectedValueOnce(error);
-
-				const { wrapper } = getWrapper(
-					{ tools: [tool], roomId: "roomId" },
-					externalToolsModule
-				);
-
-				await flushPromises();
-
-				return {
-					wrapper,
-					tool,
-				};
-			};
-
-			it("should open up the error dialog", async () => {
-				const { wrapper } = await setup();
-
-				const card = wrapper.findComponent({
-					name: "room-external-tool-card",
+	describe("when a card reports an error", () => {
+		const setup = async () => {
+			const tool: ExternalToolDisplayData =
+				externalToolDisplayDataFactory.build({
+					status: ToolConfigurationStatus.Latest,
 				});
 
-				await card.trigger("click");
-
-				const dialog = wrapper.find('[data-testId="error-dialog"]');
-				expect(dialog.exists()).toBeTruthy();
-				expect(wrapper.vm.isErrorDialogOpen).toBeTruthy();
-			});
-		});
-
-		describe("when the tool is launchable", () => {
-			const setup = async () => {
-				const tool: ExternalToolDisplayData =
-					externalToolDisplayDataFactory.build({
-						status: ToolConfigurationStatus.Latest,
-					});
-
-				const externalToolsModule = createModuleMocks(ExternalToolsModule);
-				externalToolsModule.loadToolLaunchData.mockResolvedValue(
-					toolLaunchRequestResponseFactory.build()
-				);
-
-				const { wrapper } = getWrapper(
-					{
-						tools: [tool],
-						roomId: "roomId",
-					},
-					externalToolsModule
-				);
-
-				await flushPromises();
+			const { wrapper } = getWrapper({ tools: [tool], roomId: "roomId" });
 
-				return {
-					wrapper,
-				};
+			return {
+				wrapper,
+				tool,
 			};
+		};
 
-			it("should not open up the error dialog", async () => {
-				const { wrapper } = await setup();
-
-				const card = wrapper.findComponent({
-					name: "room-external-tool-card",
-				});
-
-				await card.trigger("click");
-
-				wrapper.find('[data-testId="error-dialog"]');
+		it("should open up the error dialog", async () => {
+			const { wrapper, tool } = await setup();
 
-				expect(wrapper.vm.isErrorDialogOpen).toBeFalsy();
+			const card = wrapper.findComponent({
+				name: "room-external-tool-card",
 			});
-		});
 
-		describe("and tool is not launchable because it is outdated", () => {
-			const setup = async () => {
-				const tool: ExternalToolDisplayData =
-					externalToolDisplayDataFactory.build({
-						status: ToolConfigurationStatus.Outdated,
-					});
-
-				const externalToolsModule = createModuleMocks(ExternalToolsModule);
-				externalToolsModule.loadToolLaunchData.mockResolvedValueOnce(
-					toolLaunchRequestResponseFactory.build()
-				);
-
-				const { wrapper } = getWrapper(
-					{
-						tools: [tool],
-						roomId: "roomId",
-					},
-					externalToolsModule
-				);
+			card.vm.$emit("error", tool);
+			await Vue.nextTick();
 
-				await flushPromises();
-
-				return {
-					wrapper,
-				};
-			};
-
-			it("should open up the error dialog", async () => {
-				const { wrapper } = await setup();
-
-				const card = wrapper.findComponent({
-					name: "room-external-tool-card",
-				});
-
-				await card.trigger("click");
-
-				const dialog = wrapper.find('[data-testId="error-dialog"]');
-
-				expect(dialog.exists()).toBeTruthy();
-				expect(wrapper.vm.isErrorDialogOpen).toBeTruthy();
-			});
+			const dialog = wrapper.find('[data-testId="error-dialog"]');
+			expect(dialog.exists()).toBeTruthy();
+			expect(dialog.props("isOpen")).toEqual(true);
 		});
 	});
 });
diff --git a/src/pages/rooms/tools/RoomExternalToolsSection.vue b/src/pages/rooms/tools/RoomExternalToolsSection.vue
index 2af07cfaa8..e56ebc4660 100644
--- a/src/pages/rooms/tools/RoomExternalToolsSection.vue
+++ b/src/pages/rooms/tools/RoomExternalToolsSection.vue
@@ -9,7 +9,6 @@
 			:can-edit="canEdit"
 			@delete="onOpenDeleteDialog"
 			@edit="onEditTool"
-			@click="onClickTool"
 			@error="onError"
 			:data-testid="`external-tool-card-${index}`"
 		/>
@@ -90,11 +89,6 @@ import RoomExternalToolCard from "@/components/rooms/RoomExternalToolCard.vue";
 import { ToolContextType } from "@/serverApi/v3";
 import AuthModule from "@/store/auth";
 import ContextExternalToolsModule from "@/store/context-external-tools";
-import {
-	ToolConfigurationStatus,
-	ToolLaunchRequest,
-	ToolLaunchRequestMethodEnum,
-} from "@/store/external-tool";
 import { ExternalToolDisplayData } from "@/store/external-tool/external-tool-display-data";
 import {
 	AUTH_MODULE_KEY,
@@ -193,25 +187,6 @@ export default defineComponent({
 			});
 		};
 
-		const onClickTool = async (
-			toolLaunchRequest: ToolLaunchRequest,
-			displayData: ExternalToolDisplayData
-		) => {
-			if (isToolLaunchable(displayData)) {
-				switch (toolLaunchRequest?.method) {
-					case ToolLaunchRequestMethodEnum.Get:
-						handleGetLaunchRequest(toolLaunchRequest);
-						break;
-					case ToolLaunchRequestMethodEnum.Post:
-						handlePostLaunchRequest(toolLaunchRequest);
-						break;
-					default:
-						isToolLaunchable(displayData);
-						break;
-				}
-			}
-		};
-
 		const onError = (displayData: ExternalToolDisplayData): void => {
 			showErrorDialog(displayData);
 		};
@@ -223,48 +198,6 @@ export default defineComponent({
 			isErrorDialogOpen.value = true;
 		};
 
-		const handleGetLaunchRequest = (toolLaunch: ToolLaunchRequest) => {
-			if (toolLaunch.openNewTab) {
-				window.open(toolLaunch.url, "_blank");
-				return;
-			}
-			window.location.href = toolLaunch.url;
-		};
-
-		const handlePostLaunchRequest = (toolLaunch: ToolLaunchRequest) => {
-			const form: HTMLFormElement = document.createElement("form");
-			form.method = "POST";
-			form.action = toolLaunch.url;
-			form.target = toolLaunch.openNewTab ? "_blank" : "_self";
-
-			const payload = JSON.parse(toolLaunch.payload || "{}");
-
-			for (const key in payload) {
-				if (Object.prototype.hasOwnProperty.call(payload, key)) {
-					const hiddenField = document.createElement("input");
-					hiddenField.type = "hidden";
-					hiddenField.name = key;
-					hiddenField.value = payload[key];
-
-					form.appendChild(hiddenField);
-				}
-			}
-
-			document.body.appendChild(form);
-			form.submit();
-		};
-
-		const isToolLaunchable = (
-			displayData: ExternalToolDisplayData
-		): boolean => {
-			if (displayData.status === ToolConfigurationStatus.Latest) {
-				return true;
-			}
-			showErrorDialog(displayData);
-
-			return false;
-		};
-
 		const errorDialogText: ComputedRef<string> = computed(() => {
 			if (authModule.getUserRoles.includes("teacher")) {
 				return t("pages.rooms.tools.outdatedDialog.content.teacher");
@@ -282,7 +215,6 @@ export default defineComponent({
 			onOpenDeleteDialog,
 			onCloseDeleteDialog,
 			onDeleteTool,
-			onClickTool,
 			onEditTool,
 			isErrorDialogOpen,
 			onCloseErrorDialog,
diff --git a/src/store/external-tools.ts b/src/store/external-tools.ts
deleted file mode 100644
index 3070424a4d..0000000000
--- a/src/store/external-tools.ts
+++ /dev/null
@@ -1,54 +0,0 @@
-import { Action, Module, Mutation, VuexModule } from "vuex-module-decorators";
-import { $axios, mapAxiosErrorToResponseError } from "@/utils/api";
-import {
-	ToolApiFactory,
-	ToolApiInterface,
-	ToolLaunchRequestResponse,
-} from "@/serverApi/v3";
-import { AxiosResponse } from "axios";
-
-@Module({
-	name: "externalToolsModule",
-	namespaced: true,
-	stateFactory: true,
-})
-export default class ExternalToolsModule extends VuexModule {
-	private loading = false;
-
-	private get toolApi(): ToolApiInterface {
-		return ToolApiFactory(undefined, "v3", $axios);
-	}
-
-	get getLoading(): boolean {
-		return this.loading;
-	}
-
-	@Mutation
-	setLoading(loading: boolean): void {
-		this.loading = loading;
-	}
-
-	@Action
-	async loadToolLaunchData(
-		contextExternalToolId: string
-	): Promise<ToolLaunchRequestResponse | undefined> {
-		this.setLoading(true);
-
-		try {
-			const resp: AxiosResponse<ToolLaunchRequestResponse> =
-				await this.toolApi.toolLaunchControllerGetToolLaunchRequest(
-					contextExternalToolId
-				);
-
-			this.setLoading(false);
-
-			return resp.data;
-		} catch (error: unknown) {
-			const apiError = mapAxiosErrorToResponseError(error);
-			console.log(apiError);
-			this.setLoading(false);
-
-			throw apiError;
-		}
-	}
-}
diff --git a/src/store/external-tools.unit.ts b/src/store/external-tools.unit.ts
deleted file mode 100644
index fadb7745e9..0000000000
--- a/src/store/external-tools.unit.ts
+++ /dev/null
@@ -1,94 +0,0 @@
-import { ToolApiInterface, ToolLaunchRequestResponse } from "@/serverApi/v3";
-import * as serverApi from "@/serverApi/v3/api";
-import { toolLaunchRequestResponseFactory } from "@@/tests/test-utils/factory";
-import { createMock, DeepMocked } from "@golevelup/ts-jest";
-import { mockApiResponse } from "@@/tests/test-utils";
-import ExternalToolsModule from "./external-tools";
-import { AxiosError } from "axios";
-
-describe("ExternalToolsModule", () => {
-	let module: ExternalToolsModule;
-
-	let apiMock: DeepMocked<ToolApiInterface>;
-
-	beforeEach(() => {
-		module = new ExternalToolsModule({});
-
-		apiMock = createMock<ToolApiInterface>();
-
-		jest.spyOn(serverApi, "ToolApiFactory").mockReturnValue(apiMock);
-	});
-
-	afterEach(() => {
-		jest.restoreAllMocks();
-	});
-
-	describe("mutations", () => {
-		describe("setLoading", () => {
-			it("should set the loading state", () => {
-				module.setLoading(true);
-
-				expect(module.getLoading).toBeTruthy();
-			});
-		});
-	});
-
-	describe("actions", () => {
-		describe("loadToolLaunchData is called", () => {
-			describe("when receiving an api response", () => {
-				const setup = () => {
-					const mockResponse: ToolLaunchRequestResponse =
-						toolLaunchRequestResponseFactory.build();
-
-					apiMock.toolLaunchControllerGetToolLaunchRequest.mockResolvedValue(
-						mockApiResponse({
-							data: mockResponse,
-						})
-					);
-
-					return {
-						mockResponse,
-					};
-				};
-
-				it("should call the api", async () => {
-					setup();
-
-					await module.loadToolLaunchData("contextToolId");
-
-					expect(
-						apiMock.toolLaunchControllerGetToolLaunchRequest
-					).toHaveBeenCalledWith("contextToolId");
-				});
-
-				it("should return a response", async () => {
-					const { mockResponse } = setup();
-
-					const response: ToolLaunchRequestResponse | undefined =
-						await module.loadToolLaunchData("contextToolId");
-
-					expect(response).toEqual(mockResponse);
-				});
-			});
-
-			describe("when receiving an api error", () => {
-				const setup = () => {
-					apiMock.toolLaunchControllerGetToolLaunchRequest.mockRejectedValue(
-						new AxiosError("error")
-					);
-				};
-
-				it("should throw an error", async () => {
-					setup();
-
-					try {
-						await module.loadToolLaunchData("contextToolId");
-					} catch (error) {
-						expect(error).toBeDefined();
-						expect(module.getLoading).toBeFalsy();
-					}
-				});
-			});
-		});
-	});
-});
diff --git a/src/store/store-accessor.ts b/src/store/store-accessor.ts
index 1d5f5d26cf..708ab8da8f 100644
--- a/src/store/store-accessor.ts
+++ b/src/store/store-accessor.ts
@@ -11,31 +11,30 @@ import AuthModule from "@/store/auth";
 import AutoLogoutModule from "@/store/autoLogout";
 import CollaborativeFilesModule from "@/store/collaborative-files";
 import ContentModule from "@/store/content";
+import ContextExternalToolsModule from "@/store/context-external-tools";
 import CopyModule from "@/store/copy";
 import EnvConfigModule from "@/store/env-config";
-import ExternalToolsModule from "@/store/external-tools";
 import FilePaths from "@/store/filePaths";
 import FinishedTasksModule from "@/store/finished-tasks";
 import GroupModule from "@/store/group";
 import ImportUsersModule from "@/store/import-users";
 import LoadingStateModule from "@/store/loading-state";
 import NewsModule from "@/store/news";
-import PrivacyPolicyModule from "@/store/privacy-policy";
 import NotifierModule from "@/store/notifier";
+import PrivacyPolicyModule from "@/store/privacy-policy";
 import RoomModule from "@/store/room";
 import RoomsModule from "@/store/rooms";
+import SchoolExternalToolsModule from "@/store/school-external-tools";
 import SchoolsModule from "@/store/schools";
 import ShareModule from "@/store/share";
 import StatusAlertsModule from "@/store/status-alerts";
 import SystemsModule from "@/store/systems";
 import TasksModule from "@/store/tasks";
+import TermsOfUseModule from "@/store/terms-of-use";
 import UserLoginMigrationModule from "@/store/user-login-migrations";
+import VideoConferenceModule from "@/store/video-conference";
 import { Store } from "vuex";
 import { getModule } from "vuex-module-decorators";
-import ContextExternalToolsModule from "@/store/context-external-tools";
-import SchoolExternalToolsModule from "@/store/school-external-tools";
-import VideoConferenceModule from "@/store/video-conference";
-import TermsOfUseModule from "@/store/terms-of-use";
 
 // Each store is the singleton instance of its module class
 // Use these -- they have methods for state/getters/mutations/actions
@@ -49,7 +48,6 @@ export let contentModule: ContentModule;
 export let contextExternalToolsModule: ContextExternalToolsModule;
 export let copyModule: CopyModule;
 export let envConfigModule: EnvConfigModule;
-export let externalToolsModule: ExternalToolsModule;
 export let filePathsModule: FilePaths;
 export let finishedTasksModule: FinishedTasksModule;
 export let groupModule: GroupModule;
@@ -81,7 +79,6 @@ export function initializeStores(store: Store<any>): void {
 	contextExternalToolsModule = getModule(ContextExternalToolsModule, store);
 	copyModule = getModule(CopyModule, store);
 	envConfigModule = getModule(EnvConfigModule, store);
-	externalToolsModule = getModule(ExternalToolsModule, store);
 	filePathsModule = getModule(FilePaths, store);
 	finishedTasksModule = getModule(FinishedTasksModule, store);
 	groupModule = getModule(GroupModule, store);
@@ -116,7 +113,6 @@ export const modules = {
 	contextExternalToolsModule: ContextExternalToolsModule,
 	copyModule: CopyModule,
 	envConfigModule: EnvConfigModule,
-	externalToolsModule: ExternalToolsModule,
 	filePathsModule: FilePaths,
 	finishedTasksModule: FinishedTasksModule,
 	groupModule: GroupModule,
diff --git a/src/utils/inject/injection-keys.ts b/src/utils/inject/injection-keys.ts
index e4ea062db7..6837c2b90d 100644
--- a/src/utils/inject/injection-keys.ts
+++ b/src/utils/inject/injection-keys.ts
@@ -1,21 +1,20 @@
-import { InjectionKey } from "vue";
-import EnvConfigModule from "@/store/env-config";
-import VueI18n from "vue-i18n";
-import NotifierModule from "@/store/notifier";
-import AuthModule from "@/store/auth";
-import ExternalToolsModule from "@/store/external-tools";
 import ApplicationErrorModule from "@/store/application-error";
+import AuthModule from "@/store/auth";
 import ContextExternalToolsModule from "@/store/context-external-tools";
+import EnvConfigModule from "@/store/env-config";
+import GroupModule from "@/store/group";
+import NotifierModule from "@/store/notifier";
+import PrivacyPolicyModule from "@/store/privacy-policy";
 import RoomModule from "@/store/room";
-import VideoConferenceModule from "@/store/video-conference";
-import StatusAlertsModule from "@/store/status-alerts";
 import SchoolExternalToolsModule from "@/store/school-external-tools";
-import UserLoginMigrationModule from "@/store/user-login-migrations";
+import SchoolsModule from "@/store/schools";
+import StatusAlertsModule from "@/store/status-alerts";
 import SystemsModule from "@/store/systems";
-import GroupModule from "@/store/group";
-import PrivacyPolicyModule from "@/store/privacy-policy";
 import TermsOfUseModule from "@/store/terms-of-use";
-import SchoolsModule from "@/store/schools";
+import UserLoginMigrationModule from "@/store/user-login-migrations";
+import VideoConferenceModule from "@/store/video-conference";
+import { InjectionKey } from "vue";
+import VueI18n from "vue-i18n";
 
 export const ENV_CONFIG_MODULE_KEY: InjectionKey<EnvConfigModule> =
 	Symbol("envConfigModule");
@@ -23,8 +22,6 @@ export const I18N_KEY: InjectionKey<VueI18n> = Symbol("i18n");
 export const NOTIFIER_MODULE_KEY: InjectionKey<NotifierModule> =
 	Symbol("notifierModule");
 export const AUTH_MODULE_KEY: InjectionKey<AuthModule> = Symbol("authModule");
-export const EXTERNAL_TOOLS_MODULE_KEY: InjectionKey<ExternalToolsModule> =
-	Symbol("externalToolsModule");
 export const SCHOOL_EXTERNAL_TOOLS_MODULE_KEY: InjectionKey<SchoolExternalToolsModule> =
 	Symbol("schoolExternalToolsModule");
 export const CONTEXT_EXTERNAL_TOOLS_MODULE_KEY: InjectionKey<ContextExternalToolsModule> =
diff --git a/tests/test-utils/factory/toolLaunchRequestFactory.ts b/tests/test-utils/factory/toolLaunchRequestFactory.ts
index fc177f6e3d..4f81cd4dc0 100644
--- a/tests/test-utils/factory/toolLaunchRequestFactory.ts
+++ b/tests/test-utils/factory/toolLaunchRequestFactory.ts
@@ -1,11 +1,11 @@
-import { Factory } from "fishery";
 import {
 	ToolLaunchRequest,
 	ToolLaunchRequestMethodEnum,
 } from "@/store/external-tool";
+import { Factory } from "fishery";
 
 export const toolLaunchRequestFactory = Factory.define<ToolLaunchRequest>(
-	({ sequence }) => ({
+	() => ({
 		method: ToolLaunchRequestMethodEnum.Get,
 		payload: '{ "key": "value" }',
 		url: "https://example.com/tool-launch",