diff --git a/etc/redux-toolkit.api.md b/etc/redux-toolkit.api.md
index 401db6562e..ff4d4e41ff 100644
--- a/etc/redux-toolkit.api.md
+++ b/etc/redux-toolkit.api.md
@@ -13,6 +13,7 @@ import { DeepPartial } from 'redux';
 import { Dispatch } from 'redux';
 import { Draft } from 'immer';
 import { Middleware } from 'redux';
+import { MiddlewareAPI } from 'redux';
 import { OutputParametricSelector } from 'reselect';
 import { OutputSelector } from 'reselect';
 import { ParametricSelector } from 'reselect';
@@ -50,6 +51,17 @@ export interface ActionCreatorWithPreparedPayload<Args extends unknown[], P, T e
     (...args: Args): PayloadAction<P, T, M, E>;
 }
 
+// @alpha (undocumented)
+export type ActionListener<A extends AnyAction, S, D extends Dispatch<AnyAction>, O extends ActionListenerOptions> = (action: A, api: ActionListenerMiddlewareAPI<S, D, O>) => void;
+
+// @alpha (undocumented)
+export interface ActionListenerMiddlewareAPI<S, D extends Dispatch<AnyAction>, O extends ActionListenerOptions> extends MiddlewareAPI<D, S> {
+    // (undocumented)
+    stopPropagation: WhenFromOptions<O> extends 'before' ? () => void : undefined;
+    // (undocumented)
+    unsubscribe(): void;
+}
+
 // @public
 export interface ActionReducerMapBuilder<State> {
     addCase<ActionCreator extends TypedActionCreator<string>>(actionCreator: ActionCreator, reducer: CaseReducer<State, ReturnType<ActionCreator>>): ActionReducerMapBuilder<State>;
@@ -59,6 +71,16 @@ export interface ActionReducerMapBuilder<State> {
 // @public @deprecated
 export type Actions<T extends keyof any = string> = Record<T, Action>;
 
+// @alpha (undocumented)
+export const addListenerAction: BaseActionCreator<{
+    type: string;
+    listener: ActionListener<any, any, any, any>;
+    options: ActionListenerOptions;
+}, "actionListenerMiddleware/add", never, never> & {
+    <C extends TypedActionCreator<any>, S, D extends Dispatch<AnyAction>, O extends ActionListenerOptions>(actionCreator: C, listener: ActionListener<ReturnType<C>, S, D, O>, options?: O | undefined): AddListenerAction<ReturnType<C>, S, D, O>;
+    <S_1, D_1 extends Dispatch<AnyAction>, O_1 extends ActionListenerOptions>(type: string, listener: ActionListener<AnyAction, S_1, D_1, O_1>, options?: O_1 | undefined): AddListenerAction<AnyAction, S_1, D_1, O_1>;
+};
+
 // @public
 export type AsyncThunkAction<Returned, ThunkArg, ThunkApiConfig extends AsyncThunkConfig> = (dispatch: GetDispatch<ThunkApiConfig>, getState: () => GetState<ThunkApiConfig>, extra: GetExtra<ThunkApiConfig>) => Promise<PayloadAction<Returned, string, {
     arg: ThunkArg;
@@ -123,6 +145,18 @@ export function createAction<P = void, T extends string = string>(type: T): Payl
 // @public
 export function createAction<PA extends PrepareAction<any>, T extends string = string>(type: T, prepareAction: PA): PayloadActionCreator<ReturnType<PA>['payload'], T, PA>;
 
+// @alpha (undocumented)
+export function createActionListenerMiddleware<S, D extends Dispatch<AnyAction> = Dispatch>(): Middleware<(action: Action<"actionListenerMiddleware/add">) => () => void, S, D> & {
+    addListener: {
+        <C extends TypedActionCreator<any>, O extends ActionListenerOptions>(actionCreator: C, listener: ActionListener<ReturnType<C>, S, D, O>, options?: O | undefined): () => void;
+        <T extends string, O_1 extends ActionListenerOptions>(type: T, listener: ActionListener<Action<T>, S, D, O_1>, options?: O_1 | undefined): () => void;
+    };
+    removeListener: {
+        <C_1 extends TypedActionCreator<any>>(actionCreator: C_1, listener: ActionListener<ReturnType<C_1>, S, D, any>): boolean;
+        (type: string, listener: ActionListener<AnyAction, S, D, any>): boolean;
+    };
+} & WithMiddlewareType<Middleware<(action: Action<"actionListenerMiddleware/add">) => () => void, S, D>>;
+
 // @public (undocumented)
 export function createAsyncThunk<Returned, ThunkArg = void, ThunkApiConfig extends AsyncThunkConfig = {}>(typePrefix: string, payloadCreator: (arg: ThunkArg, thunkAPI: GetThunkAPI<ThunkApiConfig>) => Promise<Returned | RejectWithValue<GetRejectValue<ThunkApiConfig>>> | Returned | RejectWithValue<GetRejectValue<ThunkApiConfig>>, options?: AsyncThunkOptions<ThunkArg, ThunkApiConfig>): IsAny<ThunkArg, (arg: ThunkArg) => AsyncThunkAction<Returned, ThunkArg, ThunkApiConfig>, unknown extends ThunkArg ? (arg: ThunkArg) => AsyncThunkAction<Returned, ThunkArg, ThunkApiConfig> : [ThunkArg] extends [void] | [undefined] ? () => AsyncThunkAction<Returned, ThunkArg, ThunkApiConfig> : [void] extends [ThunkArg] ? (arg?: ThunkArg | undefined) => AsyncThunkAction<Returned, ThunkArg, ThunkApiConfig> : [undefined] extends [ThunkArg] ? (arg?: ThunkArg | undefined) => AsyncThunkAction<Returned, ThunkArg, ThunkApiConfig> : (arg: ThunkArg) => AsyncThunkAction<Returned, ThunkArg, ThunkApiConfig>> & {
     pending: ActionCreatorWithPreparedPayload<[string, ThunkArg], undefined, string, never, {
@@ -342,6 +376,15 @@ export type PrepareAction<P> = ((...args: any[]) => {
     error: any;
 });
 
+// @alpha (undocumented)
+export const removeListenerAction: BaseActionCreator<{
+    type: string;
+    listener: ActionListener<any, any, any, any>;
+}, "actionListenerMiddleware/remove", never, never> & {
+    <C extends TypedActionCreator<any>, S, D extends Dispatch<AnyAction>>(actionCreator: C, listener: ActionListener<ReturnType<C>, S, D, any>): RemoveListenerAction<ReturnType<C>, S, D>;
+    <S_1, D_1 extends Dispatch<AnyAction>>(type: string, listener: ActionListener<AnyAction, S_1, D_1, any>): RemoveListenerAction<AnyAction, S_1, D_1>;
+};
+
 export { Selector }
 
 // @public
diff --git a/src/createAction.ts b/src/createAction.ts
index 93558d7be6..ca3ffbac7a 100644
--- a/src/createAction.ts
+++ b/src/createAction.ts
@@ -81,7 +81,7 @@ export type _ActionCreatorWithPreparedPayload<
  *
  * @inheritdoc {redux#ActionCreator}
  */
-interface BaseActionCreator<P, T extends string, M = never, E = never> {
+export interface BaseActionCreator<P, T extends string, M = never, E = never> {
   type: T
   match(action: Action<unknown>): action is PayloadAction<P, T, M, E>
 }
diff --git a/src/createActionListenerMiddleware.test.ts b/src/createActionListenerMiddleware.test.ts
new file mode 100644
index 0000000000..b3bf831db0
--- /dev/null
+++ b/src/createActionListenerMiddleware.test.ts
@@ -0,0 +1,354 @@
+import { configureStore } from './configureStore'
+import {
+  createActionListenerMiddleware,
+  addListenerAction,
+  removeListenerAction,
+  When,
+  ActionListenerMiddlewareAPI
+} from './createActionListenerMiddleware'
+import { createAction } from './createAction'
+import { AnyAction } from 'redux'
+
+const middlewareApi = {
+  getState: expect.any(Function),
+  dispatch: expect.any(Function),
+  stopPropagation: expect.any(Function),
+  unsubscribe: expect.any(Function)
+}
+
+const noop = () => {}
+
+describe('createActionListenerMiddleware', () => {
+  let store = configureStore({
+    reducer: () => ({}),
+    middleware: [createActionListenerMiddleware()] as const
+  })
+  let reducer: jest.Mock
+  let middleware: ReturnType<typeof createActionListenerMiddleware>
+
+  const testAction1 = createAction<string>('testAction1')
+  type TestAction1 = ReturnType<typeof testAction1>
+  const testAction2 = createAction<string>('testAction2')
+
+  beforeEach(() => {
+    middleware = createActionListenerMiddleware()
+    reducer = jest.fn(() => ({}))
+    store = configureStore({
+      reducer,
+      middleware: [middleware] as const
+    })
+  })
+
+  test('directly subscribing', () => {
+    const listener = jest.fn((_: TestAction1) => {})
+
+    middleware.addListener(testAction1, listener)
+
+    store.dispatch(testAction1('a'))
+    store.dispatch(testAction2('b'))
+    store.dispatch(testAction1('c'))
+
+    expect(listener.mock.calls).toEqual([
+      [testAction1('a'), middlewareApi],
+      [testAction1('c'), middlewareApi]
+    ])
+  })
+
+  test('subscribing with the same listener will not make it trigger twice (like EventTarget.addEventListener())', () => {
+    const listener = jest.fn((_: TestAction1) => {})
+
+    middleware.addListener(testAction1, listener)
+    middleware.addListener(testAction1, listener)
+
+    store.dispatch(testAction1('a'))
+    store.dispatch(testAction2('b'))
+    store.dispatch(testAction1('c'))
+
+    expect(listener.mock.calls).toEqual([
+      [testAction1('a'), middlewareApi],
+      [testAction1('c'), middlewareApi]
+    ])
+  })
+
+  test('unsubscribing via callback', () => {
+    const listener = jest.fn((_: TestAction1) => {})
+
+    const unsubscribe = middleware.addListener(testAction1, listener)
+
+    store.dispatch(testAction1('a'))
+    unsubscribe()
+    store.dispatch(testAction2('b'))
+    store.dispatch(testAction1('c'))
+
+    expect(listener.mock.calls).toEqual([[testAction1('a'), middlewareApi]])
+  })
+
+  test('directly unsubscribing', () => {
+    const listener = jest.fn((_: TestAction1) => {})
+
+    middleware.addListener(testAction1, listener)
+
+    store.dispatch(testAction1('a'))
+
+    middleware.removeListener(testAction1, listener)
+    store.dispatch(testAction2('b'))
+    store.dispatch(testAction1('c'))
+
+    expect(listener.mock.calls).toEqual([[testAction1('a'), middlewareApi]])
+  })
+
+  test('unsubscribing without any subscriptions does not trigger an error', () => {
+    middleware.removeListener(testAction1, noop)
+  })
+
+  test('subscribing via action', () => {
+    const listener = jest.fn((_: TestAction1) => {})
+
+    store.dispatch(addListenerAction(testAction1, listener))
+
+    store.dispatch(testAction1('a'))
+    store.dispatch(testAction2('b'))
+    store.dispatch(testAction1('c'))
+
+    expect(listener.mock.calls).toEqual([
+      [testAction1('a'), middlewareApi],
+      [testAction1('c'), middlewareApi]
+    ])
+  })
+
+  test('unsubscribing via callback from dispatch', () => {
+    const listener = jest.fn((_: TestAction1) => {})
+
+    const unsubscribe = store.dispatch(addListenerAction(testAction1, listener))
+
+    store.dispatch(testAction1('a'))
+    unsubscribe()
+    store.dispatch(testAction2('b'))
+    store.dispatch(testAction1('c'))
+
+    expect(listener.mock.calls).toEqual([[testAction1('a'), middlewareApi]])
+  })
+
+  test('unsubscribing via action', () => {
+    const listener = jest.fn((_: TestAction1) => {})
+
+    middleware.addListener(testAction1, listener)
+
+    store.dispatch(testAction1('a'))
+
+    store.dispatch(removeListenerAction(testAction1, listener))
+    store.dispatch(testAction2('b'))
+    store.dispatch(testAction1('c'))
+
+    expect(listener.mock.calls).toEqual([[testAction1('a'), middlewareApi]])
+  })
+
+  const unforwaredActions: [string, AnyAction][] = [
+    ['addListenerAction', addListenerAction(testAction1, noop)],
+    ['removeListenerAction', removeListenerAction(testAction1, noop)]
+  ]
+  test.each(unforwaredActions)(
+    '"%s" is not forwarded to the reducer',
+    (_, action) => {
+      reducer.mockClear()
+
+      store.dispatch(testAction1('a'))
+      store.dispatch(action)
+      store.dispatch(testAction2('b'))
+
+      expect(reducer.mock.calls).toEqual([
+        [{}, testAction1('a')],
+        [{}, testAction2('b')]
+      ])
+    }
+  )
+
+  test('"can unsubscribe via middleware api', () => {
+    const listener = jest.fn(
+      (
+        action: TestAction1,
+        api: ActionListenerMiddlewareAPI<any, any, any>
+      ) => {
+        if (action.payload === 'b') {
+          api.unsubscribe()
+        }
+      }
+    )
+
+    middleware.addListener(testAction1, listener)
+
+    store.dispatch(testAction1('a'))
+    store.dispatch(testAction1('b'))
+    store.dispatch(testAction1('c'))
+
+    expect(listener.mock.calls).toEqual([
+      [testAction1('a'), middlewareApi],
+      [testAction1('b'), middlewareApi]
+    ])
+  })
+
+  const whenMap: [When, string, string][] = [
+    [undefined, 'reducer', 'listener'],
+    ['before', 'listener', 'reducer'],
+    ['after', 'reducer', 'listener']
+  ]
+  test.each(whenMap)(
+    'with "when" set to %s, %s runs before %s',
+    (when, _, shouldRunLast) => {
+      let whoRanLast = ''
+
+      reducer.mockClear()
+      reducer.mockImplementationOnce(() => {
+        whoRanLast = 'reducer'
+      })
+      const listener = jest.fn(() => {
+        whoRanLast = 'listener'
+      })
+
+      middleware.addListener(testAction1, listener, when ? { when } : {})
+
+      store.dispatch(testAction1('a'))
+      expect(reducer).toHaveBeenCalledTimes(1)
+      expect(listener).toHaveBeenCalledTimes(1)
+      expect(whoRanLast).toBe(shouldRunLast)
+    }
+  )
+
+  test('mixing "before" and "after"', () => {
+    const calls: Function[] = []
+    function before1() {
+      calls.push(before1)
+    }
+    function before2() {
+      calls.push(before2)
+    }
+    function after1() {
+      calls.push(after1)
+    }
+    function after2() {
+      calls.push(after2)
+    }
+
+    middleware.addListener(testAction1, before1, { when: 'before' })
+    middleware.addListener(testAction1, before2, { when: 'before' })
+    middleware.addListener(testAction1, after1, { when: 'after' })
+    middleware.addListener(testAction1, after2, { when: 'after' })
+
+    store.dispatch(testAction1('a'))
+    store.dispatch(testAction2('a'))
+
+    expect(calls).toEqual([before1, before2, after1, after2])
+  })
+
+  test('mixing "before" and "after" with stopPropagation', () => {
+    const calls: Function[] = []
+    function before1() {
+      calls.push(before1)
+    }
+    function before2(_: any, api: any) {
+      calls.push(before2)
+      api.stopPropagation()
+    }
+    function before3() {
+      calls.push(before3)
+    }
+    function after1() {
+      calls.push(after1)
+    }
+    function after2() {
+      calls.push(after2)
+    }
+
+    middleware.addListener(testAction1, before1, { when: 'before' })
+    middleware.addListener(testAction1, before2, { when: 'before' })
+    middleware.addListener(testAction1, before3, { when: 'before' })
+    middleware.addListener(testAction1, after1, { when: 'after' })
+    middleware.addListener(testAction1, after2, { when: 'after' })
+
+    store.dispatch(testAction1('a'))
+    store.dispatch(testAction2('a'))
+
+    expect(calls).toEqual([before1, before2])
+  })
+
+  test('by default, actions are forwarded to the store', () => {
+    reducer.mockClear()
+
+    const listener = jest.fn((_: TestAction1) => {})
+
+    middleware.addListener(testAction1, listener)
+
+    store.dispatch(testAction1('a'))
+
+    expect(reducer.mock.calls).toEqual([[{}, testAction1('a')]])
+  })
+
+  test('calling `api.stopPropagation` in the listeners prevents actions from being forwarded to the store', () => {
+    reducer.mockClear()
+
+    middleware.addListener(
+      testAction1,
+      (action: TestAction1, api) => {
+        if (action.payload === 'b') {
+          api.stopPropagation()
+        }
+      },
+      { when: 'before' }
+    )
+
+    store.dispatch(testAction1('a'))
+    store.dispatch(testAction1('b'))
+    store.dispatch(testAction1('c'))
+
+    expect(reducer.mock.calls).toEqual([
+      [{}, testAction1('a')],
+      [{}, testAction1('c')]
+    ])
+  })
+
+  test('calling `api.stopPropagation` with `when` set to "after" causes an error to be thrown', () => {
+    reducer.mockClear()
+
+    middleware.addListener(
+      testAction1,
+      (action: TestAction1, api) => {
+        if (action.payload === 'b') {
+          // @ts-ignore TypeScript would already prevent this from being called with "after"
+          api.stopPropagation()
+        }
+      },
+      { when: 'after' }
+    )
+
+    store.dispatch(testAction1('a'))
+    expect(() => {
+      store.dispatch(testAction1('b'))
+    }).toThrowErrorMatchingInlineSnapshot(
+      `"stopPropagation can only be called by action listeners with the \`when\` option set to \\"before\\""`
+    )
+  })
+
+  test('calling `api.stopPropagation` asynchronously causes an error to be thrown', finish => {
+    reducer.mockClear()
+
+    middleware.addListener(
+      testAction1,
+      (action: TestAction1, api) => {
+        if (action.payload === 'b') {
+          setTimeout(() => {
+            expect(() => {
+              api.stopPropagation()
+            }).toThrowErrorMatchingInlineSnapshot(
+              `"stopPropagation can only be called synchronously"`
+            )
+            finish()
+          })
+        }
+      },
+      { when: 'before' }
+    )
+
+    store.dispatch(testAction1('a'))
+    store.dispatch(testAction1('b'))
+  })
+})
diff --git a/src/createActionListenerMiddleware.ts b/src/createActionListenerMiddleware.ts
new file mode 100644
index 0000000000..f554086337
--- /dev/null
+++ b/src/createActionListenerMiddleware.ts
@@ -0,0 +1,332 @@
+import { Middleware, Dispatch, AnyAction, MiddlewareAPI, Action } from 'redux'
+import { TypedActionCreator } from './mapBuilders'
+import { createAction, BaseActionCreator } from './createAction'
+import { WithMiddlewareType } from './tsHelpers'
+
+export type When = 'before' | 'after' | undefined
+type WhenFromOptions<
+  O extends ActionListenerOptions
+> = O extends ActionListenerOptions ? O['when'] : never
+
+/**
+ * @alpha
+ */
+export interface ActionListenerMiddlewareAPI<
+  S,
+  D extends Dispatch<AnyAction>,
+  O extends ActionListenerOptions
+> extends MiddlewareAPI<D, S> {
+  stopPropagation: WhenFromOptions<O> extends 'before' ? () => void : undefined
+  unsubscribe(): void
+}
+
+/**
+ * @alpha
+ */
+export type ActionListener<
+  A extends AnyAction,
+  S,
+  D extends Dispatch<AnyAction>,
+  O extends ActionListenerOptions
+> = (action: A, api: ActionListenerMiddlewareAPI<S, D, O>) => void
+
+export interface ActionListenerOptions {
+  /**
+   * Determines if the listener runs 'before' or 'after' the reducers have been called.
+   * If set to 'before', calling `api.stopPropagation()` from the listener becomes possible.
+   * Defaults to 'before'.
+   */
+  when?: When
+}
+
+export interface AddListenerAction<
+  A extends AnyAction,
+  S,
+  D extends Dispatch<AnyAction>,
+  O extends ActionListenerOptions
+> {
+  type: 'actionListenerMiddleware/add'
+  payload: {
+    type: string
+    listener: ActionListener<A, S, D, O>
+    options?: O
+  }
+}
+
+/**
+ * @alpha
+ */
+export const addListenerAction = createAction(
+  'actionListenerMiddleware/add',
+  function prepare(
+    typeOrActionCreator: string | TypedActionCreator<string>,
+    listener: ActionListener<any, any, any, any>,
+    options?: ActionListenerOptions
+  ) {
+    const type =
+      typeof typeOrActionCreator === 'string'
+        ? typeOrActionCreator
+        : (typeOrActionCreator as TypedActionCreator<string>).type
+
+    return {
+      payload: {
+        type,
+        listener,
+        options
+      }
+    }
+  }
+) as BaseActionCreator<
+  {
+    type: string
+    listener: ActionListener<any, any, any, any>
+    options: ActionListenerOptions
+  },
+  'actionListenerMiddleware/add'
+> & {
+  <
+    C extends TypedActionCreator<any>,
+    S,
+    D extends Dispatch,
+    O extends ActionListenerOptions
+  >(
+    actionCreator: C,
+    listener: ActionListener<ReturnType<C>, S, D, O>,
+    options?: O
+  ): AddListenerAction<ReturnType<C>, S, D, O>
+
+  <S, D extends Dispatch, O extends ActionListenerOptions>(
+    type: string,
+    listener: ActionListener<AnyAction, S, D, O>,
+    options?: O
+  ): AddListenerAction<AnyAction, S, D, O>
+}
+
+interface RemoveListenerAction<
+  A extends AnyAction,
+  S,
+  D extends Dispatch<AnyAction>
+> {
+  type: 'actionListenerMiddleware/remove'
+  payload: {
+    type: string
+    listener: ActionListener<A, S, D, any>
+  }
+}
+
+/**
+ * @alpha
+ */
+export const removeListenerAction = createAction(
+  'actionListenerMiddleware/remove',
+  function prepare(
+    typeOrActionCreator: string | TypedActionCreator<string>,
+    listener: ActionListener<any, any, any, any>
+  ) {
+    const type =
+      typeof typeOrActionCreator === 'string'
+        ? typeOrActionCreator
+        : (typeOrActionCreator as TypedActionCreator<string>).type
+
+    return {
+      payload: {
+        type,
+        listener
+      }
+    }
+  }
+) as BaseActionCreator<
+  { type: string; listener: ActionListener<any, any, any, any> },
+  'actionListenerMiddleware/remove'
+> & {
+  <C extends TypedActionCreator<any>, S, D extends Dispatch>(
+    actionCreator: C,
+    listener: ActionListener<ReturnType<C>, S, D, any>
+  ): RemoveListenerAction<ReturnType<C>, S, D>
+
+  <S, D extends Dispatch>(
+    type: string,
+    listener: ActionListener<AnyAction, S, D, any>
+  ): RemoveListenerAction<AnyAction, S, D>
+}
+
+/**
+ * @alpha
+ */
+export function createActionListenerMiddleware<
+  S,
+  D extends Dispatch<AnyAction> = Dispatch
+>() {
+  type ListenerEntry = ActionListenerOptions & {
+    listener: ActionListener<any, S, D, any>
+  }
+
+  const listenerMap: Record<string, Set<ListenerEntry> | undefined> = {}
+  const middleware: Middleware<
+    {
+      (action: Action<'actionListenerMiddleware/add'>): Unsubscribe
+    },
+    S,
+    D
+  > = api => next => action => {
+    if (addListenerAction.match(action)) {
+      const unsubscribe = addListener(
+        action.payload.type,
+        action.payload.listener,
+        action.payload.options
+      )
+
+      return unsubscribe
+    }
+    if (removeListenerAction.match(action)) {
+      removeListener(action.payload.type, action.payload.listener)
+
+      return
+    }
+
+    const listeners = listenerMap[action.type]
+    if (listeners) {
+      const defaultWhen = 'after'
+      let result: unknown
+      for (const phase of ['before', 'after'] as const) {
+        for (const entry of listeners) {
+          if (phase !== (entry.when || defaultWhen)) {
+            continue
+          }
+          let stoppedPropagation = false
+          let currentPhase = phase
+          let synchronousListenerFinished = false
+          entry.listener(action, {
+            ...api,
+            stopPropagation() {
+              if (currentPhase === 'before') {
+                if (!synchronousListenerFinished) {
+                  stoppedPropagation = true
+                } else {
+                  throw new Error(
+                    'stopPropagation can only be called synchronously'
+                  )
+                }
+              } else {
+                throw new Error(
+                  'stopPropagation can only be called by action listeners with the `when` option set to "before"'
+                )
+              }
+            },
+            unsubscribe() {
+              listeners.delete(entry)
+            }
+          })
+          synchronousListenerFinished = true
+          if (stoppedPropagation) {
+            return action
+          }
+        }
+        if (phase === 'before') {
+          result = next(action)
+        } else {
+          return result
+        }
+      }
+    }
+    return next(action)
+  }
+
+  type Unsubscribe = () => void
+
+  function addListener<
+    C extends TypedActionCreator<any>,
+    O extends ActionListenerOptions
+  >(
+    actionCreator: C,
+    listener: ActionListener<ReturnType<C>, S, D, O>,
+    options?: O
+  ): Unsubscribe
+  function addListener<T extends string, O extends ActionListenerOptions>(
+    type: T,
+    listener: ActionListener<Action<T>, S, D, O>,
+    options?: O
+  ): Unsubscribe
+  function addListener(
+    typeOrActionCreator: string | TypedActionCreator<any>,
+    listener: ActionListener<AnyAction, S, D, any>,
+    options?: ActionListenerOptions
+  ): Unsubscribe {
+    const type =
+      typeof typeOrActionCreator === 'string'
+        ? typeOrActionCreator
+        : typeOrActionCreator.type
+
+    const listeners = getListenerMap(type)
+
+    let entry = findListenerEntry(listeners, listener)
+
+    if (!entry) {
+      entry = {
+        ...options,
+        listener
+      }
+
+      listeners.add(entry)
+    }
+
+    return () => listeners.delete(entry!)
+  }
+
+  function getListenerMap(type: string) {
+    if (!listenerMap[type]) {
+      listenerMap[type] = new Set()
+    }
+    return listenerMap[type]!
+  }
+
+  function removeListener<C extends TypedActionCreator<any>>(
+    actionCreator: C,
+    listener: ActionListener<ReturnType<C>, S, D, any>
+  ): boolean
+  function removeListener(
+    type: string,
+    listener: ActionListener<AnyAction, S, D, any>
+  ): boolean
+  function removeListener(
+    typeOrActionCreator: string | TypedActionCreator<any>,
+    listener: ActionListener<AnyAction, S, D, any>
+  ): boolean {
+    const type =
+      typeof typeOrActionCreator === 'string'
+        ? typeOrActionCreator
+        : typeOrActionCreator.type
+
+    const listeners = listenerMap[type]
+
+    if (!listeners) {
+      return false
+    }
+
+    let entry = findListenerEntry(listeners, listener)
+
+    if (!entry) {
+      return false
+    }
+
+    listeners.delete(entry)
+    return true
+  }
+
+  function findListenerEntry(
+    entries: Set<ListenerEntry>,
+    listener: Function
+  ): ListenerEntry | undefined {
+    for (const entry of entries) {
+      if (entry.listener === listener) {
+        return entry
+      }
+    }
+  }
+
+  return Object.assign(
+    middleware,
+    { addListener, removeListener },
+    {} as WithMiddlewareType<typeof middleware>
+  )
+}
diff --git a/src/index.ts b/src/index.ts
index f4a1843d92..0cb8290ab9 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -104,4 +104,12 @@ export {
   SerializedError
 } from './createAsyncThunk'
 
+export {
+  createActionListenerMiddleware,
+  addListenerAction,
+  removeListenerAction,
+  ActionListener,
+  ActionListenerMiddlewareAPI
+} from './createActionListenerMiddleware'
+
 export { nanoid } from './nanoid'
diff --git a/src/tsHelpers.ts b/src/tsHelpers.ts
index d624cd359b..5899565d98 100644
--- a/src/tsHelpers.ts
+++ b/src/tsHelpers.ts
@@ -65,6 +65,11 @@ export type IsUnknownOrNonInferrable<T, True, False> = AtLeastTS35<
   IsEmptyObj<T, True, IsUnknown<T, True, False>>
 >
 
+const declaredMiddlewareType: unique symbol = undefined as any
+export type WithMiddlewareType<T extends Middleware<any, any, any>> = {
+  [declaredMiddlewareType]: T
+}
+
 /**
  * Combines all dispatch signatures of all middlewares in the array `M` into
  * one intersected dispatch signature.
@@ -72,7 +77,19 @@ export type IsUnknownOrNonInferrable<T, True, False> = AtLeastTS35<
 export type DispatchForMiddlewares<M> = M extends ReadonlyArray<any>
   ? UnionToIntersection<
       M[number] extends infer MiddlewareValues
-        ? MiddlewareValues extends Middleware<infer DispatchExt, any, any>
+        ? MiddlewareValues extends WithMiddlewareType<
+            infer DeclaredMiddlewareType
+          >
+          ? DeclaredMiddlewareType extends Middleware<
+              infer DispatchExt,
+              any,
+              any
+            >
+            ? DispatchExt extends Function
+              ? DispatchExt
+              : never
+            : never
+          : MiddlewareValues extends Middleware<infer DispatchExt, any, any>
           ? DispatchExt extends Function
             ? DispatchExt
             : never