diff --git a/src/select-query-parser/result.ts b/src/select-query-parser/result.ts
index 07802c70..391f175c 100644
--- a/src/select-query-parser/result.ts
+++ b/src/select-query-parser/result.ts
@@ -16,6 +16,7 @@ import {
   IsRelationNullable,
   ResolveRelationship,
   SelectQueryError,
+  UnwrapErrorMessages,
 } from './utils'
 
 /**
@@ -35,16 +36,18 @@ export type GetResult<
   Query extends string
 > = Relationships extends null // For .rpc calls the passed relationships will be null in that case, the result will always be the function return type
   ? ParseQuery<Query> extends infer ParsedQuery extends Ast.Node[]
-    ? RPCCallNodes<ParsedQuery, RelationName extends string ? RelationName : 'rpc_call', Row>
+    ? UnwrapErrorMessages<
+        RPCCallNodes<ParsedQuery, RelationName extends string ? RelationName : 'rpc_call', Row>
+      >
     : Row
   : ParseQuery<Query> extends infer ParsedQuery
   ? ParsedQuery extends Ast.Node[]
     ? RelationName extends string
       ? Relationships extends GenericRelationship[]
-        ? ProcessNodes<Schema, Row, RelationName, Relationships, ParsedQuery>
-        : SelectQueryError<'Invalid Relationships cannot infer result type'>
-      : SelectQueryError<'Invalid RelationName cannot infer result type'>
-    : ParsedQuery
+        ? UnwrapErrorMessages<ProcessNodes<Schema, Row, RelationName, Relationships, ParsedQuery>>
+        : UnwrapErrorMessages<SelectQueryError<'Invalid Relationships cannot infer result type'>>
+      : UnwrapErrorMessages<SelectQueryError<'Invalid RelationName cannot infer result type'>>
+    : UnwrapErrorMessages<ParsedQuery>
   : never
 
 /**
diff --git a/src/select-query-parser/utils.ts b/src/select-query-parser/utils.ts
index eff2b1fc..5a7c0abf 100644
--- a/src/select-query-parser/utils.ts
+++ b/src/select-query-parser/utils.ts
@@ -10,6 +10,12 @@ import {
   UnionToArray,
 } from './types'
 
+export type UnwrapErrorMessages<T> = T extends SelectQueryError<infer M>
+  ? M
+  : T extends Record<string, unknown>
+  ? { [K in keyof T]: UnwrapErrorMessages<T[K]> }
+  : T
+
 export type SelectQueryError<Message extends string> = { error: true } & Message
 
 type RequireHintingSelectQueryError<
diff --git a/test/select-query-parser/select.test-d.ts b/test/select-query-parser/select.test-d.ts
index 7849ea1f..0001e6db 100644
--- a/test/select-query-parser/select.test-d.ts
+++ b/test/select-query-parser/select.test-d.ts
@@ -198,9 +198,9 @@ type Schema = Database['public']
   const { data } = await selectQueries.joinOneToOneWithNullablesNoHint.limit(1).single()
   let result: Exclude<typeof data, null>
   let expected: {
-    first_user: SelectQueryError<"Could not embed because more than one relationship was found for 'users' and 'best_friends' you need to hint the column with users!<columnName> ?">
-    second_user: SelectQueryError<"Could not embed because more than one relationship was found for 'users' and 'best_friends' you need to hint the column with users!<columnName> ?">
-    third_wheel: SelectQueryError<"Could not embed because more than one relationship was found for 'users' and 'best_friends' you need to hint the column with users!<columnName> ?">
+    first_user: "Could not embed because more than one relationship was found for 'users' and 'best_friends' you need to hint the column with users!<columnName> ?"
+    second_user: "Could not embed because more than one relationship was found for 'users' and 'best_friends' you need to hint the column with users!<columnName> ?"
+    third_wheel: "Could not embed because more than one relationship was found for 'users' and 'best_friends' you need to hint the column with users!<columnName> ?"
   }
   expectType<TypeEqual<typeof result, typeof expected>>(true)
 }
@@ -222,9 +222,9 @@ type Schema = Database['public']
   const { data } = await selectQueries.joinOneToManyWithNullablesNoHint.limit(1).single()
   let result: Exclude<typeof data, null>
   let expected: {
-    first_friend_of: SelectQueryError<"Could not embed because more than one relationship was found for 'best_friends' and 'users' you need to hint the column with best_friends!<columnName> ?">
-    second_friend_of: SelectQueryError<"Could not embed because more than one relationship was found for 'best_friends' and 'users' you need to hint the column with best_friends!<columnName> ?">
-    third_wheel_of: SelectQueryError<"Could not embed because more than one relationship was found for 'best_friends' and 'users' you need to hint the column with best_friends!<columnName> ?">
+    first_friend_of: "Could not embed because more than one relationship was found for 'best_friends' and 'users' you need to hint the column with best_friends!<columnName> ?"
+    second_friend_of: "Could not embed because more than one relationship was found for 'best_friends' and 'users' you need to hint the column with best_friends!<columnName> ?"
+    third_wheel_of: "Could not embed because more than one relationship was found for 'best_friends' and 'users' you need to hint the column with best_friends!<columnName> ?"
   }
   expectType<TypeEqual<typeof result, typeof expected>>(true)
 }
@@ -630,7 +630,7 @@ type Schema = Database['public']
   const { data } = await selectQueries.joinSelectViaColumnHintTwice.limit(1).single()
   let result: Exclude<typeof data, null>
   let expected: {
-    users: SelectQueryError<'table "best_friends" specified more than once use hinting for desambiguation'>
+    users: 'table "best_friends" specified more than once use hinting for desambiguation'
   }
   expectType<TypeEqual<typeof result, typeof expected>>(true)
 }
@@ -641,7 +641,7 @@ type Schema = Database['public']
   let result: Exclude<typeof data, null>
   let expected: {
     id: number
-    messages: SelectQueryError<'"channels" and "messages" do not form a many-to-one or one-to-one relationship spread not possible'>
+    messages: '"channels" and "messages" do not form a many-to-one or one-to-one relationship spread not possible'
   }
   expectType<TypeEqual<typeof result, typeof expected>>(true)
 }
@@ -684,7 +684,7 @@ type Schema = Database['public']
 {
   const { data } = await selectQueries.typecastingAndAggregate.limit(1).single()
   let result: Exclude<typeof data, null>
-  let expected: SelectQueryError<`column 'users' does not exist on 'messages'.`>
+  let expected: `column 'users' does not exist on 'messages'.`
   expectType<TypeEqual<typeof result, typeof expected>>(true)
 }
 
@@ -741,5 +741,5 @@ type Schema = Database['public']
 {
   const { data, error } = await selectQueries.aggregateOnMissingColumnWithAlias.limit(1).single()
   if (error) throw error
-  expectType<SelectQueryError<`column 'missing_column' does not exist on 'users'.`>>(data)
+  expectType<`column 'missing_column' does not exist on 'users'.`>(data)
 }