diff --git a/federation/http/index.ts b/federation/http/index.ts
index 2e9fab4..bc8801b 100644
--- a/federation/http/index.ts
+++ b/federation/http/index.ts
@@ -2,25 +2,25 @@ import type { EntityValidator } from "../validator/index";
 
 type MaybePromise<T> = T | Promise<T>;
 
-type ParserCallbacks = {
-    note: (note: typeof EntityValidator.$Note) => MaybePromise<void>;
-    follow: (follow: typeof EntityValidator.$Follow) => MaybePromise<void>;
+type ParserCallbacks<T> = {
+    note: (note: typeof EntityValidator.$Note) => MaybePromise<T>;
+    follow: (follow: typeof EntityValidator.$Follow) => MaybePromise<T>;
     followAccept: (
         followAccept: typeof EntityValidator.$FollowAccept,
-    ) => MaybePromise<void>;
+    ) => MaybePromise<T>;
     followReject: (
         followReject: typeof EntityValidator.$FollowReject,
-    ) => MaybePromise<void>;
-    user: (user: typeof EntityValidator.$User) => MaybePromise<void>;
-    like: (like: typeof EntityValidator.$Like) => MaybePromise<void>;
-    dislike: (dislike: typeof EntityValidator.$Dislike) => MaybePromise<void>;
-    undo: (undo: typeof EntityValidator.$Undo) => MaybePromise<void>;
+    ) => MaybePromise<T>;
+    user: (user: typeof EntityValidator.$User) => MaybePromise<T>;
+    like: (like: typeof EntityValidator.$Like) => MaybePromise<T>;
+    dislike: (dislike: typeof EntityValidator.$Dislike) => MaybePromise<T>;
+    undo: (undo: typeof EntityValidator.$Undo) => MaybePromise<T>;
     serverMetadata: (
         serverMetadata: typeof EntityValidator.$ServerMetadata,
-    ) => MaybePromise<void>;
+    ) => MaybePromise<T>;
     extension: (
         extension: typeof EntityValidator.$Extension,
-    ) => MaybePromise<void>;
+    ) => MaybePromise<T>;
 };
 
 export class RequestParserHandler {
@@ -34,24 +34,27 @@ export class RequestParserHandler {
 
     /**
      * Parse the body of the request and call the appropriate callback.
+     * To change the return type, edit the ReturnType generic parameter.
      * @param callbacks The callbacks to call when a specific entity is found.
      * @returns A promise that resolves when the body has been parsed, and the callbacks have finished executing.
      */
-    public async parseBody(callbacks: Partial<ParserCallbacks>): Promise<void> {
+    public async parseBody<ReturnType = void>(
+        callbacks: Partial<ParserCallbacks<ReturnType>>,
+    ): Promise<ReturnType> {
         if (!this.body.type) throw new Error("Missing type field in body");
 
         switch (this.body.type) {
             case "Note": {
                 const note = await this.validator.Note(this.body);
 
-                if (callbacks.note) await callbacks.note(note);
+                if (callbacks.note) return await callbacks.note(note);
 
                 break;
             }
             case "Follow": {
                 const follow = await this.validator.Follow(this.body);
 
-                if (callbacks.follow) await callbacks.follow(follow);
+                if (callbacks.follow) return await callbacks.follow(follow);
 
                 break;
             }
@@ -61,7 +64,7 @@ export class RequestParserHandler {
                 );
 
                 if (callbacks.followAccept)
-                    await callbacks.followAccept(followAccept);
+                    return await callbacks.followAccept(followAccept);
 
                 break;
             }
@@ -71,35 +74,35 @@ export class RequestParserHandler {
                 );
 
                 if (callbacks.followReject)
-                    await callbacks.followReject(followReject);
+                    return await callbacks.followReject(followReject);
 
                 break;
             }
             case "User": {
                 const user = await this.validator.User(this.body);
 
-                if (callbacks.user) await callbacks.user(user);
+                if (callbacks.user) return await callbacks.user(user);
 
                 break;
             }
             case "Like": {
                 const like = await this.validator.Like(this.body);
 
-                if (callbacks.like) await callbacks.like(like);
+                if (callbacks.like) return await callbacks.like(like);
 
                 break;
             }
             case "Dislike": {
                 const dislike = await this.validator.Dislike(this.body);
 
-                if (callbacks.dislike) await callbacks.dislike(dislike);
+                if (callbacks.dislike) return await callbacks.dislike(dislike);
 
                 break;
             }
             case "Undo": {
                 const undo = await this.validator.Undo(this.body);
 
-                if (callbacks.undo) await callbacks.undo(undo);
+                if (callbacks.undo) return await callbacks.undo(undo);
 
                 break;
             }
@@ -109,14 +112,15 @@ export class RequestParserHandler {
                 );
 
                 if (callbacks.serverMetadata)
-                    await callbacks.serverMetadata(serverMetadata);
+                    return await callbacks.serverMetadata(serverMetadata);
 
                 break;
             }
             case "Extension": {
                 const extension = await this.validator.Extension(this.body);
 
-                if (callbacks.extension) await callbacks.extension(extension);
+                if (callbacks.extension)
+                    return await callbacks.extension(extension);
 
                 break;
             }
@@ -125,5 +129,7 @@ export class RequestParserHandler {
                     `Invalid type field in body: ${this.body.type}`,
                 );
         }
+
+        throw new Error(`Invalid type field in body: ${this.body.type}`);
     }
 }