diff --git a/docs/api/my-api.md b/docs/api/my-api.md
index d69a633..7f69264 100644
--- a/docs/api/my-api.md
+++ b/docs/api/my-api.md
@@ -6,6 +6,48 @@
 
 Returns the raw response of the API endpoint. Intended for actions inside methods, e.g. when sending form data to the API when clicking a submit button.
 
+## Type Declarations
+
+```ts
+interface BaseApiFetchOptions {
+  /**
+   * Skip the Nuxt server proxy and fetch directly from the API.
+   * Requires `allowClient` to be enabled in the module options as well.
+   * @default false
+   */
+  client?: boolean
+  /**
+   * Cache the response for the same request.
+   * If set to `true`, the cache key will be generated from the request options.
+   * Alternatively, a custom cache key can be provided.
+   * @default false
+   */
+  cache?: string | boolean
+}
+
+type ApiFetchOptions = Omit<NitroFetchOptions<string>, 'body' | 'cache'> & {
+  pathParams?: Record<string, string>
+  body?: string | Record<string, any> | FormData | null
+}
+
+function $Api<T = any>(
+  path: string,
+  opts?: ApiFetchOptions & BaseApiFetchOptions
+): Promise<T>
+```
+
+## Caching
+
+By default, a [unique key is generated](/guide/caching) based in input parameters for each request to ensure that data fetching can be properly de-duplicated across requests. You can provide a custom key by passing a string as the `cache` option:
+
+```ts
+const route = useRoute()
+
+const data = await $myApi('posts', {
+  cache: `posts-${route.params.id}`
+})
+```
+
 ## Example
 
 ::: info
@@ -90,31 +132,3 @@ export default defineNuxtConfig({
   }
 })
 ```
-
-## Type Declarations
-
-```ts
-interface BaseApiFetchOptions {
-  /**
-   * Skip the Nuxt server proxy and fetch directly from the API.
-   * Requires `allowClient` to be enabled in the module options as well.
-   * @default false
-   */
-  client?: boolean
-  /**
-   * Cache the response for the same request
-   * @default false
-   */
-  cache?: boolean
-}
-
-type ApiFetchOptions = Omit<NitroFetchOptions<string>, 'body' | 'cache'> & {
-  pathParams?: Record<string, string>
-  body?: string | Record<string, any> | FormData | null
-}
-
-type $Api = <T = any>(
-  path: string,
-  opts?: ApiFetchOptions & BaseApiFetchOptions
-) => Promise<T>
-```
diff --git a/docs/api/use-my-api-data.md b/docs/api/use-my-api-data.md
index 6f40c2b..6a0d611 100644
--- a/docs/api/use-my-api-data.md
+++ b/docs/api/use-my-api-data.md
@@ -19,6 +19,71 @@ The composable supports every [`useAsyncData` option](https://nuxt.com/docs/api/
 
 By default, Nuxt waits until a `refresh` is finished before it can be executed again. Passing `true` as parameter skips that wait.
 
+## Type Declarations
+
+```ts
+type BaseUseApiDataOptions<T> = Omit<AsyncDataOptions<T>, 'watch'> & {
+  /**
+   * Skip the Nuxt server proxy and fetch directly from the API.
+   * Requires `allowClient` to be enabled in the module options as well.
+   * @default false
+   */
+  client?: boolean
+  /**
+   * Cache the response for the same request.
+   * @default true
+   */
+  cache?: boolean
+  /**
+   * Watch an array of reactive sources and auto-refresh the fetch result when they change.
+   * Fetch options and URL are watched by default. You can completely ignore reactive sources by using `watch: false`.
+   */
+  watch?: (WatchSource<unknown> | object)[] | false
+}
+
+type UseApiDataOptions<T> = Pick<
+  ComputedOptions<NitroFetchOptions<string>>,
+  | 'onRequest'
+  | 'onRequestError'
+  | 'onResponse'
+  | 'onResponseError'
+  | 'query'
+  | 'headers'
+  | 'method'
+  | 'retry'
+  | 'retryDelay'
+  | 'timeout'
+> & {
+  pathParams?: MaybeRef<Record<string, string>>
+  body?: MaybeRef<string | Record<string, any> | FormData | null | undefined>
+} & BaseUseApiDataOptions<T>
+
+function UseApiData<T = any>(
+  path: MaybeRefOrGetter<string>,
+  opts?: UseApiDataOptions<T>
+): AsyncData<T | undefined, FetchError>
+function UseApiData<T = any>(
+  key: MaybeRefOrGetter<string>,
+  path: MaybeRefOrGetter<string>,
+  opts?: UseApiDataOptions<T>
+): AsyncData<T | undefined, FetchError>
+```
+
+## Caching
+
+By default, a [unique key is generated](/guide/caching) based in input parameters for each request to ensure that data fetching can be properly de-duplicated across requests. You can provide a custom key by passing a string as the first argument, just like the native [`useAsyncData`](https://nuxt.com/docs/api/composables/use-async-data):
+
+```ts
+const route = useRoute()
+const key = computed(() => `posts-${route.params.id}`)
+
+const { data } = await useMyApiData(key, 'posts')
+```
+
+::: tip
+The key can be a reactive value, e.g. a computed property.
+:::
+
 ## Examples
 
 ::: info
@@ -124,48 +189,3 @@ export default defineNuxtConfig({
   }
 })
 ```
-
-## Type Declarations
-
-```ts
-type BaseUseApiDataOptions<T> = Omit<AsyncDataOptions<T>, 'watch'> & {
-  /**
-   * Skip the Nuxt server proxy and fetch directly from the API.
-   * Requires `allowClient` to be enabled in the module options as well.
-   * @default false
-   */
-  client?: boolean
-  /**
-   * Cache the response for the same request
-   * @default true
-   */
-  cache?: boolean
-  /**
-   * Watch an array of reactive sources and auto-refresh the fetch result when they change.
-   * Fetch options and URL are watched by default. You can completely ignore reactive sources by using `watch: false`.
-   */
-  watch?: (WatchSource<unknown> | object)[] | false
-}
-
-type UseApiDataOptions<T> = Pick<
-  ComputedOptions<NitroFetchOptions<string>>,
-  | 'onRequest'
-  | 'onRequestError'
-  | 'onResponse'
-  | 'onResponseError'
-  | 'query'
-  | 'headers'
-  | 'method'
-  | 'retry'
-  | 'retryDelay'
-  | 'timeout'
-> & {
-  pathParams?: MaybeRef<Record<string, string>>
-  body?: MaybeRef<string | Record<string, any> | FormData | null | undefined>
-} & BaseUseApiDataOptions<T>
-
-type UseApiData = <T = any>(
-  path: MaybeRefOrGetter<string>,
-  opts?: UseApiDataOptions<T>
-) => AsyncData<T | undefined, FetchError>
-```
diff --git a/src/runtime/composables/$api.ts b/src/runtime/composables/$api.ts
index 5289454..46bd960 100644
--- a/src/runtime/composables/$api.ts
+++ b/src/runtime/composables/$api.ts
@@ -15,10 +15,12 @@ export interface BaseApiFetchOptions {
    */
   client?: boolean
   /**
-   * Cache the response for the same request
+   * Cache the response for the same request.
+   * If set to `true`, the cache key will be generated from the request options.
+   * Alternatively, a custom cache key can be provided.
    * @default false
    */
-  cache?: boolean
+  cache?: string | boolean
 }
 
 export type ApiFetchOptions = Omit<NitroFetchOptions<string>, 'body' | 'cache'> & {
@@ -40,7 +42,7 @@ export interface $OpenApi<Paths extends Record<string, PathItemObject>> {
     path: P,
     opts: BaseApiFetchOptions & Omit<OpenApiRequestOptions<Paths[`/${P}`]>, 'method'>
   ): Promise<OpenApiResponse<Paths[`/${P}`]['get']>>
- <P extends AllPaths<Paths>, M extends IgnoreCase<keyof Paths[`/${P}`] & HttpMethod>>(
+  <P extends AllPaths<Paths>, M extends IgnoreCase<keyof Paths[`/${P}`] & HttpMethod>>(
     path: P,
     opts?: BaseApiFetchOptions & OpenApiRequestOptions<Paths[`/${P}`], M> & { method: M }
   ): Promise<OpenApiResponse<Paths[`/${P}`][Lowercase<M>]>>
@@ -52,7 +54,9 @@ export function _$api<T = any>(
   opts: ApiFetchOptions & BaseApiFetchOptions = {},
 ): Promise<T> {
   const nuxt = useNuxtApp()
+  const { apiParty } = useRuntimeConfig().public
   const promiseMap = (nuxt._promiseMap = nuxt._promiseMap || new Map()) as Map<string, Promise<T>>
+
   const {
     pathParams,
     query,
@@ -63,24 +67,26 @@ export function _$api<T = any>(
     cache = false,
     ...fetchOptions
   } = opts
-  const { apiParty } = useRuntimeConfig().public
-  const key = `$party${hash([
-    endpointId,
-    path,
-    pathParams,
-    query,
-    method,
-    ...(isFormData(body) ? [] : [body]),
-  ])}`
+
+  const _key = typeof cache === 'string'
+    ? cache
+    : `$party${hash([
+      endpointId,
+      path,
+      pathParams,
+      query,
+      method,
+      ...(isFormData(body) ? [] : [body]),
+    ])}`
 
   if (client && !apiParty.allowClient)
     throw new Error('Client-side API requests are disabled. Set "allowClient: true" in the module options to enable them.')
 
-  if ((nuxt.isHydrating || cache) && key in nuxt.payload.data)
-    return Promise.resolve(nuxt.payload.data[key])
+  if ((nuxt.isHydrating || cache) && _key in nuxt.payload.data)
+    return Promise.resolve(nuxt.payload.data[_key])
 
-  if (promiseMap.has(key))
-    return promiseMap.get(key)!
+  if (promiseMap.has(_key))
+    return promiseMap.get(_key)!
 
   const endpoints = (apiParty as unknown as ModuleOptions).endpoints || {}
   const endpoint = endpoints[endpointId]
@@ -120,19 +126,19 @@ export function _$api<T = any>(
   const request = (client ? clientFetcher() : serverFetcher())
     .then((response) => {
       if (process.server || cache)
-        nuxt.payload.data[key] = response
-      promiseMap.delete(key)
+        nuxt.payload.data[_key] = response
+      promiseMap.delete(_key)
       return response
     })
     // Invalidate cache if request fails
     .catch((error) => {
-      if (key in nuxt.payload.data)
-        delete nuxt.payload.data[key]
-      promiseMap.delete(key)
+      if (_key in nuxt.payload.data)
+        delete nuxt.payload.data[_key]
+      promiseMap.delete(_key)
       throw error
     }) as Promise<T>
 
-  promiseMap.set(key, request)
+  promiseMap.set(_key, request)
 
   return request
 }
diff --git a/src/runtime/composables/useApiData.ts b/src/runtime/composables/useApiData.ts
index 798a531..c5513d3 100644
--- a/src/runtime/composables/useApiData.ts
+++ b/src/runtime/composables/useApiData.ts
@@ -27,7 +27,7 @@ export type BaseUseApiDataOptions<T> = Omit<AsyncDataOptions<T>, 'watch'> & {
    */
   client?: boolean
   /**
-   * Cache the response for the same request
+   * Cache the response for the same request.
    * @default true
    */
   cache?: boolean
@@ -60,10 +60,17 @@ export type UseOpenApiDataOptions<
   M extends IgnoreCase<keyof P & HttpMethod> = IgnoreCase<keyof P & 'get'>,
 > = BaseUseApiDataOptions<OpenApiResponse<P[Lowercase<M>]>> & ComputedOptions<OpenApiRequestOptions<P, M>>
 
-export type UseApiData = <T = any>(
-  path: MaybeRefOrGetter<string>,
-  opts?: UseApiDataOptions<T>,
-) => AsyncData<T | undefined, FetchError>
+export interface UseApiData {
+  <T = any>(
+    path: MaybeRefOrGetter<string>,
+    opts?: UseApiDataOptions<T>,
+  ): AsyncData<T | undefined, FetchError>
+  <T = any>(
+    key: MaybeRefOrGetter<string>,
+    path: MaybeRefOrGetter<string>,
+    opts?: UseApiDataOptions<T>,
+  ): AsyncData<T | undefined, FetchError>
+}
 
 export interface UseOpenApiData<Paths extends Record<string, PathItemObject>> {
   <P extends GETPlainPaths<Paths>>(
@@ -78,13 +85,42 @@ export interface UseOpenApiData<Paths extends Record<string, PathItemObject>> {
     path: MaybeRefOrGetter<P>,
     opts: UseOpenApiDataOptions<Paths[`/${P}`], M> & { method: M },
   ): AsyncData<OpenApiResponse<Paths[`/${P}`][Lowercase<M>]> | undefined, FetchError<OpenApiError<Paths[`/${P}`][Lowercase<M>]>>>
+  // Support for custom unique key
+  <P extends GETPlainPaths<Paths>>(
+    key: MaybeRefOrGetter<string>,
+    path: MaybeRefOrGetter<P>,
+    opts?: Omit<UseOpenApiDataOptions<Paths[`/${P}`]>, 'method'>,
+  ): AsyncData<OpenApiResponse<Paths[`/${P}`]['get']> | undefined, FetchError<OpenApiError<Paths[`/${P}`]['get']>>>
+  <P extends GETPaths<Paths>>(
+    key: MaybeRefOrGetter<string>,
+    path: MaybeRefOrGetter<P>,
+    opts: Omit<UseOpenApiDataOptions<Paths[`/${P}`]>, 'method'>,
+  ): AsyncData<OpenApiResponse<Paths[`/${P}`]['get']> | undefined, FetchError<OpenApiError<Paths[`/${P}`]['get']>>>
+  <P extends AllPaths<Paths>, M extends IgnoreCase<keyof Paths[`/${P}`] & HttpMethod>>(
+    key: MaybeRefOrGetter<string>,
+    path: MaybeRefOrGetter<P>,
+    opts: UseOpenApiDataOptions<Paths[`/${P}`], M> & { method: M },
+  ): AsyncData<OpenApiResponse<Paths[`/${P}`][Lowercase<M>]> | undefined, FetchError<OpenApiError<Paths[`/${P}`][Lowercase<M>]>>>
 }
 
+export function _useApiData<T = any>(
+  endpointId: string,
+  key: MaybeRefOrGetter<string>,
+  path: MaybeRefOrGetter<string>,
+  opts: UseApiDataOptions<T>,
+): AsyncData<T | undefined, FetchError>
 export function _useApiData<T = any>(
   endpointId: string,
   path: MaybeRefOrGetter<string>,
-  opts: UseApiDataOptions<T> = {},
+  opts: UseApiDataOptions<T>,
+): AsyncData<T | undefined, FetchError>
+export function _useApiData<T = any>(
+  endpointId: string,
+  ...args: [MaybeRefOrGetter<string>, UseApiDataOptions<T>] | [MaybeRefOrGetter<string>, MaybeRefOrGetter<string>, UseApiDataOptions<T>]
 ) {
+  const [key = undefined] = args.length === 3 ? [args[0]] : []
+  const [path, opts = {}] = args.length === 3 ? [args[1], args[2]] : args
+
   const { apiParty } = useRuntimeConfig().public
   const {
     server,
@@ -103,7 +139,20 @@ export function _useApiData<T = any>(
     cache = true,
     ...fetchOptions
   } = opts
+
   const _path = computed(() => resolvePath(toValue(path), toValue(pathParams)))
+  const _key = computed(() => `$party${
+    key
+      ? toValue(key)
+      : hash([
+          endpointId,
+          _path.value,
+          toValue(query),
+          toValue(method),
+          ...(isFormData(toValue(body)) ? [] : [toValue(body)]),
+        ])
+    }`,
+  )
 
   if (client && !apiParty.allowClient)
     throw new Error('Client-side API requests are disabled. Set "allowClient: true" in the module options to enable them.')
@@ -140,23 +189,16 @@ export function _useApiData<T = any>(
   }
 
   let controller: AbortController | undefined
-  const key = computed(() => `$party${hash([
-    endpointId,
-    _path.value,
-    toValue(query),
-    toValue(method),
-    ...(isFormData(toValue(body)) ? [] : [toValue(body)]),
-  ])}`)
 
   return useAsyncData<T, FetchError>(
-    key.value,
+    _key.value,
     async (nuxt) => {
       controller?.abort?.()
 
       // Workaround to persist response client-side
       // https://github.com/nuxt/nuxt/issues/15445
-      if ((nuxt!.isHydrating || cache) && key.value in nuxt!.payload.data)
-        return nuxt!.payload.data[key.value]
+      if ((nuxt!.isHydrating || cache) && _key.value in nuxt!.payload.data)
+        return nuxt!.payload.data[_key.value]
 
       controller = new AbortController()
 
@@ -197,14 +239,14 @@ export function _useApiData<T = any>(
       }
       catch (error) {
         // Invalidate cache if request fails
-        if (key.value in nuxt!.payload.data)
-          delete nuxt!.payload.data[key.value]
+        if (_key.value in nuxt!.payload.data)
+          delete nuxt!.payload.data[_key.value]
 
         throw error
       }
 
       if (cache)
-        nuxt!.payload.data[key.value] = result
+        nuxt!.payload.data[_key.value] = result
 
       return result
     },