diff --git a/packages/react-query/src/createTRPCReact.tsx b/packages/react-query/src/createTRPCReact.tsx
index b3416d8f051..d422c952b52 100644
--- a/packages/react-query/src/createTRPCReact.tsx
+++ b/packages/react-query/src/createTRPCReact.tsx
@@ -15,6 +15,7 @@ import {
   inferTransformedSubscriptionOutput,
 } from '@trpc/server/shared';
 import { useMemo } from 'react';
+import { QueryKey, QueryType } from './internals/getArrayQueryKey';
 import { TRPCUseQueries } from './internals/useQueries';
 import {
   CreateReactUtilsProxy,
@@ -48,6 +49,15 @@ export type DecorateProcedure<
   TPath extends string,
 > = TProcedure extends AnyQueryProcedure
   ? {
+      /**
+       * Method to extract the query key for a procedure
+       * @param type - defaults to `any`
+       * @link https://trpc.io/docs/useContext#-the-function-i-want-isnt-here
+       */
+      getQueryKey: (
+        input: inferProcedureInput<TProcedure>,
+        type?: QueryType,
+      ) => QueryKey;
       useQuery: <
         TQueryFnData = inferTransformedProcedureOutput<TProcedure>,
         TData = inferTransformedProcedureOutput<TProcedure>,
@@ -164,7 +174,9 @@ export type DecoratedProcedureRecord<
   TPath extends string = '',
 > = {
   [TKey in keyof TProcedures]: TProcedures[TKey] extends AnyRouter
-    ? DecoratedProcedureRecord<
+    ? {
+        getQueryKey: () => QueryKey;
+      } & DecoratedProcedureRecord<
         TProcedures[TKey]['_def']['record'],
         TFlags,
         `${TPath}${TKey & string}.`
diff --git a/packages/react-query/src/internals/context.tsx b/packages/react-query/src/internals/context.tsx
index fbe0b0e7e50..3474dfab68c 100644
--- a/packages/react-query/src/internals/context.tsx
+++ b/packages/react-query/src/internals/context.tsx
@@ -160,13 +160,6 @@ export interface TRPCContextState<
     filters?: InvalidateQueryFilters,
     options?: InvalidateOptions,
   ): Promise<void>;
-  /**
-   * @link https://react-query.tanstack.com/guides/query-invalidation
-   */
-  invalidateQueries(
-    filters?: InvalidateQueryFilters,
-    options?: InvalidateOptions,
-  ): Promise<void>;
 
   /**
    * @link https://react-query.tanstack.com/reference/QueryClient#queryclientresetqueries
diff --git a/packages/react-query/src/internals/getArrayQueryKey.test.ts b/packages/react-query/src/internals/getArrayQueryKey.test.ts
index 98c1496d107..432f1854693 100644
--- a/packages/react-query/src/internals/getArrayQueryKey.test.ts
+++ b/packages/react-query/src/internals/getArrayQueryKey.test.ts
@@ -1,6 +1,17 @@
 import { getArrayQueryKey } from './getArrayQueryKey';
 
 test('getArrayQueryKey', () => {
+  // empty path should not nest an extra array
+  expect(getArrayQueryKey('', 'any')).toMatchInlineSnapshot(`Array []`);
+
+  // should not nest an empty object
+  expect(getArrayQueryKey('foo', 'any')).toMatchInlineSnapshot(`
+    Array [
+      Array [
+        "foo",
+      ],
+    ]
+  `);
   expect(getArrayQueryKey('foo', 'query')).toMatchInlineSnapshot(`
     Array [
       Array [
diff --git a/packages/react-query/src/internals/getArrayQueryKey.ts b/packages/react-query/src/internals/getArrayQueryKey.ts
index 850227fec3c..ab0bf8804bd 100644
--- a/packages/react-query/src/internals/getArrayQueryKey.ts
+++ b/packages/react-query/src/internals/getArrayQueryKey.ts
@@ -1,16 +1,21 @@
 export type QueryType = 'query' | 'infinite' | 'any';
 
+export type QueryKey = [
+  string[],
+  { input?: unknown; type?: Exclude<QueryType, 'any'> }?,
+];
+
 /**
  * To allow easy interactions with groups of related queries, such as
  * invalidating all queries of a router, we use an array as the path when
  * storing in tanstack query. This function converts from the `.` separated
  * path passed around internally by both the legacy and proxy implementation.
  * https://github.com/trpc/trpc/issues/2611
- */
+ **/
 export function getArrayQueryKey(
   queryKey: string | [string] | [string, ...unknown[]] | unknown[],
   type: QueryType,
-): [string[], { input?: unknown; type?: Exclude<QueryType, 'any'> }] {
+): QueryKey {
   const queryKeyArrayed = Array.isArray(queryKey) ? queryKey : [queryKey];
   const [path, input] = queryKeyArrayed;
 
@@ -20,6 +25,10 @@ export function getArrayQueryKey(
   // Construct a query key that is easy to destructure and flexible for
   // partial selecting etc.
   // https://github.com/trpc/trpc/issues/3128
+  if (!input && (!type || type === 'any'))
+    // for `utils.invalidate()` to match all queries (including vanilla react-query)
+    // we don't want nested array if path is empty, i.e. `[]` instead of `[[]]`
+    return arrayPath.length ? [arrayPath] : ([] as unknown as QueryKey);
   return [
     arrayPath,
     {
diff --git a/packages/react-query/src/internals/getQueryKey.ts b/packages/react-query/src/internals/getQueryKey.ts
index 51a8da89e09..87fda4b5bfe 100644
--- a/packages/react-query/src/internals/getQueryKey.ts
+++ b/packages/react-query/src/internals/getQueryKey.ts
@@ -6,5 +6,6 @@ export function getQueryKey(
   path: string,
   input: unknown,
 ): [string] | [string, unknown] {
-  return input === undefined ? [path] : [path, input];
+  if (path.length) return input === undefined ? [path] : [path, input];
+  return [] as unknown as [string];
 }
diff --git a/packages/react-query/src/shared/proxy/decorationProxy.ts b/packages/react-query/src/shared/proxy/decorationProxy.ts
index 2cdec3eca0c..106b67dc913 100644
--- a/packages/react-query/src/shared/proxy/decorationProxy.ts
+++ b/packages/react-query/src/shared/proxy/decorationProxy.ts
@@ -1,5 +1,6 @@
 import { AnyRouter } from '@trpc/server';
 import { createRecursiveProxy } from '@trpc/server/shared';
+import { getArrayQueryKey } from '../../internals/getArrayQueryKey';
 import { getQueryKey } from '../../internals/getQueryKey';
 import { CreateReactQueryHooks } from '../hooks/createHooksInternal';
 
@@ -28,6 +29,12 @@ export function createReactProxyDecoration<
     const [input, ...rest] = args;
 
     const queryKey = getQueryKey(path, input);
+
+    // Expose queryKey helper
+    if (lastArg === 'getQueryKey') {
+      return getArrayQueryKey(queryKey, (rest[0] as any) ?? 'any');
+    }
+
     if (lastArg.startsWith('useSuspense')) {
       const opts = rest[0] || {};
       const fn =
diff --git a/packages/react-query/src/shared/proxy/utilsProxy.ts b/packages/react-query/src/shared/proxy/utilsProxy.ts
index 686f09be097..3b554752282 100644
--- a/packages/react-query/src/shared/proxy/utilsProxy.ts
+++ b/packages/react-query/src/shared/proxy/utilsProxy.ts
@@ -171,6 +171,7 @@ type DecorateRouter = {
    * @link https://react-query.tanstack.com/guides/query-invalidation
    */
   invalidate(
+    input?: undefined,
     filters?: InvalidateQueryFilters,
     options?: InvalidateOptions,
   ): Promise<void>;
diff --git a/packages/tests/server/interop/react/invalidateQueries.test.tsx b/packages/tests/server/interop/react/invalidateQueries.test.tsx
index e2937687184..80cca9838fe 100644
--- a/packages/tests/server/interop/react/invalidateQueries.test.tsx
+++ b/packages/tests/server/interop/react/invalidateQueries.test.tsx
@@ -192,12 +192,15 @@ describe('invalidateQueries()', () => {
           <button
             data-testid="invalidate-5-predicate"
             onClick={() => {
-              utils.invalidateQueries({
+              utils.invalidateQueries(undefined, {
                 predicate(opts) {
                   const { queryKey } = opts;
-                  const [path, input] = queryKey;
+                  const [path, rest] = queryKey;
 
-                  return path === 'count' && input === 'test';
+                  return (
+                    JSON.stringify(path) === JSON.stringify(['count']) &&
+                    (rest as any)?.input === 'test'
+                  );
                 },
               });
             }}
diff --git a/packages/tests/server/react/getQueryKey.test.tsx b/packages/tests/server/react/getQueryKey.test.tsx
new file mode 100644
index 00000000000..d2059ce51b6
--- /dev/null
+++ b/packages/tests/server/react/getQueryKey.test.tsx
@@ -0,0 +1,178 @@
+import { getServerAndReactClient } from './__reactHelpers';
+import { useIsFetching } from '@tanstack/react-query';
+import { render, waitFor } from '@testing-library/react';
+import { initTRPC } from '@trpc/server';
+import { konn } from 'konn/dist-cjs';
+import React from 'react';
+import { z } from 'zod';
+
+type Post = {
+  id: number;
+  text: string;
+};
+
+const defaultPost = { id: 0, text: 'new post' };
+const ctx = konn()
+  .beforeEach(() => {
+    const t = initTRPC.create();
+
+    const posts: Post[] = [defaultPost];
+
+    const appRouter = t.router({
+      post: t.router({
+        byId: t.procedure
+          .input(
+            z.object({
+              id: z.number(),
+            }),
+          )
+          .query(({ input }) => posts.find((post) => post.id === input.id)),
+        all: t.procedure.query(() => posts),
+      }),
+    });
+
+    return getServerAndReactClient(appRouter);
+  })
+  .afterEach(async (ctx) => {
+    await ctx?.close?.();
+  })
+  .done();
+
+describe('getQueryKeys', () => {
+  test('no input', async () => {
+    const { proxy, App } = ctx;
+
+    function MyComponent() {
+      const happy1 = proxy.post.all.getQueryKey(undefined, 'query');
+      const happy2 = proxy.post.all.getQueryKey();
+
+      // @ts-expect-error - post.all has no input
+      const sad = proxy.post.all.getQueryKey('foo');
+
+      return (
+        <>
+          <pre data-testid="qKey1">{JSON.stringify(happy1)}</pre>
+          <pre data-testid="qKey2">{JSON.stringify(happy2)}</pre>
+        </>
+      );
+    }
+
+    const utils = render(
+      <App>
+        <MyComponent />
+      </App>,
+    );
+
+    await waitFor(() => {
+      expect(utils.getByTestId('qKey1')).toHaveTextContent(
+        JSON.stringify([['post', 'all'], { type: 'query' }]),
+      );
+      expect(utils.getByTestId('qKey2')).toHaveTextContent(
+        JSON.stringify([['post', 'all']]),
+      );
+    });
+  });
+
+  test('with input', async () => {
+    const { proxy, App } = ctx;
+
+    function MyComponent() {
+      const happy1 = proxy.post.byId.getQueryKey({ id: 1 }, 'query');
+
+      // doesn't really make sense but should still work
+      const happyIsh = proxy.post.byId.getQueryKey({ id: 1 });
+
+      // @ts-expect-error - post.byId has required input
+      const sad = proxy.post.byId.getQueryKey(undefined, 'query');
+
+      return (
+        <>
+          <pre data-testid="qKey1">{JSON.stringify(happy1)}</pre>
+          <pre data-testid="qKey2">{JSON.stringify(happyIsh)}</pre>
+        </>
+      );
+    }
+
+    const utils = render(
+      <App>
+        <MyComponent />
+      </App>,
+    );
+
+    await waitFor(() => {
+      expect(utils.getByTestId('qKey1')).toHaveTextContent(
+        JSON.stringify([['post', 'byId'], { input: { id: 1 }, type: 'query' }]),
+      );
+      expect(utils.getByTestId('qKey2')).toHaveTextContent(
+        JSON.stringify([['post', 'byId'], { input: { id: 1 } }]),
+      );
+    });
+  });
+
+  test('on router', async () => {
+    const { proxy, App } = ctx;
+
+    function MyComponent() {
+      const happy = proxy.post.getQueryKey();
+
+      // @ts-expect-error - router has no input
+      const sad = proxy.post.getQueryKey('foo');
+
+      return (
+        <div>
+          <pre data-testid="qKey">{JSON.stringify(happy)}</pre>
+        </div>
+      );
+    }
+
+    const utils = render(
+      <App>
+        <MyComponent />
+      </App>,
+    );
+
+    await waitFor(() => {
+      expect(utils.getByTestId('qKey')).toHaveTextContent(
+        JSON.stringify([['post']]),
+      );
+    });
+  });
+
+  test('forwarded to a real method', async () => {
+    const { proxy, App } = ctx;
+
+    function MyComponent() {
+      proxy.post.all.useQuery();
+
+      const qKey = proxy.post.all.getQueryKey(undefined, 'query');
+      const isFetching = useIsFetching(qKey);
+
+      return <div>{isFetching}</div>;
+    }
+
+    const utils = render(
+      <App>
+        <MyComponent />
+      </App>,
+    );
+
+    // should be fetching initially, and then not
+    expect(utils.container).toHaveTextContent('1');
+    await waitFor(() => {
+      expect(utils.container).toHaveTextContent('0');
+    });
+  });
+
+  test('outside of the react context', () => {
+    const { proxy } = ctx;
+
+    const all = proxy.post.all.getQueryKey(undefined, 'query');
+    const byId = proxy.post.byId.getQueryKey({ id: 1 }, 'query');
+
+    expect(all).toEqual([['post', 'all'], { type: 'query' }]);
+    expect(byId).toEqual([
+      ['post', 'byId'],
+      { input: { id: 1 }, type: 'query' },
+    ]);
+  });
+});
diff --git a/packages/tests/server/react/invalidateQueries.test.tsx b/packages/tests/server/react/invalidateQueries.test.tsx
index 2e89af23c07..62a9c096721 100644
--- a/packages/tests/server/react/invalidateQueries.test.tsx
+++ b/packages/tests/server/react/invalidateQueries.test.tsx
@@ -186,7 +186,7 @@ describe('invalidateQueries()', () => {
           <button
             data-testid="invalidate-4-predicate"
             onClick={() => {
-              utils.invalidate({
+              utils.invalidate(undefined, {
                 predicate(opts) {
                   const { queryKey } = opts;
                   const [path, input] = queryKey;
diff --git a/packages/tests/server/react/useContext.test.tsx b/packages/tests/server/react/useContext.test.tsx
index fa941c4ec0a..4fe474d0566 100644
--- a/packages/tests/server/react/useContext.test.tsx
+++ b/packages/tests/server/react/useContext.test.tsx
@@ -61,6 +61,10 @@ const ctx = konn()
             return newPost;
           }),
       }),
+
+      greeting: t.router({
+        get: t.procedure.query(() => 'hello'),
+      }),
     });
 
     return getServerAndReactClient(appRouter);
diff --git a/packages/tests/server/regression/issue-3455-56-invalidate-queries.test.tsx b/packages/tests/server/regression/issue-3455-56-invalidate-queries.test.tsx
new file mode 100644
index 00000000000..ed0d974a4c6
--- /dev/null
+++ b/packages/tests/server/regression/issue-3455-56-invalidate-queries.test.tsx
@@ -0,0 +1,218 @@
+import { getServerAndReactClient } from '../react/__reactHelpers';
+import { useQuery } from '@tanstack/react-query';
+import { render, waitFor } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { initTRPC } from '@trpc/server/src';
+import { konn } from 'konn';
+import React from 'react';
+import { z } from 'zod';
+
+const post = { id: 1, text: 'foo' };
+const posts = [post];
+
+const ctx = konn()
+  .beforeEach(() => {
+    const t = initTRPC.create();
+    const appRouter = t.router({
+      post: t.router({
+        byId: t.procedure
+          .input(
+            z.object({
+              id: z.number(),
+            }),
+          )
+          .query(({ input }) => posts.find((post) => post.id === input.id)),
+        all: t.procedure.query(() => posts),
+      }),
+
+      greeting: t.procedure.query(async () => {
+        await new Promise((res) => setTimeout(res, 500));
+        return 'Hello trpc';
+      }),
+    });
+    return getServerAndReactClient(appRouter);
+  })
+  .afterEach(async (ctx) => {
+    await ctx?.close?.();
+  })
+  .done();
+
+test('invalidate with filter', async () => {
+  const { proxy, App } = ctx;
+  const greetingSpy = jest.fn();
+  const postSpy = jest.fn();
+
+  function MyComponent() {
+    const allPosts = proxy.post.all.useQuery(undefined, {
+      onSuccess: () => postSpy(),
+    });
+    const greeting = proxy.greeting.useQuery(undefined, {
+      onSuccess: () => greetingSpy(),
+    });
+
+    const utils = proxy.useContext();
+
+    return (
+      <>
+        <button
+          data-testid="invalidate"
+          onClick={() => {
+            utils.invalidate(undefined, {
+              predicate: (query) => {
+                return (query.queryKey[0] as string[])[0] === 'post';
+              },
+            });
+          }}
+        />
+        {allPosts.isFetching ? 'posts:fetching' : 'posts:done'}
+        {allPosts.data?.map((post) => {
+          return <div key={post.id}>{post.text}</div>;
+        })}
+        {greeting.isFetching ? 'greeting:fetching' : 'greeting:done'}
+        {greeting.data}
+      </>
+    );
+  }
+
+  const utils = render(
+    <App>
+      <MyComponent />
+    </App>,
+  );
+
+  await waitFor(() => {
+    expect(utils.container).toHaveTextContent('posts:done');
+    expect(utils.container).toHaveTextContent('greeting:done');
+  });
+
+  const invalidateButton = await utils.findByTestId('invalidate');
+  await userEvent.click(invalidateButton);
+
+  // post should match the filter and be invalidated
+  // greeting should not and thus still be done
+  expect(utils.container).toHaveTextContent('posts:fetching');
+  expect(utils.container).toHaveTextContent('greeting:done');
+
+  await waitFor(() => {
+    expect(utils.container).toHaveTextContent('posts:done');
+    expect(utils.container).toHaveTextContent('greeting:done');
+  });
+
+  expect(postSpy).toHaveBeenCalledTimes(2);
+  expect(greetingSpy).toHaveBeenCalledTimes(1);
+});
+
+test('tanstack query queries are invalidated', async () => {
+  const { proxy, App } = ctx;
+
+  function MyComponent() {
+    const utils = proxy.useContext();
+
+    const rqQuery = useQuery(['test'], async () => {
+      await new Promise((res) => setTimeout(res, 500));
+      return 'Hello tanstack';
+    });
+    const trpcQuery = proxy.greeting.useQuery();
+
+    return (
+      <>
+        <button data-testid="invalidate" onClick={() => utils.invalidate()} />
+        {rqQuery.isFetching ? 'rq:fetching' : 'rq:done'}
+        {trpcQuery.isFetching ? 'trpc:fetching' : 'trpc:done'}
+      </>
+    );
+  }
+
+  const utils = render(
+    <App>
+      <MyComponent />
+    </App>,
+  );
+  await waitFor(() => {
+    expect(utils.container).toHaveTextContent('rq:done');
+    expect(utils.container).toHaveTextContent('trpc:done');
+  });
+
+  await userEvent.click(utils.getByTestId('invalidate'));
+
+  expect(utils.container).toHaveTextContent('rq:fetching');
+  expect(utils.container).toHaveTextContent('trpc:fetching');
+
+  await waitFor(() => {
+    expect(utils.container).toHaveTextContent('rq:done');
+    expect(utils.container).toHaveTextContent('trpc:done');
+  });
+});
+
+test('mixed providers with more "advanced" filter', async () => {
+  const { proxy, App } = ctx;
+
+  function MyComponent() {
+    const utils = proxy.useContext();
+
+    const rqQuery1 = useQuery(
+      ['test', 1],
+      async () => {
+        await new Promise((res) => setTimeout(res, 500));
+        return 'Hello tanstack1';
+      },
+      { retry: false },
+    );
+
+    const rqQuery2 = useQuery(
+      ['test', 2],
+      async () => {
+        await new Promise((res) => setTimeout(res, 500));
+        return 'Hello tanstack2';
+      },
+      { retry: true },
+    );
+
+    const trpcQuery = proxy.greeting.useQuery(undefined, {
+      retry: false,
+    });
+
+    return (
+      <>
+        <button
+          data-testid="invalidate"
+          onClick={() => {
+            utils.invalidate(undefined, {
+              predicate: (query) => {
+                // invalidate all queries that have `retry: false`
+                return query.options.retry === false;
+              },
+            });
+          }}
+        />
+        {rqQuery1.isFetching ? 'rq1:fetching' : 'rq1:done'}
+        {rqQuery2.isFetching ? 'rq2:fetching' : 'rq2:done'}
+        {trpcQuery.isFetching ? 'trpc:fetching' : 'trpc:done'}
+      </>
+    );
+  }
+
+  const utils = render(
+    <App>
+      <MyComponent />
+    </App>,
+  );
+
+  await waitFor(() => {
+    expect(utils.container).toHaveTextContent('rq1:done');
+    expect(utils.container).toHaveTextContent('rq2:done');
+    expect(utils.container).toHaveTextContent('trpc:done');
+  });
+
+  await userEvent.click(utils.getByTestId('invalidate'));
+
+  expect(utils.container).toHaveTextContent('rq1:fetching');
+  expect(utils.container).toHaveTextContent('rq2:done');
+  expect(utils.container).toHaveTextContent('trpc:fetching');
+
+  await waitFor(() => {
+    expect(utils.container).toHaveTextContent('rq1:done');
+    expect(utils.container).toHaveTextContent('rq2:done');
+    expect(utils.container).toHaveTextContent('trpc:done');
+  });
+});
diff --git a/www/docs/reactjs/useContext.mdx b/www/docs/reactjs/useContext.mdx
index 958e9b2bd85..5220d6a6bc2 100644
--- a/www/docs/reactjs/useContext.mdx
+++ b/www/docs/reactjs/useContext.mdx
@@ -95,6 +95,49 @@ These are the helpers you'll get access to via `useContext`. The table below wil
 | `setInfiniteData`   | [`queryClient.setInfiniteQueryData`](https://tanstack.com/query/v4/docs/reference/QueryClient#queryclientsetquerydata)           |
 | `getInfiniteData`   | [`queryClient.getInfiniteData`](https://tanstack.com/query/v4/docs/reference/QueryClient#queryclientgetquerydata)                |
 
+### ❓ The function I want isn't here!
+
+`@tanstack/react-query` has a lot of functions that we haven't put in the tRPC context yet. If you need a function that isn't here, feel free to [open a feature request](https://github.com/trpc/trpc/issues/new/choose) requesting it.
+
+In the meantime, you can import and use the function directly from `@tanstack/react-query`. We provide a `getQueryKey` helper on routers and procedures so that you can easily provide the native function the correct query key.
+
+```tsx
+function getQueryKey(
+  input: TInput,
+  type?: QueryType; /** @default 'any' */
+)
+
+type QueryType = "query" | "infinite" | "any";
+// for useQuery ──┘         │            │
+// for useInfinitQuery ─────┘            │
+// will match any ───────────────────────┘
+
+/** @note signature on router doesn't take any parameters */
+```
+
+```tsx
+import { useIsFetching, useQueryClient } from '@tanstack/react-query';
+import { trpc } from '~/utils/trpc';
+
+function MyComponent() {
+  const queryClient = useQueryClient();
+
+  const posts = trpc.post.list.useQuery();
+
+  // See if a query is fetching
+  const postListKey = trpc.post.list.getQueryKey(undefined, 'infinite');
+  const isFetching = useIsFetching(postListKey);
+
+  // Set some query defaults for an entire router
+  const postKey = trpc.post.getQueryKey(undefined, 'any');
+  queryClient.setQueryDefaults(postKey, { staleTime: 30 * 60 * 1000 });
+
+  // ...
+}
+```
+
+## Proxy client
+
 In addition to the above react-query helpers, the context also exposes your tRPC proxy client. This lets you call your procedures with `async`/`await` without needing to create an additional vanilla client.
 
 ```tsx