diff --git a/packages/backend-test-utils/package.json b/packages/backend-test-utils/package.json
index d58720723d..cc47249a2d 100644
--- a/packages/backend-test-utils/package.json
+++ b/packages/backend-test-utils/package.json
@@ -73,7 +73,9 @@
     "testcontainers": "^10.0.0",
     "textextensions": "^5.16.0",
     "uuid": "^11.0.0",
-    "yn": "^4.0.0"
+    "yn": "^4.0.0",
+    "zod": "^3.22.4",
+    "zod-to-json-schema": "^3.20.4"
   },
   "devDependencies": {
     "@backstage/cli": "workspace:^",
diff --git a/packages/backend-test-utils/report.api.md b/packages/backend-test-utils/report.api.md
index c74d975920..a9377e70fe 100644
--- a/packages/backend-test-utils/report.api.md
+++ b/packages/backend-test-utils/report.api.md
@@ -3,8 +3,11 @@
 > Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
 
 ```ts
+import { ActionsRegistryActionOptions } from '@backstage/backend-plugin-api';
 import { ActionsRegistryService } from '@backstage/backend-plugin-api';
 import { ActionsService } from '@backstage/backend-plugin-api';
+import { ActionsServiceAction } from '@backstage/backend-plugin-api';
+import { AnyZodObject } from 'zod';
 import { AuditorService } from '@backstage/backend-plugin-api';
 import { AuthorizeResult } from '@backstage/plugin-permission-common';
 import { AuthService } from '@backstage/backend-plugin-api';
@@ -26,6 +29,7 @@ import { ExtensionPoint } from '@backstage/backend-plugin-api';
 import { HttpAuthService } from '@backstage/backend-plugin-api';
 import { HttpRouterService } from '@backstage/backend-plugin-api';
 import { JsonObject } from '@backstage/types';
+import { JsonValue } from '@backstage/types';
 import Keyv from 'keyv';
 import { Knex } from 'knex';
 import { LifecycleService } from '@backstage/backend-plugin-api';
@@ -56,6 +60,33 @@ export interface CreateMockDirectoryOptions {
   mockOsTmpDir?: boolean;
 }
 
+// @public
+export class MockActionsRegistry
+  implements ActionsRegistryService, ActionsService
+{
+  // (undocumented)
+  readonly actions: Map<string, ActionsRegistryActionOptions<any, any>>;
+  // (undocumented)
+  static create(opts: { logger: LoggerService }): MockActionsRegistry;
+  // (undocumented)
+  invoke(opts: {
+    id: string;
+    input?: JsonObject;
+    credentials?: BackstageCredentials;
+  }): Promise<{
+    output: JsonValue;
+  }>;
+  // (undocumented)
+  list(): Promise<{
+    actions: ActionsServiceAction[];
+  }>;
+  // (undocumented)
+  register<
+    TInputSchema extends AnyZodObject,
+    TOutputSchema extends AnyZodObject,
+  >(options: ActionsRegistryActionOptions<TInputSchema, TOutputSchema>): void;
+}
+
 // @public (undocumented)
 export namespace mockCredentials {
   export function limitedUser(
@@ -174,6 +205,10 @@ export namespace mockServices {
       ) => ServiceMock<ActionsService>;
   }
   // (undocumented)
+  export function actionsRegistry(options?: {
+    logger: LoggerService;
+  }): MockActionsRegistry;
+  // (undocumented)
   export namespace actionsRegistry {
     const // (undocumented)
       factory: () => ServiceFactory<
diff --git a/packages/backend-test-utils/src/next/services/MockActionsRegistry.test.ts b/packages/backend-test-utils/src/next/services/MockActionsRegistry.test.ts
new file mode 100644
index 0000000000..e4556cb89e
--- /dev/null
+++ b/packages/backend-test-utils/src/next/services/MockActionsRegistry.test.ts
@@ -0,0 +1,232 @@
+/*
+ * Copyright 2025 The Backstage Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import {
+  coreServices,
+  createBackendPlugin,
+} from '@backstage/backend-plugin-api';
+import { startTestBackend } from '../wiring';
+import { mockServices } from './mockServices';
+import { mockCredentials } from './mockCredentials';
+import { Router } from 'express';
+import supertest from 'supertest';
+
+describe('MockActionsRegistry', () => {
+  it('should be able to register and invoke actions', async () => {
+    const registry = mockServices.actionsRegistry();
+
+    registry.register({
+      name: 'my-demo-action',
+      title: 'Test',
+      description: 'Test',
+      schema: {
+        input: z =>
+          z.object({
+            name: z.string(),
+          }),
+        output: z =>
+          z.object({
+            name: z.string(),
+          }),
+      },
+      action: async ({ input }) => ({ output: { name: input.name } }),
+    });
+
+    const result = await registry.invoke({
+      id: 'test:my-demo-action',
+      input: { name: 'test' },
+    });
+
+    expect(result).toEqual({ output: { name: 'test' } });
+  });
+
+  it('should throw an error when the input is invalid to the action', async () => {
+    const registry = mockServices.actionsRegistry();
+
+    registry.register({
+      name: 'my-demo-action',
+      title: 'Test',
+      description: 'Test',
+      schema: {
+        input: z => z.object({ name: z.string() }),
+        output: z => z.object({ name: z.string() }),
+      },
+      action: async ({ input }) => ({ output: { name: input.name } }),
+    });
+
+    await expect(
+      registry.invoke({ id: 'test:my-demo-action', input: { name: 1 } }),
+    ).rejects.toThrow('Invalid input to action "test:my-demo-action"');
+  });
+
+  it('should throw an error when the action is not found', async () => {
+    const registry = mockServices.actionsRegistry();
+
+    await expect(registry.invoke({ id: 'test' })).rejects.toThrow(
+      'Action "test" not found, available actions: none',
+    );
+  });
+
+  it('should throw an error when the action is not found with recommended actions', async () => {
+    const registry = mockServices.actionsRegistry();
+
+    registry.register({
+      name: 'my-demo-action',
+      title: 'Test',
+      description: 'Test',
+      schema: {
+        input: z => z.object({ name: z.string() }),
+        output: z => z.object({ name: z.string() }),
+      },
+      action: async ({ input }) => ({ output: { name: input.name } }),
+    });
+
+    await expect(registry.invoke({ id: 'test' })).rejects.toThrow(
+      'Action "test" not found, available actions: "test:my-demo-action"',
+    );
+  });
+
+  it('should throw an error when the output is invalid', async () => {
+    const registry = mockServices.actionsRegistry();
+
+    registry.register({
+      name: 'my-demo-action',
+      title: 'Test',
+      description: 'Test',
+      schema: {
+        input: z => z.object({ name: z.number() }),
+        output: z => z.object({ name: z.string() }),
+      },
+      // @ts-expect-error - we want to test the error case
+      action: async ({ input }) => ({ output: { name: input.name } }),
+    });
+
+    await expect(
+      registry.invoke({ id: 'test:my-demo-action', input: { name: 1 } }),
+    ).rejects.toThrow('Invalid output from action "test:my-demo-action"');
+  });
+
+  it('should list the actions correctly', async () => {
+    const registry = mockServices.actionsRegistry();
+
+    registry.register({
+      name: 'my-demo-action',
+      title: 'Test',
+      description: 'Test',
+      schema: {
+        input: z => z.object({ name: z.string() }),
+        output: z => z.object({ name: z.string() }),
+      },
+      action: async ({ input }) => ({ output: { name: input.name } }),
+    });
+
+    const result = await registry.list();
+
+    expect(result).toMatchObject({
+      actions: [
+        {
+          id: 'test:my-demo-action',
+          name: 'my-demo-action',
+          title: 'Test',
+          description: 'Test',
+          attributes: {
+            destructive: true,
+            idempotent: false,
+            readOnly: false,
+          },
+          schema: {
+            input: {
+              type: 'object',
+              properties: {
+                name: { type: 'string' },
+              },
+            },
+            output: {
+              type: 'object',
+              properties: {
+                name: { type: 'string' },
+              },
+            },
+          },
+        },
+      ],
+    });
+  });
+
+  describe('mockServices.actions + mockService.actionsRegistry', () => {
+    it('should be able to register and invoke actions', async () => {
+      const pluginWithAction = createBackendPlugin({
+        pluginId: 'my-plugin',
+        register(reg) {
+          reg.registerInit({
+            deps: { actionsRegistry: coreServices.actionsRegistry },
+            async init({ actionsRegistry }) {
+              actionsRegistry.register({
+                name: 'test',
+                title: 'Test',
+                description: 'Test',
+                schema: {
+                  input: z => z.object({ name: z.string() }),
+                  output: z => z.object({ name: z.string() }),
+                },
+                action: async ({ input }) => {
+                  expect(input).toEqual({ name: 'test' });
+                  return { output: { name: input.name } };
+                },
+              });
+            },
+          });
+        },
+      });
+
+      const pluginToCallAction = createBackendPlugin({
+        pluginId: 'my-plugin-to-call-action',
+        register(reg) {
+          reg.registerInit({
+            deps: {
+              actions: coreServices.actions,
+              router: coreServices.httpRouter,
+            },
+            async init({ actions, router }) {
+              const testRouter = Router();
+              router.use(testRouter);
+
+              testRouter.post('/test', async (_, res) => {
+                const { output } = await actions.invoke({
+                  id: 'my-plugin:test',
+                  input: { name: 'test' },
+                  credentials: mockCredentials.service(),
+                });
+
+                res.json(output);
+              });
+            },
+          });
+        },
+      });
+
+      const { server } = await startTestBackend({
+        features: [pluginWithAction, pluginToCallAction],
+      });
+
+      const { body, status } = await supertest(server).post(
+        '/api/my-plugin-to-call-action/test',
+      );
+
+      expect(status).toBe(200);
+      expect(body).toEqual({ name: 'test' });
+    });
+  });
+});
diff --git a/packages/backend-test-utils/src/next/services/MockActionsRegistry.ts b/packages/backend-test-utils/src/next/services/MockActionsRegistry.ts
new file mode 100644
index 0000000000..62d940515b
--- /dev/null
+++ b/packages/backend-test-utils/src/next/services/MockActionsRegistry.ts
@@ -0,0 +1,166 @@
+/*
+ * Copyright 2025 The Backstage Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import {
+  ActionsRegistryActionOptions,
+  ActionsRegistryService,
+  ActionsService,
+  ActionsServiceAction,
+  BackstageCredentials,
+  LoggerService,
+} from '@backstage/backend-plugin-api';
+import { ForwardedError, InputError, NotFoundError } from '@backstage/errors';
+import { JsonObject, JsonValue } from '@backstage/types';
+import { z, AnyZodObject } from 'zod';
+import zodToJsonSchema from 'zod-to-json-schema';
+import { mockCredentials } from './mockCredentials';
+
+/**
+ * A mock implementation of the ActionsRegistryService and ActionsService that can be used in tests.
+ *
+ * This is useful for testing actions that are registered with the ActionsRegistryService and ActionsService.
+ *
+ * The plugin ID is hardcoded to `testing` in the mock implementation.
+ *
+ * @example
+ * ```ts
+ * const actionsRegistry = mockServices.actionsRegistry();
+ *
+ * actionsRegistry.register({
+ *   name: 'test',
+ *   title: 'Test',
+ *   description: 'Test',
+ *   schema: {
+ *     input: z.object({ name: z.string() }),
+ *     output: z.object({ name: z.string() }),
+ *   },
+ *   action: async ({ input }) => ({ output: { name: input.name } }),
+ * });
+ *
+ *
+ * const result = await actionsRegistry.invoke({
+ *   id: 'testing:test',
+ *   input: { name: 'test' },
+ * });
+ *
+ * expect(result).toEqual({ output: { name: 'test' } });
+ * ```
+ *
+ * @public
+ */
+export class MockActionsRegistry
+  implements ActionsRegistryService, ActionsService
+{
+  private constructor(private readonly logger: LoggerService) {}
+
+  static create(opts: { logger: LoggerService }) {
+    return new MockActionsRegistry(opts.logger);
+  }
+
+  readonly actions: Map<string, ActionsRegistryActionOptions<any, any>> =
+    new Map();
+
+  async list(): Promise<{ actions: ActionsServiceAction[] }> {
+    return {
+      actions: Array.from(this.actions.entries()).map(([id, action]) => ({
+        id,
+        name: action.name,
+        title: action.title,
+        description: action.description,
+        attributes: {
+          destructive: action.attributes?.destructive ?? true,
+          idempotent: action.attributes?.idempotent ?? false,
+          readOnly: action.attributes?.readOnly ?? false,
+        },
+        schema: {
+          input: action.schema?.input
+            ? zodToJsonSchema(action.schema.input(z))
+            : zodToJsonSchema(z.object({})),
+          output: action.schema?.output
+            ? zodToJsonSchema(action.schema.output(z))
+            : zodToJsonSchema(z.object({})),
+        } as ActionsServiceAction['schema'],
+      })),
+    };
+  }
+
+  async invoke(opts: {
+    id: string;
+    input?: JsonObject;
+    credentials?: BackstageCredentials;
+  }): Promise<{ output: JsonValue }> {
+    const action = this.actions.get(opts.id);
+
+    if (!action) {
+      const availableActionIds = Array.from(this.actions.keys()).join(', ');
+      throw new NotFoundError(
+        `Action "${opts.id}" not found, available actions: ${
+          availableActionIds ? `"${availableActionIds}"` : 'none'
+        }`,
+      );
+    }
+
+    const input = action.schema?.input
+      ? action.schema.input(z).safeParse(opts.input)
+      : ({ success: true, data: undefined } as const);
+
+    if (!input.success) {
+      throw new InputError(`Invalid input to action "${opts.id}"`, input.error);
+    }
+
+    try {
+      const result = await action.action({
+        input: input.data,
+        credentials: opts.credentials ?? mockCredentials.none(),
+        logger: this.logger,
+      });
+
+      const output = action.schema?.output
+        ? action.schema.output(z).safeParse(result?.output)
+        : ({ success: true, data: result?.output } as const);
+
+      if (!output.success) {
+        throw new InputError(
+          `Invalid output from action "${opts.id}"`,
+          output.error,
+        );
+      }
+
+      return { output: output.data };
+    } catch (error) {
+      throw new ForwardedError(
+        `Failed execution of action "${opts.id}"`,
+        error,
+      );
+    }
+  }
+
+  register<
+    TInputSchema extends AnyZodObject,
+    TOutputSchema extends AnyZodObject,
+  >(options: ActionsRegistryActionOptions<TInputSchema, TOutputSchema>): void {
+    // hardcode test: prefix similar to how the default actions registry does it
+    // and other places around the testing ecosystem:
+    // https://github.com/backstage/backstage/blob/a9219496d5c073aaa0b8caf32ece10455cf65e61/packages/backend-test-utils/src/next/services/mockServices.ts#L321
+    // https://github.com/backstage/backstage/blob/861f162b4a39117b824669d67a951ed1db142e3d/packages/backend-test-utils/src/next/wiring/ServiceFactoryTester.ts#L99
+    const id = `test:${options.name}`;
+
+    if (this.actions.has(id)) {
+      throw new Error(`Action with id "${id}" is already registered`);
+    }
+
+    this.actions.set(id, options);
+  }
+}
diff --git a/packages/backend-test-utils/src/next/services/index.ts b/packages/backend-test-utils/src/next/services/index.ts
index 7c3949e207..347c50aaee 100644
--- a/packages/backend-test-utils/src/next/services/index.ts
+++ b/packages/backend-test-utils/src/next/services/index.ts
@@ -15,3 +15,4 @@
  */
 export { mockServices, type ServiceMock } from './mockServices';
 export { mockCredentials } from './mockCredentials';
+export { type MockActionsRegistry } from './MockActionsRegistry';
diff --git a/packages/backend-test-utils/src/next/services/mockServices.ts b/packages/backend-test-utils/src/next/services/mockServices.ts
index 95f8b084c9..a44bf912e7 100644
--- a/packages/backend-test-utils/src/next/services/mockServices.ts
+++ b/packages/backend-test-utils/src/next/services/mockServices.ts
@@ -58,6 +58,7 @@ import { MockEventsService } from './MockEventsService';
 import { actionsServiceFactory } from '@backstage/backend-defaults/actions';
 import { actionsRegistryServiceFactory } from '@backstage/backend-defaults/actionsRegistry';
 import { MockPermissionsService } from './MockPermissionsService';
+import { MockActionsRegistry } from './MockActionsRegistry';
 
 /** @internal */
 function createLoggerMock() {
@@ -560,6 +561,14 @@ export namespace mockServices {
     }));
   }
 
+  export function actionsRegistry(options?: {
+    logger: LoggerService;
+  }): MockActionsRegistry {
+    return MockActionsRegistry.create({
+      logger: options?.logger ?? mockServices.logger.mock(),
+    });
+  }
+
   export namespace actionsRegistry {
     export const factory = () => actionsRegistryServiceFactory;
     export const mock = simpleMock(coreServices.actionsRegistry, () => ({
diff --git a/packages/backend-test-utils/src/next/wiring/TestBackend.ts b/packages/backend-test-utils/src/next/wiring/TestBackend.ts
index 20d02cf880..84042aedd8 100644
--- a/packages/backend-test-utils/src/next/wiring/TestBackend.ts
+++ b/packages/backend-test-utils/src/next/wiring/TestBackend.ts
@@ -84,6 +84,8 @@ export const defaultServiceFactories = [
   mockServices.userInfo.factory(),
   mockServices.urlReader.factory(),
   mockServices.events.factory(),
+  mockServices.actionsRegistry.factory(),
+  mockServices.actions.factory(),
 ];
 
 /**
diff --git a/yarn.lock b/yarn.lock
index b35d626c22..6bc788890f 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -3803,6 +3803,8 @@ __metadata:
     textextensions: "npm:^5.16.0"
     uuid: "npm:^11.0.0"
     yn: "npm:^4.0.0"
+    zod: "npm:^3.22.4"
+    zod-to-json-schema: "npm:^3.20.4"
   languageName: unknown
   linkType: soft