diff --git a/.changeset/clean-phones-agree.md b/.changeset/clean-phones-agree.md
new file mode 100644
index 0000000..40edbf7
--- /dev/null
+++ b/.changeset/clean-phones-agree.md
@@ -0,0 +1,5 @@
+---
+"@softnetics/hono-react-query": minor
+---
+
+return client and originalClient from createRQClient
diff --git a/src/index.spec.tsx b/src/index.spec.tsx
index 58b5452..21f6694 100644
--- a/src/index.spec.tsx
+++ b/src/index.spec.tsx
@@ -38,6 +38,8 @@ describe('createReactQueryClient', () => {
       baseUrl: 'http://localhost:3000',
     })
 
+    expect(client.honoClient).toBeDefined()
+    expect(client.client).toBeDefined()
     expect(client.useQuery).toBeDefined()
     expect(client.useMutation).toBeDefined()
     expect(client.queryOptions).toBeDefined()
@@ -48,6 +50,55 @@ describe('createReactQueryClient', () => {
     expect(client.useOptimisticUpdateQuery).toBeDefined()
   })
 
+  describe('client', () => {
+    const client = createReactQueryClient<BasicHonoApp>({
+      baseUrl: 'http://localhost:3000',
+    })
+    it('should have typed arguments with return type', () => {
+      const queryFn = () => client.client('/users/:id', '$get', { param: { id: 'none' } })
+      expectTypeOf<ReturnType<typeof queryFn>>().toEqualTypeOf<
+        Promise<
+          | {
+              data: {
+                user: {
+                  id: string
+                  name: string
+                }
+              }
+              status: 200
+              format: 'json'
+              headers: Record<string, string>
+            }
+          | {
+              data: {
+                error: string
+              }
+              status: 400
+              format: 'json'
+              headers: Record<string, string>
+            }
+        >
+      >()
+    })
+    it('should not contain Error when throwOnError is true', () => {
+      const queryFn = () =>
+        client.client('/users/:id', '$get', { param: { id: 'none' } }, { throwOnError: true })
+      expectTypeOf<ReturnType<typeof queryFn>>().toEqualTypeOf<
+        Promise<{
+          data: {
+            user: {
+              id: string
+              name: string
+            }
+          }
+          status: 200
+          format: 'json'
+          headers: Record<string, string>
+        }>
+      >()
+    })
+  })
+
   describe('useQuery', () => {
     it('should contain Error in Data when throwOnError is false', () => {
       const client = createReactQueryClient<BasicHonoApp>({
diff --git a/src/index.ts b/src/index.ts
index a712f0d..c2da827 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -14,7 +14,9 @@ import { HonoResponseError, isHonoResponseError } from './error'
 import { createQueryKey } from './query-key'
 import {
   type Client,
+  type FlatClientFn,
   type HonoMutationOptions,
+  type HonoPayloadOptions,
   type HonoQueryOptions,
   type HonoSuspenseQueryOptions,
   type InferUseHonoQuery,
@@ -40,8 +42,11 @@ function createReactQueryClient<T extends Hono>(
     : never
 > {
   const client = hc(options.baseUrl, options)
+  const flatClient = flatClientFactory(client)
 
   return {
+    client: flatClient,
+    honoClient: client,
     useQuery: useQueryFactory(client),
     useSuspenseQuery: useSuspenseQueryFactory(client),
     useMutation: useMutationFactory(client),
@@ -94,6 +99,18 @@ async function responseParser(response: Response, throwOnError?: boolean): Promi
   throw new HonoResponseError(res)
 }
 
+function flatClientFactory<THono extends Record<string, any>>(
+  honoClient: Record<string, ClientRequest<any>>
+): FlatClientFn<THono> {
+  return (async (path: string, method: string, payload?: any, options?: HonoPayloadOptions) => {
+    const paths = [...path.toString().split('/').filter(Boolean), method.toString()]
+    const handler = getter(honoClient, paths)
+    const throwOnError = options?.throwOnError ?? false // Note: Default to false for flat client
+    const response = await handler(payload, options)
+    return responseParser(response, throwOnError)
+  }) as FlatClientFn<THono>
+}
+
 function useQueryFactory<T extends Record<string, any>>(
   client: Record<string, ClientRequest<any>>
 ): UseHonoQuery<T> {
@@ -259,6 +276,8 @@ function useOptimisticUpdateQueryFactory<T extends Record<string, any>>() {
 export {
   createQueryKey,
   createReactQueryClient,
+  type Client as FlatClient,
+  type FlatClientFn,
   HonoResponseError,
   type InferUseHonoQuery,
   isHonoResponseError,
diff --git a/src/types.ts b/src/types.ts
index 2b91596..dec7413 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -56,7 +56,7 @@ type ErrorResponse<T> =
       >
     : never
 
-type HonoPayloadOptions = ClientRequestOptions & { throwOnError?: boolean }
+export type HonoPayloadOptions = ClientRequestOptions & { throwOnError?: boolean }
 export type HonoPayload<
   TInput,
   TOptions extends HonoPayloadOptions | undefined = HonoPayloadOptions | undefined,
@@ -305,6 +305,8 @@ export type UseHonoOptimisticUpdateQuery<TApp extends Record<string, any>> = <
   | undefined
 
 export type ReactQueryClient<TApp extends Record<string, any>> = {
+  honoClient: Record<string, ClientRequest<any>>
+  client: FlatClientFn<TApp>
   useQuery: UseHonoQuery<TApp>
   useSuspenseQuery: UseHonoSuspenseQuery<TApp>
   useMutation: UseHonoMutation<TApp>
@@ -319,3 +321,21 @@ export type ReactQueryClient<TApp extends Record<string, any>> = {
 
 export type InferUseHonoQuery<TQuery extends UseQueryResult<any, any>> =
   TQuery extends UseQueryResult<infer TData, any> ? TData : never
+
+export type FlatClientFn<TApp extends Record<string, any>> = <
+  TPath extends keyof TApp = keyof TApp,
+  TMethod extends keyof TApp[TPath] = keyof TApp[TPath],
+  TPayload extends InferFunctionInput<TApp[TPath][TMethod]> = InferFunctionInput<
+    TApp[TPath][TMethod]
+  >,
+  TOptions extends HonoPayloadOptions | undefined = HonoPayloadOptions | undefined,
+>(
+  path: TPath,
+  method: TMethod,
+  payload: TPayload,
+  options?: TOptions
+) => Promise<
+  TOptions extends { throwOnError: true }
+    ? SuccessResponse<InferFunctionReturn<TApp[TPath][TMethod]>>
+    : ClientResponseParser<InferFunctionReturn<TApp[TPath][TMethod]>>
+>