diff --git a/keyserver/src/responders/activity-responders.js b/keyserver/src/responders/activity-responders.js
index 6b551e5c7..1c2ec4083 100644
--- a/keyserver/src/responders/activity-responders.js
+++ b/keyserver/src/responders/activity-responders.js
@@ -1,62 +1,66 @@
 // @flow
 
 import t from 'tcomb';
 import type { TList } from 'tcomb';
 
-import type {
-  UpdateActivityResult,
-  UpdateActivityRequest,
-  SetThreadUnreadStatusRequest,
-  SetThreadUnreadStatusResult,
-  ActivityUpdate,
+import {
+  type UpdateActivityResult,
+  type UpdateActivityRequest,
+  type SetThreadUnreadStatusRequest,
+  type SetThreadUnreadStatusResult,
+  type ActivityUpdate,
+  setThreadUnreadStatusResult,
+  updateActivityResultValidator,
 } from 'lib/types/activity-types.js';
 import { tShape } from 'lib/utils/validation-utils.js';
 
 import type { Viewer } from '../session/viewer.js';
 import {
   activityUpdater,
   setThreadUnreadStatus,
 } from '../updaters/activity-updaters.js';
-import { validateInput } from '../utils/validation-utils.js';
+import { validateInput, validateOutput } from '../utils/validation-utils.js';
 
 const activityUpdatesInputValidator: TList<Array<ActivityUpdate>> = t.list(
   tShape({
     focus: t.Bool,
     threadID: t.String,
     latestMessage: t.maybe(t.String),
   }),
 );
 
 const inputValidator = tShape({
   updates: activityUpdatesInputValidator,
 });
 
 async function updateActivityResponder(
   viewer: Viewer,
   input: any,
 ): Promise<UpdateActivityResult> {
   const request: UpdateActivityRequest = input;
   await validateInput(viewer, inputValidator, request);
-  return await activityUpdater(viewer, request);
+  const result = await activityUpdater(viewer, request);
+  return validateOutput(viewer, updateActivityResultValidator, result);
 }
 
 const setThreadUnreadStatusValidator = tShape({
   threadID: t.String,
   unread: t.Bool,
   latestMessage: t.maybe(t.String),
 });
 async function threadSetUnreadStatusResponder(
   viewer: Viewer,
   input: any,
 ): Promise<SetThreadUnreadStatusResult> {
   const request: SetThreadUnreadStatusRequest = input;
   await validateInput(viewer, setThreadUnreadStatusValidator, request);
 
-  return await setThreadUnreadStatus(viewer, request);
+  const result = await setThreadUnreadStatus(viewer, request);
+  return validateOutput(viewer, setThreadUnreadStatusResult, result);
 }
 
 export {
   activityUpdatesInputValidator,
   updateActivityResponder,
   threadSetUnreadStatusResponder,
 };
diff --git a/keyserver/src/responders/entry-responders.js b/keyserver/src/responders/entry-responders.js
index f630b97c5..377eab8e2 100644
--- a/keyserver/src/responders/entry-responders.js
+++ b/keyserver/src/responders/entry-responders.js
@@ -1,306 +1,318 @@
 // @flow
 
 import t from 'tcomb';
 import type { TInterface } from 'tcomb';
 
 import { filteredThreadIDs } from 'lib/selectors/calendar-filter-selectors.js';
 import {
   type CalendarQuery,
   type SaveEntryRequest,
   type CreateEntryRequest,
   type DeleteEntryRequest,
   type DeleteEntryResponse,
   type RestoreEntryRequest,
   type RestoreEntryResponse,
   type FetchEntryInfosResponse,
   type DeltaEntryInfosResult,
   type SaveEntryResponse,
   rawEntryInfoValidator,
 } from 'lib/types/entry-types.js';
 import {
   type CalendarFilter,
   calendarThreadFilterTypes,
 } from 'lib/types/filter-types.js';
 import {
   type FetchEntryRevisionInfosResult,
   type FetchEntryRevisionInfosRequest,
   historyRevisionInfoValidator,
 } from 'lib/types/history-types.js';
 import { rawMessageInfoValidator } from 'lib/types/message-types.js';
 import { serverCreateUpdatesResponseValidator } from 'lib/types/update-types.js';
 import { accountUserInfoValidator } from 'lib/types/user-types.js';
 import { ServerError } from 'lib/utils/errors.js';
 import { tString, tShape, tDate, tID } from 'lib/utils/validation-utils.js';
 
 import createEntry from '../creators/entry-creator.js';
 import { deleteEntry, restoreEntry } from '../deleters/entry-deleters.js';
 import {
   fetchEntryInfos,
   fetchEntryRevisionInfo,
   fetchEntriesForSession,
 } from '../fetchers/entry-fetchers.js';
 import { verifyThreadIDs } from '../fetchers/thread-fetchers.js';
 import type { Viewer } from '../session/viewer.js';
 import {
   updateEntry,
   compareNewCalendarQuery,
 } from '../updaters/entry-updaters.js';
 import { commitSessionUpdate } from '../updaters/session-updaters.js';
-import { validateInput } from '../utils/validation-utils.js';
+import { validateInput, validateOutput } from '../utils/validation-utils.js';
 
 type EntryQueryInput = {
   +startDate: string,
   +endDate: string,
   +navID?: ?string,
   +includeDeleted?: ?boolean,
   +filters?: ?$ReadOnlyArray<CalendarFilter>,
 };
 const entryQueryInputValidator: TInterface<EntryQueryInput> = tShape({
   navID: t.maybe(t.String),
   startDate: tDate,
   endDate: tDate,
   includeDeleted: t.maybe(t.Boolean),
   filters: t.maybe(
     t.list(
       t.union([
         tShape({
           type: tString(calendarThreadFilterTypes.NOT_DELETED),
         }),
         tShape({
           type: tString(calendarThreadFilterTypes.THREAD_LIST),
           threadIDs: t.list(t.String),
         }),
       ]),
     ),
   ),
 });
 
 const newEntryQueryInputValidator: TInterface<CalendarQuery> = tShape({
   startDate: tDate,
   endDate: tDate,
   filters: t.list(
     t.union([
       tShape({
         type: tString(calendarThreadFilterTypes.NOT_DELETED),
       }),
       tShape({
         type: tString(calendarThreadFilterTypes.THREAD_LIST),
         threadIDs: t.list(t.String),
       }),
     ]),
   ),
 });
 
 function normalizeCalendarQuery(input: any): CalendarQuery {
   if (input.filters) {
     return {
       startDate: input.startDate,
       endDate: input.endDate,
       filters: input.filters,
     };
   }
   const filters = [];
   if (!input.includeDeleted) {
     filters.push({ type: calendarThreadFilterTypes.NOT_DELETED });
   }
   if (input.navID !== 'home') {
     filters.push({
       type: calendarThreadFilterTypes.THREAD_LIST,
       threadIDs: [input.navID],
     });
   }
   return {
     startDate: input.startDate,
     endDate: input.endDate,
     filters,
   };
 }
 
 async function verifyCalendarQueryThreadIDs(
   request: CalendarQuery,
 ): Promise<void> {
   const threadIDsToFilterTo = filteredThreadIDs(request.filters);
   if (threadIDsToFilterTo && threadIDsToFilterTo.size > 0) {
     const verifiedThreadIDs = await verifyThreadIDs([...threadIDsToFilterTo]);
     if (verifiedThreadIDs.length !== threadIDsToFilterTo.size) {
       throw new ServerError('invalid_parameters');
     }
   }
 }
 
 export const fetchEntryInfosResponseValidator: TInterface<FetchEntryInfosResponse> =
   tShape<FetchEntryInfosResponse>({
     rawEntryInfos: t.list(rawEntryInfoValidator),
     userInfos: t.dict(t.String, accountUserInfoValidator),
   });
 
 async function entryFetchResponder(
   viewer: Viewer,
   input: any,
 ): Promise<FetchEntryInfosResponse> {
   await validateInput(viewer, entryQueryInputValidator, input);
   const request = normalizeCalendarQuery(input);
 
   await verifyCalendarQueryThreadIDs(request);
 
   const response = await fetchEntryInfos(viewer, [request]);
-  return { ...response, userInfos: {} };
+  return validateOutput(viewer, fetchEntryInfosResponseValidator, {
+    ...response,
+    userInfos: {},
+  });
 }
 
 const entryRevisionHistoryFetchInputValidator = tShape({
   id: t.String,
 });
 
 export const fetchEntryRevisionInfosResultValidator: TInterface<FetchEntryRevisionInfosResult> =
   tShape<FetchEntryRevisionInfosResult>({
     result: t.list(historyRevisionInfoValidator),
   });
 
 async function entryRevisionFetchResponder(
   viewer: Viewer,
   input: any,
 ): Promise<FetchEntryRevisionInfosResult> {
   const request: FetchEntryRevisionInfosRequest = input;
   await validateInput(viewer, entryRevisionHistoryFetchInputValidator, request);
   const entryHistory = await fetchEntryRevisionInfo(viewer, request.id);
-  return { result: entryHistory };
+  const response = { result: entryHistory };
+  return validateOutput(
+    viewer,
+    fetchEntryRevisionInfosResultValidator,
+    response,
+  );
 }
 
 const createEntryRequestInputValidator = tShape({
   text: t.String,
   sessionID: t.maybe(t.String),
   timestamp: t.Number,
   date: tDate,
   threadID: t.String,
   localID: t.maybe(t.String),
   calendarQuery: t.maybe(newEntryQueryInputValidator),
 });
 
 export const saveEntryResponseValidator: TInterface<SaveEntryResponse> =
   tShape<SaveEntryResponse>({
     entryID: tID,
     newMessageInfos: t.list(rawMessageInfoValidator),
     updatesResult: serverCreateUpdatesResponseValidator,
   });
 
 async function entryCreationResponder(
   viewer: Viewer,
   input: any,
 ): Promise<SaveEntryResponse> {
   const request: CreateEntryRequest = input;
   await validateInput(viewer, createEntryRequestInputValidator, request);
-  return await createEntry(viewer, request);
+  const response = await createEntry(viewer, request);
+  return validateOutput(viewer, saveEntryResponseValidator, response);
 }
 
 const saveEntryRequestInputValidator = tShape({
   entryID: t.String,
   text: t.String,
   prevText: t.String,
   sessionID: t.maybe(t.String),
   timestamp: t.Number,
   calendarQuery: t.maybe(newEntryQueryInputValidator),
 });
 
 async function entryUpdateResponder(
   viewer: Viewer,
   input: any,
 ): Promise<SaveEntryResponse> {
   const request: SaveEntryRequest = input;
   await validateInput(viewer, saveEntryRequestInputValidator, request);
-  return await updateEntry(viewer, request);
+  const response = await updateEntry(viewer, request);
+  return validateOutput(viewer, saveEntryResponseValidator, response);
 }
 
 const deleteEntryRequestInputValidator = tShape({
   entryID: t.String,
   prevText: t.String,
   sessionID: t.maybe(t.String),
   timestamp: t.Number,
   calendarQuery: t.maybe(newEntryQueryInputValidator),
 });
 
 export const deleteEntryResponseValidator: TInterface<DeleteEntryResponse> =
   tShape<DeleteEntryResponse>({
     newMessageInfos: t.list(rawMessageInfoValidator),
     threadID: tID,
     updatesResult: serverCreateUpdatesResponseValidator,
   });
 
 async function entryDeletionResponder(
   viewer: Viewer,
   input: any,
 ): Promise<DeleteEntryResponse> {
   const request: DeleteEntryRequest = input;
   await validateInput(viewer, deleteEntryRequestInputValidator, request);
-  return await deleteEntry(viewer, request);
+  const response = await deleteEntry(viewer, request);
+  return validateOutput(viewer, deleteEntryResponseValidator, response);
 }
 
 const restoreEntryRequestInputValidator = tShape({
   entryID: t.String,
   sessionID: t.maybe(t.String),
   timestamp: t.Number,
   calendarQuery: t.maybe(newEntryQueryInputValidator),
 });
 
 export const restoreEntryResponseValidator: TInterface<RestoreEntryResponse> =
   tShape<RestoreEntryResponse>({
     newMessageInfos: t.list(rawMessageInfoValidator),
     updatesResult: serverCreateUpdatesResponseValidator,
   });
 
 async function entryRestorationResponder(
   viewer: Viewer,
   input: any,
 ): Promise<RestoreEntryResponse> {
   const request: RestoreEntryRequest = input;
   await validateInput(viewer, restoreEntryRequestInputValidator, request);
-  return await restoreEntry(viewer, request);
+  const response = await restoreEntry(viewer, request);
+  return validateOutput(viewer, restoreEntryResponseValidator, response);
 }
 
 export const deltaEntryInfosResultValidator: TInterface<DeltaEntryInfosResult> =
   tShape<DeltaEntryInfosResult>({
     rawEntryInfos: t.list(rawEntryInfoValidator),
     deletedEntryIDs: t.list(tID),
     userInfos: t.list(accountUserInfoValidator),
   });
 
 async function calendarQueryUpdateResponder(
   viewer: Viewer,
   input: any,
 ): Promise<DeltaEntryInfosResult> {
   const request: CalendarQuery = input;
   await validateInput(viewer, newEntryQueryInputValidator, input);
 
   await verifyCalendarQueryThreadIDs(request);
   if (!viewer.loggedIn) {
     throw new ServerError('not_logged_in');
   }
 
   const { difference, oldCalendarQuery, sessionUpdate } =
     compareNewCalendarQuery(viewer, request);
 
   const [response] = await Promise.all([
     fetchEntriesForSession(viewer, difference, oldCalendarQuery),
     commitSessionUpdate(viewer, sessionUpdate),
   ]);
 
-  return {
+  return validateOutput(viewer, deltaEntryInfosResultValidator, {
     rawEntryInfos: response.rawEntryInfos,
     deletedEntryIDs: response.deletedEntryIDs,
     // Old clients expect userInfos object
     userInfos: [],
-  };
+  });
 }
 
 export {
   entryQueryInputValidator,
   newEntryQueryInputValidator,
   normalizeCalendarQuery,
   verifyCalendarQueryThreadIDs,
   entryFetchResponder,
   entryRevisionFetchResponder,
   entryCreationResponder,
   entryUpdateResponder,
   entryDeletionResponder,
   entryRestorationResponder,
   calendarQueryUpdateResponder,
 };
diff --git a/keyserver/src/responders/keys-responders.js b/keyserver/src/responders/keys-responders.js
index f8719d9f0..9696d9de9 100644
--- a/keyserver/src/responders/keys-responders.js
+++ b/keyserver/src/responders/keys-responders.js
@@ -1,36 +1,41 @@
 // @flow
 
 import t, { type TUnion } from 'tcomb';
 
 import type { GetSessionPublicKeysArgs } from 'lib/types/request-types.js';
 import {
   type SessionPublicKeys,
   sessionPublicKeysValidator,
 } from 'lib/types/session-types.js';
 import { tShape, tNull } from 'lib/utils/validation-utils.js';
 
 import { fetchSessionPublicKeys } from '../fetchers/key-fetchers.js';
 import type { Viewer } from '../session/viewer.js';
-import { validateInput } from '../utils/validation-utils.js';
+import { validateInput, validateOutput } from '../utils/validation-utils.js';
 
 const getSessionPublicKeysInputValidator = tShape({
   session: t.String,
 });
 
 type GetSessionPublicKeysResponse = SessionPublicKeys | null;
 export const getSessionPublicKeysResponseValidator: TUnion<GetSessionPublicKeysResponse> =
   t.union([sessionPublicKeysValidator, tNull]);
 
 async function getSessionPublicKeysResponder(
   viewer: Viewer,
   input: any,
 ): Promise<GetSessionPublicKeysResponse> {
   if (!viewer.loggedIn) {
     return null;
   }
   const request: GetSessionPublicKeysArgs = input;
   await validateInput(viewer, getSessionPublicKeysInputValidator, request);
-  return await fetchSessionPublicKeys(request.session);
+  const response = await fetchSessionPublicKeys(request.session);
+  return validateOutput(
+    viewer,
+    getSessionPublicKeysResponseValidator,
+    response,
+  );
 }
 
 export { getSessionPublicKeysResponder };
diff --git a/keyserver/src/responders/message-report-responder.js b/keyserver/src/responders/message-report-responder.js
index a0336c7aa..6844fd4c2 100644
--- a/keyserver/src/responders/message-report-responder.js
+++ b/keyserver/src/responders/message-report-responder.js
@@ -1,38 +1,39 @@
 // @flow
 
 import t, { type TInterface } from 'tcomb';
 
 import {
   type MessageReportCreationRequest,
   type MessageReportCreationResult,
 } from 'lib/types/message-report-types.js';
 import { rawMessageInfoValidator } from 'lib/types/message-types.js';
 import { tShape } from 'lib/utils/validation-utils.js';
 
 import createMessageReport from '../creators/message-report-creator.js';
 import type { Viewer } from '../session/viewer.js';
-import { validateInput } from '../utils/validation-utils.js';
+import { validateInput, validateOutput } from '../utils/validation-utils.js';
 
 const messageReportCreationRequestInputValidator = tShape({
   messageID: t.String,
 });
 
 export const messageReportCreationResultValidator: TInterface<MessageReportCreationResult> =
   tShape<MessageReportCreationResult>({ messageInfo: rawMessageInfoValidator });
 
 async function messageReportCreationResponder(
   viewer: Viewer,
   input: any,
 ): Promise<MessageReportCreationResult> {
   await validateInput(
     viewer,
     messageReportCreationRequestInputValidator,
     input,
   );
   const request: MessageReportCreationRequest = input;
 
   const rawMessageInfos = await createMessageReport(viewer, request);
-  return { messageInfo: rawMessageInfos[0] };
+  const result = { messageInfo: rawMessageInfos[0] };
+  return validateOutput(viewer, messageReportCreationResultValidator, result);
 }
 
 export { messageReportCreationResponder };
diff --git a/keyserver/src/responders/message-responders.js b/keyserver/src/responders/message-responders.js
index 513174514..74fe1fdca 100644
--- a/keyserver/src/responders/message-responders.js
+++ b/keyserver/src/responders/message-responders.js
@@ -1,438 +1,446 @@
 // @flow
 
 import invariant from 'invariant';
 import t, { type TInterface } from 'tcomb';
 
 import { onlyOneEmojiRegex } from 'lib/shared/emojis.js';
 import {
   createMediaMessageData,
   trimMessage,
 } from 'lib/shared/message-utils.js';
 import { relationshipBlockedInEitherDirection } from 'lib/shared/relationship-utils.js';
 import type { Media } from 'lib/types/media-types.js';
 import { messageTypes } from 'lib/types/message-types-enum.js';
 import {
   type SendTextMessageRequest,
   type SendMultimediaMessageRequest,
   type SendReactionMessageRequest,
   type SendEditMessageRequest,
   type FetchMessageInfosResponse,
   type FetchMessageInfosRequest,
   defaultNumberPerThread,
   type SendMessageResponse,
   type SendEditMessageResponse,
   type FetchPinnedMessagesRequest,
   type FetchPinnedMessagesResult,
   messageTruncationStatusesValidator,
   rawMessageInfoValidator,
 } from 'lib/types/message-types.js';
 import type { EditMessageData } from 'lib/types/messages/edit.js';
 import type { ReactionMessageData } from 'lib/types/messages/reaction.js';
 import type { TextMessageData } from 'lib/types/messages/text.js';
 import { threadPermissions } from 'lib/types/thread-types.js';
 import { userInfosValidator } from 'lib/types/user-types.js';
 import { ServerError } from 'lib/utils/errors.js';
 import { values } from 'lib/utils/objects.js';
 import {
   tRegex,
   tShape,
   tMediaMessageMedia,
 } from 'lib/utils/validation-utils.js';
 
 import createMessages from '../creators/message-creator.js';
 import { SQL } from '../database/database.js';
 import {
   fetchMessageInfos,
   fetchMessageInfoForLocalID,
   fetchMessageInfoByID,
   fetchThreadMessagesCount,
   fetchPinnedMessageInfos,
 } from '../fetchers/message-fetchers.js';
 import { fetchServerThreadInfos } from '../fetchers/thread-fetchers.js';
 import { checkThreadPermission } from '../fetchers/thread-permission-fetchers.js';
 import {
   fetchImages,
   fetchMediaFromMediaMessageContent,
 } from '../fetchers/upload-fetchers.js';
 import { fetchKnownUserInfos } from '../fetchers/user-fetchers.js';
 import type { Viewer } from '../session/viewer.js';
 import {
   assignImages,
   assignMessageContainerToMedia,
 } from '../updaters/upload-updaters.js';
-import { validateInput } from '../utils/validation-utils.js';
+import { validateInput, validateOutput } from '../utils/validation-utils.js';
 
 const sendTextMessageRequestInputValidator = tShape({
   threadID: t.String,
   localID: t.maybe(t.String),
   text: t.String,
   sidebarCreation: t.maybe(t.Boolean),
 });
 
 export const sendMessageResponseValidator: TInterface<SendMessageResponse> =
   tShape<SendMessageResponse>({ newMessageInfo: rawMessageInfoValidator });
 
 async function textMessageCreationResponder(
   viewer: Viewer,
   input: any,
 ): Promise<SendMessageResponse> {
   const request: SendTextMessageRequest = input;
   await validateInput(viewer, sendTextMessageRequestInputValidator, request);
 
   const { threadID, localID, text: rawText, sidebarCreation } = request;
   const text = trimMessage(rawText);
   if (!text) {
     throw new ServerError('invalid_parameters');
   }
 
   const hasPermission = await checkThreadPermission(
     viewer,
     threadID,
     threadPermissions.VOICED,
   );
   if (!hasPermission) {
     throw new ServerError('invalid_parameters');
   }
 
   let messageData: TextMessageData = {
     type: messageTypes.TEXT,
     threadID,
     creatorID: viewer.id,
     time: Date.now(),
     text,
   };
   if (localID) {
     messageData = { ...messageData, localID };
   }
   if (sidebarCreation) {
     const numMessages = await fetchThreadMessagesCount(threadID);
     if (numMessages === 2) {
       // sidebarCreation is set below to prevent double notifs from a sidebar
       // creation. We expect precisely two messages to appear before a
       // sidebarCreation: a SIDEBAR_SOURCE and a CREATE_SIDEBAR. If two users
       // attempt to create a sidebar at the same time, then both clients will
       // attempt to set sidebarCreation here, but we only want to suppress
       // notifs for the client that won the race.
       messageData = { ...messageData, sidebarCreation };
     }
   }
   const rawMessageInfos = await createMessages(viewer, [messageData]);
 
-  return { newMessageInfo: rawMessageInfos[0] };
+  const response = { newMessageInfo: rawMessageInfos[0] };
+  return validateOutput(viewer, sendMessageResponseValidator, response);
 }
 
 const fetchMessageInfosRequestInputValidator = tShape({
   cursors: t.dict(t.String, t.maybe(t.String)),
   numberPerThread: t.maybe(t.Number),
 });
 
 export const fetchMessageInfosResponseValidator: TInterface<FetchMessageInfosResponse> =
   tShape<FetchMessageInfosResponse>({
     rawMessageInfos: t.list(rawMessageInfoValidator),
     truncationStatuses: messageTruncationStatusesValidator,
     userInfos: userInfosValidator,
   });
 
 async function messageFetchResponder(
   viewer: Viewer,
   input: any,
 ): Promise<FetchMessageInfosResponse> {
   const request: FetchMessageInfosRequest = input;
   await validateInput(viewer, fetchMessageInfosRequestInputValidator, request);
   const response = await fetchMessageInfos(
     viewer,
     { threadCursors: request.cursors },
     request.numberPerThread ? request.numberPerThread : defaultNumberPerThread,
   );
-  return { ...response, userInfos: {} };
+  return validateOutput(viewer, fetchMessageInfosResponseValidator, {
+    ...response,
+    userInfos: {},
+  });
 }
 
 const sendMultimediaMessageRequestInputValidator = t.union([
   // This option is only used for messageTypes.IMAGES
   tShape({
     threadID: t.String,
     localID: t.String,
     sidebarCreation: t.maybe(t.Boolean),
     mediaIDs: t.list(t.String),
   }),
   tShape({
     threadID: t.String,
     localID: t.String,
     sidebarCreation: t.maybe(t.Boolean),
     mediaMessageContents: t.list(tMediaMessageMedia),
   }),
 ]);
 async function multimediaMessageCreationResponder(
   viewer: Viewer,
   input: any,
 ): Promise<SendMessageResponse> {
   const request: SendMultimediaMessageRequest = input;
   await validateInput(
     viewer,
     sendMultimediaMessageRequestInputValidator,
     request,
   );
 
   if (
     (request.mediaIDs && request.mediaIDs.length === 0) ||
     (request.mediaMessageContents && request.mediaMessageContents.length === 0)
   ) {
     throw new ServerError('invalid_parameters');
   }
 
   const { threadID, localID, sidebarCreation } = request;
   const hasPermission = await checkThreadPermission(
     viewer,
     threadID,
     threadPermissions.VOICED,
   );
   if (!hasPermission) {
     throw new ServerError('invalid_parameters');
   }
 
   const existingMessageInfoPromise = fetchMessageInfoForLocalID(
     viewer,
     localID,
   );
   const mediaPromise: Promise<$ReadOnlyArray<Media>> = request.mediaIDs
     ? fetchImages(viewer, request.mediaIDs)
     : fetchMediaFromMediaMessageContent(viewer, request.mediaMessageContents);
 
   const [existingMessageInfo, media] = await Promise.all([
     existingMessageInfoPromise,
     mediaPromise,
   ]);
 
   if (media.length === 0 && !existingMessageInfo) {
     throw new ServerError('invalid_parameters');
   }
 
   // We use the MULTIMEDIA type for encrypted photos
   const containsEncryptedMedia = media.some(
     m => m.type === 'encrypted_photo' || m.type === 'encrypted_video',
   );
   const messageData = createMediaMessageData(
     {
       localID,
       threadID,
       creatorID: viewer.id,
       media,
       sidebarCreation,
     },
     { forceMultimediaMessageType: containsEncryptedMedia },
   );
   const [newMessageInfo] = await createMessages(viewer, [messageData]);
   const { id } = newMessageInfo;
   invariant(
     id !== null && id !== undefined,
     'serverID should be set in createMessages result',
   );
 
   if (request.mediaIDs) {
     await assignImages(viewer, request.mediaIDs, id, threadID);
   } else {
     await assignMessageContainerToMedia(
       viewer,
       request.mediaMessageContents,
       id,
       threadID,
     );
   }
 
-  return { newMessageInfo };
+  const response = { newMessageInfo };
+  return validateOutput(viewer, sendMessageResponseValidator, response);
 }
 
 const sendReactionMessageRequestInputValidator = tShape({
   threadID: t.String,
   localID: t.maybe(t.String),
   targetMessageID: t.String,
   reaction: tRegex(onlyOneEmojiRegex),
   action: t.enums.of(['add_reaction', 'remove_reaction']),
 });
 async function reactionMessageCreationResponder(
   viewer: Viewer,
   input: any,
 ): Promise<SendMessageResponse> {
   const request: SendReactionMessageRequest = input;
   await validateInput(viewer, sendReactionMessageRequestInputValidator, input);
 
   const { threadID, localID, targetMessageID, reaction, action } = request;
 
   if (!targetMessageID || !reaction) {
     throw new ServerError('invalid_parameters');
   }
 
   const targetMessageInfo = await fetchMessageInfoByID(viewer, targetMessageID);
 
   if (!targetMessageInfo || !targetMessageInfo.id) {
     throw new ServerError('invalid_parameters');
   }
 
   const [serverThreadInfos, hasPermission, targetMessageUserInfos] =
     await Promise.all([
       fetchServerThreadInfos(SQL`t.id = ${threadID}`),
       checkThreadPermission(
         viewer,
         threadID,
         threadPermissions.REACT_TO_MESSAGE,
       ),
       fetchKnownUserInfos(viewer, [targetMessageInfo.creatorID]),
     ]);
 
   const targetMessageThreadInfo = serverThreadInfos.threadInfos[threadID];
   if (targetMessageThreadInfo.sourceMessageID === targetMessageID) {
     throw new ServerError('invalid_parameters');
   }
 
   const targetMessageCreator =
     targetMessageUserInfos[targetMessageInfo.creatorID];
 
   const targetMessageCreatorRelationship =
     targetMessageCreator?.relationshipStatus;
 
   const creatorRelationshipHasBlock =
     targetMessageCreatorRelationship &&
     relationshipBlockedInEitherDirection(targetMessageCreatorRelationship);
 
   if (!hasPermission || creatorRelationshipHasBlock) {
     throw new ServerError('invalid_parameters');
   }
 
   let messageData: ReactionMessageData = {
     type: messageTypes.REACTION,
     threadID,
     creatorID: viewer.id,
     time: Date.now(),
     targetMessageID,
     reaction,
     action,
   };
   if (localID) {
     messageData = { ...messageData, localID };
   }
 
   const rawMessageInfos = await createMessages(viewer, [messageData]);
 
-  return { newMessageInfo: rawMessageInfos[0] };
+  const response = { newMessageInfo: rawMessageInfos[0] };
+  return validateOutput(viewer, sendMessageResponseValidator, response);
 }
 
 const editMessageRequestInputValidator = tShape({
   targetMessageID: t.String,
   text: t.String,
 });
 
 export const sendEditMessageResponseValidator: TInterface<SendEditMessageResponse> =
   tShape<SendEditMessageResponse>({
     newMessageInfos: t.list(rawMessageInfoValidator),
   });
 
 async function editMessageCreationResponder(
   viewer: Viewer,
   input: any,
 ): Promise<SendEditMessageResponse> {
   const request: SendEditMessageRequest = input;
   await validateInput(viewer, editMessageRequestInputValidator, input);
 
   const { targetMessageID, text: rawText } = request;
   const text = trimMessage(rawText);
   if (!targetMessageID || !text) {
     throw new ServerError('invalid_parameters');
   }
 
   const targetMessageInfo = await fetchMessageInfoByID(viewer, targetMessageID);
   if (!targetMessageInfo || !targetMessageInfo.id) {
     throw new ServerError('invalid_parameters');
   }
 
   if (targetMessageInfo.type !== messageTypes.TEXT) {
     throw new ServerError('invalid_parameters');
   }
 
   const { threadID } = targetMessageInfo;
 
   const [serverThreadInfos, hasPermission, rawSidebarThreadInfos] =
     await Promise.all([
       fetchServerThreadInfos(SQL`t.id = ${threadID}`),
       checkThreadPermission(viewer, threadID, threadPermissions.EDIT_MESSAGE),
       fetchServerThreadInfos(
         SQL`t.parent_thread_id = ${threadID} AND t.source_message = ${targetMessageID}`,
       ),
     ]);
 
   const targetMessageThreadInfo = serverThreadInfos.threadInfos[threadID];
   if (targetMessageThreadInfo.sourceMessageID === targetMessageID) {
     // We are editing first message of the sidebar
     // If client wants to do that it sends id of the sourceMessage instead
     throw new ServerError('invalid_parameters');
   }
 
   if (!hasPermission) {
     throw new ServerError('invalid_parameters');
   }
 
   if (targetMessageInfo.creatorID !== viewer.id) {
     throw new ServerError('invalid_parameters');
   }
 
   const time = Date.now();
   const messagesData = [];
   let messageData: EditMessageData = {
     type: messageTypes.EDIT_MESSAGE,
     threadID,
     creatorID: viewer.id,
     time,
     targetMessageID,
     text,
   };
   messagesData.push(messageData);
 
   const sidebarThreadValues = values(rawSidebarThreadInfos.threadInfos);
   for (const sidebarThreadValue of sidebarThreadValues) {
     if (sidebarThreadValue && sidebarThreadValue.id) {
       messageData = {
         type: messageTypes.EDIT_MESSAGE,
         threadID: sidebarThreadValue.id,
         creatorID: viewer.id,
         time,
         targetMessageID,
         text: text,
       };
       messagesData.push(messageData);
     }
   }
 
   const newMessageInfos = await createMessages(viewer, messagesData);
 
-  return { newMessageInfos };
+  const response = { newMessageInfos };
+  return validateOutput(viewer, sendEditMessageResponseValidator, response);
 }
 
 const fetchPinnedMessagesResponderInputValidator = tShape({
   threadID: t.String,
 });
 
 export const fetchPinnedMessagesResultValidator: TInterface<FetchPinnedMessagesResult> =
   tShape<FetchPinnedMessagesResult>({
     pinnedMessages: t.list(rawMessageInfoValidator),
   });
 
 async function fetchPinnedMessagesResponder(
   viewer: Viewer,
   input: any,
 ): Promise<FetchPinnedMessagesResult> {
   const request: FetchPinnedMessagesRequest = input;
   await validateInput(
     viewer,
     fetchPinnedMessagesResponderInputValidator,
     input,
   );
-  return await fetchPinnedMessageInfos(viewer, request);
+  const response = await fetchPinnedMessageInfos(viewer, request);
+  return validateOutput(viewer, fetchPinnedMessagesResultValidator, response);
 }
 
 export {
   textMessageCreationResponder,
   messageFetchResponder,
   multimediaMessageCreationResponder,
   reactionMessageCreationResponder,
   editMessageCreationResponder,
   fetchPinnedMessagesResponder,
 };
diff --git a/keyserver/src/responders/relationship-responders.js b/keyserver/src/responders/relationship-responders.js
index 7f96bb94d..95e1829bd 100644
--- a/keyserver/src/responders/relationship-responders.js
+++ b/keyserver/src/responders/relationship-responders.js
@@ -1,37 +1,38 @@
 // @flow
 
 import t, { type TInterface } from 'tcomb';
 
 import {
   type RelationshipRequest,
   type RelationshipErrors,
   relationshipActionsList,
 } from 'lib/types/relationship-types.js';
 import { tShape } from 'lib/utils/validation-utils.js';
 
 import type { Viewer } from '../session/viewer.js';
 import { updateRelationships } from '../updaters/relationship-updaters.js';
-import { validateInput } from '../utils/validation-utils.js';
+import { validateInput, validateOutput } from '../utils/validation-utils.js';
 
 const updateRelationshipInputValidator = tShape({
   action: t.enums.of(relationshipActionsList, 'relationship action'),
   userIDs: t.list(t.String),
 });
 
 export const relationshipErrorsValidator: TInterface<RelationshipErrors> =
   tShape<RelationshipErrors>({
     invalid_user: t.maybe(t.list(t.String)),
     already_friends: t.maybe(t.list(t.String)),
     user_blocked: t.maybe(t.list(t.String)),
   });
 
 async function updateRelationshipsResponder(
   viewer: Viewer,
   input: any,
 ): Promise<RelationshipErrors> {
   const request: RelationshipRequest = input;
   await validateInput(viewer, updateRelationshipInputValidator, request);
-  return await updateRelationships(viewer, request);
+  const response = await updateRelationships(viewer, request);
+  return validateOutput(viewer, relationshipErrorsValidator, response);
 }
 
 export { updateRelationshipsResponder };
diff --git a/keyserver/src/responders/report-responders.js b/keyserver/src/responders/report-responders.js
index 290bb68c1..f5669a4c1 100644
--- a/keyserver/src/responders/report-responders.js
+++ b/keyserver/src/responders/report-responders.js
@@ -1,254 +1,259 @@
 // @flow
 
 import type { $Response, $Request } from 'express';
 import t from 'tcomb';
 import type { TInterface, TStructProps } from 'tcomb';
 
 import {
   type ReportCreationResponse,
   type ReportCreationRequest,
   type FetchErrorReportInfosResponse,
   type FetchErrorReportInfosRequest,
   type ThreadInconsistencyReportShape,
   type EntryInconsistencyReportShape,
   reportTypes,
   reportInfoValidator,
 } from 'lib/types/report-types.js';
 import { userInfoValidator } from 'lib/types/user-types.js';
 import { ServerError } from 'lib/utils/errors.js';
 import {
   tShape,
   tPlatform,
   tPlatformDetails,
 } from 'lib/utils/validation-utils.js';
 
 import { newEntryQueryInputValidator } from './entry-responders.js';
 import createReport from '../creators/report-creator.js';
 import {
   fetchErrorReportInfos,
   fetchReduxToolsImport,
 } from '../fetchers/report-fetchers.js';
 import type { Viewer } from '../session/viewer.js';
-import { validateInput } from '../utils/validation-utils.js';
+import { validateInput, validateOutput } from '../utils/validation-utils.js';
 
 const tActionSummary = tShape({
   type: t.String,
   time: t.Number,
   summary: t.String,
 });
 const threadInconsistencyReportValidatorShape: TStructProps<ThreadInconsistencyReportShape> =
   {
     platformDetails: tPlatformDetails,
     beforeAction: t.Object,
     action: t.Object,
     pollResult: t.maybe(t.Object),
     pushResult: t.Object,
     lastActionTypes: t.maybe(t.list(t.String)),
     lastActions: t.maybe(t.list(tActionSummary)),
     time: t.maybe(t.Number),
   };
 const entryInconsistencyReportValidatorShape: TStructProps<EntryInconsistencyReportShape> =
   {
     platformDetails: tPlatformDetails,
     beforeAction: t.Object,
     action: t.Object,
     calendarQuery: newEntryQueryInputValidator,
     pollResult: t.maybe(t.Object),
     pushResult: t.Object,
     lastActionTypes: t.maybe(t.list(t.String)),
     lastActions: t.maybe(t.list(tActionSummary)),
     time: t.Number,
   };
 const userInconsistencyReportValidatorShape = {
   platformDetails: tPlatformDetails,
   action: t.Object,
   beforeStateCheck: t.Object,
   afterStateCheck: t.Object,
   lastActions: t.list(tActionSummary),
   time: t.Number,
 };
 
 const threadInconsistencyReportCreationRequest = tShape({
   ...threadInconsistencyReportValidatorShape,
   type: t.irreducible(
     'reportTypes.THREAD_INCONSISTENCY',
     x => x === reportTypes.THREAD_INCONSISTENCY,
   ),
 });
 
 const entryInconsistencyReportCreationRquest = tShape({
   ...entryInconsistencyReportValidatorShape,
   type: t.irreducible(
     'reportTypes.ENTRY_INCONSISTENCY',
     x => x === reportTypes.ENTRY_INCONSISTENCY,
   ),
 });
 
 const mediaMissionReportCreationRequest = tShape({
   type: t.irreducible(
     'reportTypes.MEDIA_MISSION',
     x => x === reportTypes.MEDIA_MISSION,
   ),
   platformDetails: tPlatformDetails,
   time: t.Number,
   mediaMission: t.Object,
   uploadServerID: t.maybe(t.String),
   uploadLocalID: t.maybe(t.String),
   mediaLocalID: t.maybe(t.String),
   messageServerID: t.maybe(t.String),
   messageLocalID: t.maybe(t.String),
 });
 
 const userInconsistencyReportCreationRequest = tShape({
   ...userInconsistencyReportValidatorShape,
   type: t.irreducible(
     'reportTypes.USER_INCONSISTENCY',
     x => x === reportTypes.USER_INCONSISTENCY,
   ),
 });
 
 const reportCreationRequestInputValidator = t.union([
   tShape({
     type: t.maybe(
       t.irreducible('reportTypes.ERROR', x => x === reportTypes.ERROR),
     ),
     platformDetails: t.maybe(tPlatformDetails),
     deviceType: t.maybe(tPlatform),
     codeVersion: t.maybe(t.Number),
     stateVersion: t.maybe(t.Number),
     errors: t.list(
       tShape({
         errorMessage: t.String,
         stack: t.maybe(t.String),
         componentStack: t.maybe(t.String),
       }),
     ),
     preloadedState: t.Object,
     currentState: t.Object,
     actions: t.list(t.union([t.Object, t.String])),
   }),
   threadInconsistencyReportCreationRequest,
   entryInconsistencyReportCreationRquest,
   mediaMissionReportCreationRequest,
   userInconsistencyReportCreationRequest,
 ]);
 
 export const reportCreationResponseValidator: TInterface<ReportCreationResponse> =
   tShape<ReportCreationResponse>({ id: t.String });
 
 async function reportCreationResponder(
   viewer: Viewer,
   input: any,
 ): Promise<ReportCreationResponse> {
   await validateInput(viewer, reportCreationRequestInputValidator, input);
   if (input.type === null || input.type === undefined) {
     input.type = reportTypes.ERROR;
   }
   if (!input.platformDetails && input.deviceType) {
     const { deviceType, codeVersion, stateVersion, ...rest } = input;
     input = {
       ...rest,
       platformDetails: { platform: deviceType, codeVersion, stateVersion },
     };
   }
   const request: ReportCreationRequest = input;
   const response = await createReport(viewer, request);
   if (!response) {
     throw new ServerError('ignored_report');
   }
-  return response;
+  return validateOutput(viewer, reportCreationResponseValidator, response);
 }
 
 const reportMultiCreationRequestInputValidator = tShape({
   reports: t.list(
     t.union([
       tShape({
         type: t.irreducible('reportTypes.ERROR', x => x === reportTypes.ERROR),
         platformDetails: tPlatformDetails,
         errors: t.list(
           tShape({
             errorMessage: t.String,
             stack: t.maybe(t.String),
             componentStack: t.maybe(t.String),
           }),
         ),
         preloadedState: t.Object,
         currentState: t.Object,
         actions: t.list(t.union([t.Object, t.String])),
       }),
       threadInconsistencyReportCreationRequest,
       entryInconsistencyReportCreationRquest,
       mediaMissionReportCreationRequest,
       userInconsistencyReportCreationRequest,
     ]),
   ),
 });
 
 type ReportMultiCreationRequest = {
   reports: $ReadOnlyArray<ReportCreationRequest>,
 };
 async function reportMultiCreationResponder(
   viewer: Viewer,
   input: any,
 ): Promise<void> {
   const request: ReportMultiCreationRequest = input;
   await validateInput(
     viewer,
     reportMultiCreationRequestInputValidator,
     request,
   );
   await Promise.all(
     request.reports.map(reportCreationRequest =>
       createReport(viewer, reportCreationRequest),
     ),
   );
 }
 
 const fetchErrorReportInfosRequestInputValidator = tShape({
   cursor: t.maybe(t.String),
 });
 
 export const fetchErrorReportInfosResponseValidator: TInterface<FetchErrorReportInfosResponse> =
   tShape<FetchErrorReportInfosResponse>({
     reports: t.list(reportInfoValidator),
     userInfos: t.list(userInfoValidator),
   });
 
 async function errorReportFetchInfosResponder(
   viewer: Viewer,
   input: any,
 ): Promise<FetchErrorReportInfosResponse> {
   const request: FetchErrorReportInfosRequest = input;
   await validateInput(
     viewer,
     fetchErrorReportInfosRequestInputValidator,
     request,
   );
-  return await fetchErrorReportInfos(viewer, request);
+  const response = await fetchErrorReportInfos(viewer, request);
+  return validateOutput(
+    viewer,
+    fetchErrorReportInfosResponseValidator,
+    response,
+  );
 }
 
 async function errorReportDownloadResponder(
   viewer: Viewer,
   req: $Request,
   res: $Response,
 ): Promise<void> {
   const id = req.params.reportID;
   if (!id) {
     throw new ServerError('invalid_parameters');
   }
   const result = await fetchReduxToolsImport(viewer, id);
   res.set('Content-Disposition', `attachment; filename=report-${id}.json`);
   res.json({
     preloadedState: JSON.stringify(result.preloadedState),
     payload: JSON.stringify(result.payload),
   });
 }
 
 export {
   threadInconsistencyReportValidatorShape,
   entryInconsistencyReportValidatorShape,
   reportCreationResponder,
   reportMultiCreationResponder,
   errorReportFetchInfosResponder,
   errorReportDownloadResponder,
 };
diff --git a/keyserver/src/responders/search-responders.js b/keyserver/src/responders/search-responders.js
index 7008add66..3762b7151 100644
--- a/keyserver/src/responders/search-responders.js
+++ b/keyserver/src/responders/search-responders.js
@@ -1,35 +1,36 @@
 // @flow
 
 import t, { type TInterface } from 'tcomb';
 
 import type {
   UserSearchRequest,
   UserSearchResult,
 } from 'lib/types/search-types.js';
 import { globalAccountUserInfoValidator } from 'lib/types/user-types.js';
 import { tShape } from 'lib/utils/validation-utils.js';
 
 import { searchForUsers } from '../search/users.js';
 import type { Viewer } from '../session/viewer.js';
-import { validateInput } from '../utils/validation-utils.js';
+import { validateInput, validateOutput } from '../utils/validation-utils.js';
 
 const userSearchRequestInputValidator = tShape({
   prefix: t.maybe(t.String),
 });
 
 export const userSearchResultValidator: TInterface<UserSearchResult> =
   tShape<UserSearchResult>({
     userInfos: t.list(globalAccountUserInfoValidator),
   });
 
 async function userSearchResponder(
   viewer: Viewer,
   input: any,
 ): Promise<UserSearchResult> {
   const request: UserSearchRequest = input;
   await validateInput(viewer, userSearchRequestInputValidator, request);
   const searchResults = await searchForUsers(request);
-  return { userInfos: searchResults };
+  const result = { userInfos: searchResults };
+  return validateOutput(viewer, userSearchResultValidator, result);
 }
 
 export { userSearchResponder };
diff --git a/keyserver/src/responders/thread-responders.js b/keyserver/src/responders/thread-responders.js
index 7920421f0..86020324b 100644
--- a/keyserver/src/responders/thread-responders.js
+++ b/keyserver/src/responders/thread-responders.js
@@ -1,290 +1,299 @@
 // @flow
 
 import t from 'tcomb';
 import type { TInterface, TUnion } from 'tcomb';
 
 import { rawEntryInfoValidator } from 'lib/types/entry-types.js';
 import { mediaValidator } from 'lib/types/media-types.js';
 import {
   rawMessageInfoValidator,
   messageTruncationStatusesValidator,
 } from 'lib/types/message-types.js';
 import {
   type ThreadDeletionRequest,
   type RoleChangeRequest,
   type ChangeThreadSettingsResult,
   type RemoveMembersRequest,
   type LeaveThreadRequest,
   type LeaveThreadResult,
   type UpdateThreadRequest,
   type ServerNewThreadRequest,
   type NewThreadResponse,
   type ServerThreadJoinRequest,
   type ThreadJoinResult,
   type ThreadFetchMediaResult,
   type ThreadFetchMediaRequest,
   type ToggleMessagePinRequest,
   type ToggleMessagePinResult,
   threadTypes,
   rawThreadInfoValidator,
 } from 'lib/types/thread-types.js';
 import { serverUpdateInfoValidator } from 'lib/types/update-types.js';
 import { userInfosValidator } from 'lib/types/user-types.js';
 import { updateUserAvatarRequestValidator } from 'lib/utils/avatar-utils.js';
 import { values } from 'lib/utils/objects.js';
 import {
   tShape,
   tNumEnum,
   tColor,
   tPassword,
   tID,
 } from 'lib/utils/validation-utils.js';
 
 import {
   entryQueryInputValidator,
   verifyCalendarQueryThreadIDs,
 } from './entry-responders.js';
 import { createThread } from '../creators/thread-creator.js';
 import { deleteThread } from '../deleters/thread-deleters.js';
 import { fetchMediaForThread } from '../fetchers/upload-fetchers.js';
 import type { Viewer } from '../session/viewer.js';
 import {
   updateRole,
   removeMembers,
   leaveThread,
   updateThread,
   joinThread,
   toggleMessagePinForThread,
 } from '../updaters/thread-updaters.js';
-import { validateInput } from '../utils/validation-utils.js';
+import { validateInput, validateOutput } from '../utils/validation-utils.js';
 
 const threadDeletionRequestInputValidator = tShape({
   threadID: t.String,
   accountPassword: t.maybe(tPassword),
 });
 
 export const leaveThreadResultValidator: TInterface<LeaveThreadResult> =
   tShape<LeaveThreadResult>({
     threadInfos: t.maybe(t.dict(tID, rawThreadInfoValidator)),
     updatesResult: tShape({
       newUpdates: t.list(serverUpdateInfoValidator),
     }),
   });
 
 async function threadDeletionResponder(
   viewer: Viewer,
   input: any,
 ): Promise<LeaveThreadResult> {
   const request: ThreadDeletionRequest = input;
   await validateInput(viewer, threadDeletionRequestInputValidator, request);
-  return await deleteThread(viewer, request);
+  const result = await deleteThread(viewer, request);
+  return validateOutput(viewer, leaveThreadResultValidator, result);
 }
 
 const roleChangeRequestInputValidator = tShape({
   threadID: t.String,
   memberIDs: t.list(t.String),
   role: t.refinement(t.String, str => {
     const int = parseInt(str, 10);
     return String(int) === str && int > 0;
   }),
 });
 
 export const changeThreadSettingsResultValidator: TInterface<ChangeThreadSettingsResult> =
   tShape<ChangeThreadSettingsResult>({
     newMessageInfos: t.list(rawMessageInfoValidator),
     threadInfo: t.maybe(rawThreadInfoValidator),
     threadInfos: t.maybe(t.dict(tID, rawThreadInfoValidator)),
     updatesResult: tShape({
       newUpdates: t.list(serverUpdateInfoValidator),
     }),
   });
 
 async function roleUpdateResponder(
   viewer: Viewer,
   input: any,
 ): Promise<ChangeThreadSettingsResult> {
   const request: RoleChangeRequest = input;
   await validateInput(viewer, roleChangeRequestInputValidator, request);
-  return await updateRole(viewer, request);
+  const result = await updateRole(viewer, request);
+  return validateOutput(viewer, changeThreadSettingsResultValidator, result);
 }
 
 const removeMembersRequestInputValidator = tShape({
   threadID: t.String,
   memberIDs: t.list(t.String),
 });
 
 async function memberRemovalResponder(
   viewer: Viewer,
   input: any,
 ): Promise<ChangeThreadSettingsResult> {
   const request: RemoveMembersRequest = input;
   await validateInput(viewer, removeMembersRequestInputValidator, request);
-  return await removeMembers(viewer, request);
+  const result = await removeMembers(viewer, request);
+  return validateOutput(viewer, changeThreadSettingsResultValidator, result);
 }
 
 const leaveThreadRequestInputValidator = tShape({
   threadID: t.String,
 });
 
 async function threadLeaveResponder(
   viewer: Viewer,
   input: any,
 ): Promise<LeaveThreadResult> {
   const request: LeaveThreadRequest = input;
   await validateInput(viewer, leaveThreadRequestInputValidator, request);
-  return await leaveThread(viewer, request);
+  const result = await leaveThread(viewer, request);
+  return validateOutput(viewer, leaveThreadResultValidator, result);
 }
 
 const updateThreadRequestInputValidator = tShape({
   threadID: t.String,
   changes: tShape({
     type: t.maybe(tNumEnum(values(threadTypes))),
     name: t.maybe(t.String),
     description: t.maybe(t.String),
     color: t.maybe(tColor),
     parentThreadID: t.maybe(t.String),
     newMemberIDs: t.maybe(t.list(t.String)),
     avatar: t.maybe(updateUserAvatarRequestValidator),
   }),
   accountPassword: t.maybe(tPassword),
 });
 
 async function threadUpdateResponder(
   viewer: Viewer,
   input: any,
 ): Promise<ChangeThreadSettingsResult> {
   const request: UpdateThreadRequest = input;
   await validateInput(viewer, updateThreadRequestInputValidator, request);
-  return await updateThread(viewer, request);
+  const result = await updateThread(viewer, request);
+  return validateOutput(viewer, changeThreadSettingsResultValidator, result);
 }
 
 const threadRequestValidationShape = {
   name: t.maybe(t.String),
   description: t.maybe(t.String),
   color: t.maybe(tColor),
   parentThreadID: t.maybe(t.String),
   initialMemberIDs: t.maybe(t.list(t.String)),
   calendarQuery: t.maybe(entryQueryInputValidator),
 };
 const newThreadRequestInputValidator: TUnion<ServerNewThreadRequest> = t.union([
   tShape({
     type: tNumEnum([threadTypes.SIDEBAR]),
     sourceMessageID: t.String,
     ...threadRequestValidationShape,
   }),
   tShape({
     type: tNumEnum([
       threadTypes.COMMUNITY_OPEN_SUBTHREAD,
       threadTypes.COMMUNITY_SECRET_SUBTHREAD,
       threadTypes.PERSONAL,
       threadTypes.LOCAL,
     ]),
     ...threadRequestValidationShape,
   }),
 ]);
 
 export const newThreadResponseValidator: TInterface<NewThreadResponse> =
   tShape<NewThreadResponse>({
     updatesResult: tShape({
       newUpdates: t.list(serverUpdateInfoValidator),
     }),
     newMessageInfos: t.list(rawMessageInfoValidator),
     newThreadInfo: t.maybe(rawThreadInfoValidator),
     userInfos: userInfosValidator,
     newThreadID: t.maybe(tID),
   });
 
 async function threadCreationResponder(
   viewer: Viewer,
   input: any,
 ): Promise<NewThreadResponse> {
   const request: ServerNewThreadRequest = input;
   await validateInput(viewer, newThreadRequestInputValidator, request);
 
-  return await createThread(viewer, request, {
+  const result = await createThread(viewer, request, {
     silentlyFailMembers: request.type === threadTypes.SIDEBAR,
   });
+  return validateOutput(viewer, newThreadResponseValidator, result);
 }
 
 const joinThreadRequestInputValidator = tShape({
   threadID: t.String,
   calendarQuery: t.maybe(entryQueryInputValidator),
   inviteLinkSecret: t.maybe(t.String),
 });
 
 export const threadJoinResultValidator: TInterface<ThreadJoinResult> =
   tShape<ThreadJoinResult>({
     threadInfos: t.maybe(t.dict(tID, rawThreadInfoValidator)),
     updatesResult: tShape({
       newUpdates: t.list(serverUpdateInfoValidator),
     }),
     rawMessageInfos: t.list(rawMessageInfoValidator),
     truncationStatuses: messageTruncationStatusesValidator,
     userInfos: userInfosValidator,
     rawEntryInfos: t.maybe(t.list(rawEntryInfoValidator)),
   });
 
 async function threadJoinResponder(
   viewer: Viewer,
   input: any,
 ): Promise<ThreadJoinResult> {
   const request: ServerThreadJoinRequest = input;
   await validateInput(viewer, joinThreadRequestInputValidator, request);
 
   if (request.calendarQuery) {
     await verifyCalendarQueryThreadIDs(request.calendarQuery);
   }
 
-  return await joinThread(viewer, request);
+  const result = await joinThread(viewer, request);
+  return validateOutput(viewer, threadJoinResultValidator, result);
 }
 
 const threadFetchMediaRequestInputValidator = tShape({
   threadID: t.String,
   limit: t.Number,
   offset: t.Number,
 });
 
 export const threadFetchMediaResultValidator: TInterface<ThreadFetchMediaResult> =
   tShape<ThreadFetchMediaResult>({ media: t.list(mediaValidator) });
 
 async function threadFetchMediaResponder(
   viewer: Viewer,
   input: any,
 ): Promise<ThreadFetchMediaResult> {
   const request: ThreadFetchMediaRequest = input;
   await validateInput(viewer, threadFetchMediaRequestInputValidator, request);
-  return await fetchMediaForThread(viewer, request);
+  const result = await fetchMediaForThread(viewer, request);
+  return validateOutput(viewer, threadFetchMediaResultValidator, result);
 }
 
 const toggleMessagePinRequestInputValidator = tShape({
   messageID: t.String,
   action: t.enums.of(['pin', 'unpin']),
 });
 
 export const toggleMessagePinResultValidator: TInterface<ToggleMessagePinResult> =
   tShape<ToggleMessagePinResult>({
     newMessageInfos: t.list(rawMessageInfoValidator),
     threadID: tID,
   });
 
 async function toggleMessagePinResponder(
   viewer: Viewer,
   input: any,
 ): Promise<ToggleMessagePinResult> {
   const request: ToggleMessagePinRequest = input;
   await validateInput(viewer, toggleMessagePinRequestInputValidator, request);
-  return await toggleMessagePinForThread(viewer, request);
+  const result = await toggleMessagePinForThread(viewer, request);
+  return validateOutput(viewer, toggleMessagePinResultValidator, result);
 }
 
 export {
   threadDeletionResponder,
   roleUpdateResponder,
   memberRemovalResponder,
   threadLeaveResponder,
   threadUpdateResponder,
   threadCreationResponder,
   threadJoinResponder,
   threadFetchMediaResponder,
   newThreadRequestInputValidator,
   toggleMessagePinResponder,
 };
diff --git a/keyserver/src/responders/user-responders.js b/keyserver/src/responders/user-responders.js
index b2d07d0ed..386a12e7c 100644
--- a/keyserver/src/responders/user-responders.js
+++ b/keyserver/src/responders/user-responders.js
@@ -1,717 +1,737 @@
 // @flow
 
 import type { Utility as OlmUtility } from '@commapp/olm';
 import invariant from 'invariant';
 import { ErrorTypes, SiweMessage } from 'siwe';
 import t, { type TInterface } from 'tcomb';
 import bcrypt from 'twin-bcrypt';
 
 import {
   baseLegalPolicies,
   policies,
   policyTypeValidator,
 } from 'lib/facts/policies.js';
 import { hasMinCodeVersion } from 'lib/shared/version-utils.js';
 import type {
   ResetPasswordRequest,
   LogOutResponse,
   DeleteAccountRequest,
   RegisterResponse,
   RegisterRequest,
   LogInResponse,
   LogInRequest,
   UpdatePasswordRequest,
   UpdateUserSettingsRequest,
   PolicyAcknowledgmentRequest,
 } from 'lib/types/account-types.js';
 import {
   userSettingsTypes,
   notificationTypeValues,
   logInActionSources,
 } from 'lib/types/account-types.js';
-import type {
-  ClientAvatar,
-  UpdateUserAvatarRequest,
-  UpdateUserAvatarResponse,
+import {
+  type ClientAvatar,
+  clientAvatarValidator,
+  type UpdateUserAvatarRequest,
+  type UpdateUserAvatarResponse,
 } from 'lib/types/avatar-types.js';
 import type {
   IdentityKeysBlob,
   SignedIdentityKeysBlob,
 } from 'lib/types/crypto-types.js';
 import {
   type CalendarQuery,
   rawEntryInfoValidator,
 } from 'lib/types/entry-types.js';
 import {
   defaultNumberPerThread,
   rawMessageInfoValidator,
   messageTruncationStatusesValidator,
 } from 'lib/types/message-types.js';
 import type {
   SIWEAuthRequest,
   SIWEMessage,
   SIWESocialProof,
 } from 'lib/types/siwe-types.js';
 import {
   type SubscriptionUpdateRequest,
   type SubscriptionUpdateResponse,
   threadSubscriptionValidator,
 } from 'lib/types/subscription-types.js';
 import { rawThreadInfoValidator } from 'lib/types/thread-types.js';
+import { createUpdatesResultValidator } from 'lib/types/update-types.js';
 import {
   type PasswordUpdate,
   loggedOutUserInfoValidator,
   loggedInUserInfoValidator,
   oldLoggedInUserInfoValidator,
   userInfoValidator,
 } from 'lib/types/user-types.js';
 import { updateUserAvatarRequestValidator } from 'lib/utils/avatar-utils.js';
 import {
   identityKeysBlobValidator,
   signedIdentityKeysBlobValidator,
 } from 'lib/utils/crypto-utils.js';
 import { ServerError } from 'lib/utils/errors.js';
 import { values } from 'lib/utils/objects.js';
 import { promiseAll } from 'lib/utils/promises.js';
 import {
   getPublicKeyFromSIWEStatement,
   isValidSIWEMessage,
   isValidSIWEStatementWithPublicKey,
   primaryIdentityPublicKeyRegex,
 } from 'lib/utils/siwe-utils.js';
 import {
   tShape,
   tPlatformDetails,
   tPassword,
   tEmail,
   tOldValidUsername,
   tRegex,
   tID,
 } from 'lib/utils/validation-utils.js';
 
 import {
   entryQueryInputValidator,
   newEntryQueryInputValidator,
   normalizeCalendarQuery,
   verifyCalendarQueryThreadIDs,
 } from './entry-responders.js';
 import {
   createAccount,
   processSIWEAccountCreation,
 } from '../creators/account-creator.js';
 import { dbQuery, SQL } from '../database/database.js';
 import { deleteAccount } from '../deleters/account-deleters.js';
 import { deleteCookie } from '../deleters/cookie-deleters.js';
 import { checkAndInvalidateSIWENonceEntry } from '../deleters/siwe-nonce-deleters.js';
 import { fetchEntryInfos } from '../fetchers/entry-fetchers.js';
 import { fetchMessageInfos } from '../fetchers/message-fetchers.js';
 import { fetchNotAcknowledgedPolicies } from '../fetchers/policy-acknowledgment-fetchers.js';
 import { fetchThreadInfos } from '../fetchers/thread-fetchers.js';
 import {
   fetchKnownUserInfos,
   fetchLoggedInUserInfo,
   fetchUserIDForEthereumAddress,
 } from '../fetchers/user-fetchers.js';
 import {
   createNewAnonymousCookie,
   createNewUserCookie,
   setNewSession,
 } from '../session/cookies.js';
 import type { Viewer } from '../session/viewer.js';
 import {
   accountUpdater,
   checkAndSendVerificationEmail,
   checkAndSendPasswordResetEmail,
   updatePassword,
   updateUserSettings,
   updateUserAvatar,
 } from '../updaters/account-updaters.js';
 import { userSubscriptionUpdater } from '../updaters/user-subscription-updaters.js';
 import { viewerAcknowledgmentUpdater } from '../updaters/viewer-acknowledgment-updater.js';
 import { getOlmUtility } from '../utils/olm-utils.js';
-import { validateInput } from '../utils/validation-utils.js';
+import { validateInput, validateOutput } from '../utils/validation-utils.js';
 
 const subscriptionUpdateRequestInputValidator = tShape({
   threadID: t.String,
   updatedFields: tShape({
     pushNotifs: t.maybe(t.Boolean),
     home: t.maybe(t.Boolean),
   }),
 });
 
 export const subscriptionUpdateResponseValidator: TInterface<SubscriptionUpdateResponse> =
   tShape<SubscriptionUpdateResponse>({
     threadSubscription: threadSubscriptionValidator,
   });
 
 async function userSubscriptionUpdateResponder(
   viewer: Viewer,
   input: any,
 ): Promise<SubscriptionUpdateResponse> {
   const request: SubscriptionUpdateRequest = input;
   await validateInput(viewer, subscriptionUpdateRequestInputValidator, request);
   const threadSubscription = await userSubscriptionUpdater(viewer, request);
-  return { threadSubscription };
+  return validateOutput(viewer, subscriptionUpdateResponseValidator, {
+    threadSubscription,
+  });
 }
 
 const accountUpdateInputValidator = tShape({
   updatedFields: tShape({
     email: t.maybe(tEmail),
     password: t.maybe(tPassword),
   }),
   currentPassword: tPassword,
 });
 
 async function passwordUpdateResponder(
   viewer: Viewer,
   input: any,
 ): Promise<void> {
   const request: PasswordUpdate = input;
   await validateInput(viewer, accountUpdateInputValidator, request);
   await accountUpdater(viewer, request);
 }
 
 async function sendVerificationEmailResponder(viewer: Viewer): Promise<void> {
   await validateInput(viewer, null, null);
   await checkAndSendVerificationEmail(viewer);
 }
 
 const resetPasswordRequestInputValidator = tShape({
   usernameOrEmail: t.union([tEmail, tOldValidUsername]),
 });
 
 async function sendPasswordResetEmailResponder(
   viewer: Viewer,
   input: any,
 ): Promise<void> {
   const request: ResetPasswordRequest = input;
   await validateInput(viewer, resetPasswordRequestInputValidator, request);
   await checkAndSendPasswordResetEmail(request);
 }
 
 export const logOutResponseValidator: TInterface<LogOutResponse> =
   tShape<LogOutResponse>({
     currentUserInfo: loggedOutUserInfoValidator,
   });
 
 async function logOutResponder(viewer: Viewer): Promise<LogOutResponse> {
   await validateInput(viewer, null, null);
   if (viewer.loggedIn) {
     const [anonymousViewerData] = await Promise.all([
       createNewAnonymousCookie({
         platformDetails: viewer.platformDetails,
         deviceToken: viewer.deviceToken,
       }),
       deleteCookie(viewer.cookieID),
     ]);
     viewer.setNewCookie(anonymousViewerData);
   }
-  return {
+  const response = {
     currentUserInfo: {
       id: viewer.id,
       anonymous: true,
     },
   };
+  return validateOutput(viewer, logOutResponseValidator, response);
 }
 
 const deleteAccountRequestInputValidator = tShape({
   password: t.maybe(tPassword),
 });
 
 async function accountDeletionResponder(
   viewer: Viewer,
   input: any,
 ): Promise<LogOutResponse> {
   const request: DeleteAccountRequest = input;
   await validateInput(viewer, deleteAccountRequestInputValidator, request);
   const result = await deleteAccount(viewer, request);
   invariant(result, 'deleteAccount should return result if handed request');
-  return result;
+  return validateOutput(viewer, logOutResponseValidator, result);
 }
 
 const deviceTokenUpdateRequestInputValidator = tShape({
   deviceType: t.maybe(t.enums.of(['ios', 'android'])),
   deviceToken: t.String,
 });
 
 const registerRequestInputValidator = tShape({
   username: t.String,
   email: t.maybe(tEmail),
   password: tPassword,
   calendarQuery: t.maybe(newEntryQueryInputValidator),
   deviceTokenUpdateRequest: t.maybe(deviceTokenUpdateRequestInputValidator),
   platformDetails: tPlatformDetails,
   // We include `primaryIdentityPublicKey` to avoid breaking
   // old clients, but we no longer do anything with it.
   primaryIdentityPublicKey: t.maybe(tRegex(primaryIdentityPublicKeyRegex)),
   signedIdentityKeysBlob: t.maybe(signedIdentityKeysBlobValidator),
 });
 
 export const registerResponseValidator: TInterface<RegisterResponse> =
   tShape<RegisterResponse>({
     id: t.String,
     rawMessageInfos: t.list(rawMessageInfoValidator),
     currentUserInfo: t.union([
       oldLoggedInUserInfoValidator,
       loggedInUserInfoValidator,
     ]),
     cookieChange: tShape({
       threadInfos: t.dict(t.String, rawThreadInfoValidator),
       userInfos: t.list(userInfoValidator),
     }),
   });
 
 async function accountCreationResponder(
   viewer: Viewer,
   input: any,
 ): Promise<RegisterResponse> {
   const request: RegisterRequest = input;
   await validateInput(viewer, registerRequestInputValidator, request);
   const { signedIdentityKeysBlob } = request;
   if (signedIdentityKeysBlob) {
     const identityKeys: IdentityKeysBlob = JSON.parse(
       signedIdentityKeysBlob.payload,
     );
     if (!identityKeysBlobValidator.is(identityKeys)) {
       throw new ServerError('invalid_identity_keys_blob');
     }
 
     const olmUtil: OlmUtility = getOlmUtility();
     try {
       olmUtil.ed25519_verify(
         identityKeys.primaryIdentityPublicKeys.ed25519,
         signedIdentityKeysBlob.payload,
         signedIdentityKeysBlob.signature,
       );
     } catch (e) {
       throw new ServerError('invalid_signature');
     }
   }
-  return await createAccount(viewer, request);
+  const response = await createAccount(viewer, request);
+  return validateOutput(viewer, registerResponseValidator, response);
 }
 
 type ProcessSuccessfulLoginParams = {
   +viewer: Viewer,
   +input: any,
   +userID: string,
   +calendarQuery: ?CalendarQuery,
   +socialProof?: ?SIWESocialProof,
   +signedIdentityKeysBlob?: ?SignedIdentityKeysBlob,
 };
 
 async function processSuccessfulLogin(
   params: ProcessSuccessfulLoginParams,
 ): Promise<LogInResponse> {
   const {
     viewer,
     input,
     userID,
     calendarQuery,
     socialProof,
     signedIdentityKeysBlob,
   } = params;
 
   const request: LogInRequest = input;
   const newServerTime = Date.now();
   const deviceToken = request.deviceTokenUpdateRequest
     ? request.deviceTokenUpdateRequest.deviceToken
     : viewer.deviceToken;
   const [userViewerData, notAcknowledgedPolicies] = await Promise.all([
     createNewUserCookie(userID, {
       platformDetails: request.platformDetails,
       deviceToken,
       socialProof,
       signedIdentityKeysBlob,
     }),
     fetchNotAcknowledgedPolicies(userID, baseLegalPolicies),
     deleteCookie(viewer.cookieID),
   ]);
   viewer.setNewCookie(userViewerData);
 
   if (
     notAcknowledgedPolicies.length &&
     hasMinCodeVersion(viewer.platformDetails, 181)
   ) {
     const currentUserInfo = await fetchLoggedInUserInfo(viewer);
     return {
       notAcknowledgedPolicies,
       currentUserInfo: currentUserInfo,
       rawMessageInfos: [],
       truncationStatuses: {},
       userInfos: [],
       rawEntryInfos: [],
       serverTime: 0,
       cookieChange: {
         threadInfos: {},
         userInfos: [],
       },
     };
   }
 
   if (calendarQuery) {
     await setNewSession(viewer, calendarQuery, newServerTime);
   }
 
   const threadCursors = {};
   for (const watchedThreadID of request.watchedIDs) {
     threadCursors[watchedThreadID] = null;
   }
   const messageSelectionCriteria = { threadCursors, joinedThreads: true };
 
   const [
     threadsResult,
     messagesResult,
     entriesResult,
     userInfos,
     currentUserInfo,
   ] = await Promise.all([
     fetchThreadInfos(viewer),
     fetchMessageInfos(viewer, messageSelectionCriteria, defaultNumberPerThread),
     calendarQuery ? fetchEntryInfos(viewer, [calendarQuery]) : undefined,
     fetchKnownUserInfos(viewer),
     fetchLoggedInUserInfo(viewer),
   ]);
 
   const rawEntryInfos = entriesResult ? entriesResult.rawEntryInfos : null;
   const response: LogInResponse = {
     currentUserInfo,
     rawMessageInfos: messagesResult.rawMessageInfos,
     truncationStatuses: messagesResult.truncationStatuses,
     serverTime: newServerTime,
     userInfos: values(userInfos),
     cookieChange: {
       threadInfos: threadsResult.threadInfos,
       userInfos: [],
     },
   };
   if (rawEntryInfos) {
     return {
       ...response,
       rawEntryInfos,
     };
   }
   return response;
 }
 
 const logInRequestInputValidator = tShape({
   username: t.maybe(t.String),
   usernameOrEmail: t.maybe(t.union([tEmail, tOldValidUsername])),
   password: tPassword,
   watchedIDs: t.list(t.String),
   calendarQuery: t.maybe(entryQueryInputValidator),
   deviceTokenUpdateRequest: t.maybe(deviceTokenUpdateRequestInputValidator),
   platformDetails: tPlatformDetails,
   source: t.maybe(t.enums.of(values(logInActionSources))),
   // We include `primaryIdentityPublicKey` to avoid breaking
   // old clients, but we no longer do anything with it.
   primaryIdentityPublicKey: t.maybe(tRegex(primaryIdentityPublicKeyRegex)),
   signedIdentityKeysBlob: t.maybe(signedIdentityKeysBlobValidator),
 });
 
 export const logInResponseValidator: TInterface<LogInResponse> =
   tShape<LogInResponse>({
     currentUserInfo: t.union([
       loggedInUserInfoValidator,
       oldLoggedInUserInfoValidator,
     ]),
     rawMessageInfos: t.list(rawMessageInfoValidator),
     truncationStatuses: messageTruncationStatusesValidator,
     userInfos: t.list(userInfoValidator),
     rawEntryInfos: t.maybe(t.list(rawEntryInfoValidator)),
     serverTime: t.Number,
     cookieChange: tShape({
       threadInfos: t.dict(tID, rawThreadInfoValidator),
       userInfos: t.list(userInfoValidator),
     }),
     notAcknowledgedPolicies: t.maybe(t.list(policyTypeValidator)),
   });
 
 async function logInResponder(
   viewer: Viewer,
   input: any,
 ): Promise<LogInResponse> {
   await validateInput(viewer, logInRequestInputValidator, input);
   const request: LogInRequest = input;
 
   let identityKeys: ?IdentityKeysBlob;
   const { signedIdentityKeysBlob } = request;
   if (signedIdentityKeysBlob) {
     identityKeys = JSON.parse(signedIdentityKeysBlob.payload);
 
     const olmUtil: OlmUtility = getOlmUtility();
     try {
       olmUtil.ed25519_verify(
         identityKeys.primaryIdentityPublicKeys.ed25519,
         signedIdentityKeysBlob.payload,
         signedIdentityKeysBlob.signature,
       );
     } catch (e) {
       throw new ServerError('invalid_signature');
     }
   }
 
   const calendarQuery = request.calendarQuery
     ? normalizeCalendarQuery(request.calendarQuery)
     : null;
   const promises = {};
   if (calendarQuery) {
     promises.verifyCalendarQueryThreadIDs =
       verifyCalendarQueryThreadIDs(calendarQuery);
   }
   const username = request.username ?? request.usernameOrEmail;
   if (!username) {
     if (hasMinCodeVersion(viewer.platformDetails, 150)) {
       throw new ServerError('invalid_credentials');
     } else {
       throw new ServerError('invalid_parameters');
     }
   }
   const userQuery = SQL`
     SELECT id, hash, username
     FROM users
     WHERE LCASE(username) = LCASE(${username})
   `;
   promises.userQuery = dbQuery(userQuery);
   const {
     userQuery: [userResult],
   } = await promiseAll(promises);
 
   if (userResult.length === 0) {
     if (hasMinCodeVersion(viewer.platformDetails, 150)) {
       throw new ServerError('invalid_credentials');
     } else {
       throw new ServerError('invalid_parameters');
     }
   }
 
   const userRow = userResult[0];
 
   if (!userRow.hash || !bcrypt.compareSync(request.password, userRow.hash)) {
     throw new ServerError('invalid_credentials');
   }
 
   const id = userRow.id.toString();
 
-  return await processSuccessfulLogin({
+  const response = await processSuccessfulLogin({
     viewer,
     input,
     userID: id,
     calendarQuery,
     signedIdentityKeysBlob,
   });
+  return validateOutput(viewer, logInResponseValidator, response);
 }
 
 const siweAuthRequestInputValidator = tShape({
   signature: t.String,
   message: t.String,
   calendarQuery: entryQueryInputValidator,
   deviceTokenUpdateRequest: t.maybe(deviceTokenUpdateRequestInputValidator),
   platformDetails: tPlatformDetails,
   watchedIDs: t.list(t.String),
   signedIdentityKeysBlob: t.maybe(signedIdentityKeysBlobValidator),
 });
 
 async function siweAuthResponder(
   viewer: Viewer,
   input: any,
 ): Promise<LogInResponse> {
   await validateInput(viewer, siweAuthRequestInputValidator, input);
   const request: SIWEAuthRequest = input;
   const {
     message,
     signature,
     deviceTokenUpdateRequest,
     platformDetails,
     signedIdentityKeysBlob,
   } = request;
   const calendarQuery = normalizeCalendarQuery(request.calendarQuery);
 
   // 1. Ensure that `message` is a well formed Comm SIWE Auth message.
   const siweMessage: SIWEMessage = new SiweMessage(message);
   if (!isValidSIWEMessage(siweMessage)) {
     throw new ServerError('invalid_parameters');
   }
 
   // 2. Ensure that the `nonce` exists in the `siwe_nonces` table
   //    AND hasn't expired. If those conditions are met, delete the entry to
   //    ensure that the same `nonce` can't be re-used in a future request.
   const wasNonceCheckedAndInvalidated = await checkAndInvalidateSIWENonceEntry(
     siweMessage.nonce,
   );
   if (!wasNonceCheckedAndInvalidated) {
     throw new ServerError('invalid_parameters');
   }
 
   // 3. Validate SIWEMessage signature and handle possible errors.
   try {
     await siweMessage.validate(signature);
   } catch (error) {
     if (error === ErrorTypes.EXPIRED_MESSAGE) {
       // Thrown when the `expirationTime` is present and in the past.
       throw new ServerError('expired_message');
     } else if (error === ErrorTypes.INVALID_SIGNATURE) {
       // Thrown when the `validate()` function can't verify the message.
       throw new ServerError('invalid_signature');
     } else if (error === ErrorTypes.MALFORMED_SESSION) {
       // Thrown when some required field is missing.
       throw new ServerError('malformed_session');
     } else {
       throw new ServerError('unknown_error');
     }
   }
 
   // 4. Pull `primaryIdentityPublicKey` out from SIWEMessage `statement`.
   //    We expect it to be included for BOTH native and web clients.
   const { statement } = siweMessage;
   const primaryIdentityPublicKey =
     statement && isValidSIWEStatementWithPublicKey(statement)
       ? getPublicKeyFromSIWEStatement(statement)
       : null;
   if (!primaryIdentityPublicKey) {
     throw new ServerError('invalid_siwe_statement_public_key');
   }
 
   // 5. Verify `signedIdentityKeysBlob.payload` with included `signature`
   //    if `signedIdentityKeysBlob` was included in the `SIWEAuthRequest`.
   let identityKeys: ?IdentityKeysBlob;
   if (signedIdentityKeysBlob) {
     identityKeys = JSON.parse(signedIdentityKeysBlob.payload);
     if (!identityKeysBlobValidator.is(identityKeys)) {
       throw new ServerError('invalid_identity_keys_blob');
     }
 
     const olmUtil: OlmUtility = getOlmUtility();
     try {
       olmUtil.ed25519_verify(
         identityKeys.primaryIdentityPublicKeys.ed25519,
         signedIdentityKeysBlob.payload,
         signedIdentityKeysBlob.signature,
       );
     } catch (e) {
       throw new ServerError('invalid_signature');
     }
   }
 
   // 6. Ensure that `primaryIdentityPublicKeys.ed25519` matches SIWE
   //    statement `primaryIdentityPublicKey` if `identityKeys` exists.
   if (
     identityKeys &&
     identityKeys.primaryIdentityPublicKeys.ed25519 !== primaryIdentityPublicKey
   ) {
     throw new ServerError('primary_public_key_mismatch');
   }
 
   // 7. Construct `SIWESocialProof` object with the stringified
   //    SIWEMessage and the corresponding signature.
   const socialProof: SIWESocialProof = {
     siweMessage: siweMessage.toMessage(),
     siweMessageSignature: signature,
   };
 
   // 8. Create account with call to `processSIWEAccountCreation(...)`
   //    if address does not correspond to an existing user.
   let userID = await fetchUserIDForEthereumAddress(siweMessage.address);
   if (!userID) {
     const siweAccountCreationRequest = {
       address: siweMessage.address,
       calendarQuery,
       deviceTokenUpdateRequest,
       platformDetails,
       socialProof,
     };
     userID = await processSIWEAccountCreation(
       viewer,
       siweAccountCreationRequest,
     );
   }
 
   // 9. Complete login with call to `processSuccessfulLogin(...)`.
-  return await processSuccessfulLogin({
+  const response = await processSuccessfulLogin({
     viewer,
     input,
     userID,
     calendarQuery,
     socialProof,
     signedIdentityKeysBlob,
   });
+  return validateOutput(viewer, logInResponseValidator, response);
 }
 
 const updatePasswordRequestInputValidator = tShape({
   code: t.String,
   password: tPassword,
   watchedIDs: t.list(t.String),
   calendarQuery: t.maybe(entryQueryInputValidator),
   deviceTokenUpdateRequest: t.maybe(deviceTokenUpdateRequestInputValidator),
   platformDetails: tPlatformDetails,
 });
 
 async function oldPasswordUpdateResponder(
   viewer: Viewer,
   input: any,
 ): Promise<LogInResponse> {
   await validateInput(viewer, updatePasswordRequestInputValidator, input);
   const request: UpdatePasswordRequest = input;
   if (request.calendarQuery) {
     request.calendarQuery = normalizeCalendarQuery(request.calendarQuery);
   }
-  return await updatePassword(viewer, request);
+  const response = await updatePassword(viewer, request);
+  return validateOutput(viewer, logInResponseValidator, response);
 }
 
 const updateUserSettingsInputValidator = tShape({
   name: t.irreducible(
     userSettingsTypes.DEFAULT_NOTIFICATIONS,
     x => x === userSettingsTypes.DEFAULT_NOTIFICATIONS,
   ),
   data: t.enums.of(notificationTypeValues),
 });
 
 async function updateUserSettingsResponder(
   viewer: Viewer,
   input: any,
 ): Promise<void> {
   const request: UpdateUserSettingsRequest = input;
   await validateInput(viewer, updateUserSettingsInputValidator, request);
-  return await updateUserSettings(viewer, request);
+  await updateUserSettings(viewer, request);
 }
 
 const policyAcknowledgmentRequestInputValidator = tShape({
   policy: t.maybe(t.enums.of(policies)),
 });
 
 async function policyAcknowledgmentResponder(
   viewer: Viewer,
   input: any,
 ): Promise<void> {
   const request: PolicyAcknowledgmentRequest = input;
   await validateInput(
     viewer,
     policyAcknowledgmentRequestInputValidator,
     request,
   );
   await viewerAcknowledgmentUpdater(viewer, request.policy);
 }
 
+export const updateUserAvatarResponseValidator: TInterface<UpdateUserAvatarResponse> =
+  tShape<UpdateUserAvatarResponse>({
+    updates: createUpdatesResultValidator,
+  });
+
+const updateUserAvatarResponderValidator = t.union([
+  t.maybe(clientAvatarValidator),
+  updateUserAvatarResponseValidator,
+]);
+
 async function updateUserAvatarResponder(
   viewer: Viewer,
   input: any,
 ): Promise<?ClientAvatar | UpdateUserAvatarResponse> {
   const request: UpdateUserAvatarRequest = input;
   await validateInput(viewer, updateUserAvatarRequestValidator, request);
-  return await updateUserAvatar(viewer, request);
+  const result = await updateUserAvatar(viewer, request);
+  return validateOutput(viewer, updateUserAvatarResponderValidator, result);
 }
 
 export {
   userSubscriptionUpdateResponder,
   passwordUpdateResponder,
   sendVerificationEmailResponder,
   sendPasswordResetEmailResponder,
   logOutResponder,
   accountDeletionResponder,
   accountCreationResponder,
   logInResponder,
   siweAuthResponder,
   oldPasswordUpdateResponder,
   updateUserSettingsResponder,
   policyAcknowledgmentResponder,
   updateUserAvatarResponder,
 };
diff --git a/lib/types/update-types.js b/lib/types/update-types.js
index 84f4040ac..7b6ac5d75 100644
--- a/lib/types/update-types.js
+++ b/lib/types/update-types.js
@@ -1,415 +1,421 @@
 // @flow
 
 import invariant from 'invariant';
 import t, { type TUnion, type TInterface } from 'tcomb';
 
 import { type RawEntryInfo, rawEntryInfoValidator } from './entry-types.js';
 import {
   type RawMessageInfo,
   rawMessageInfoValidator,
   type MessageTruncationStatus,
   messageTruncationStatusValidator,
 } from './message-types.js';
 import { type RawThreadInfo, rawThreadInfoValidator } from './thread-types.js';
 import {
   type UserInfo,
   userInfoValidator,
   type UserInfos,
+  userInfosValidator,
   type LoggedInUserInfo,
   loggedInUserInfoValidator,
   type OldLoggedInUserInfo,
   oldLoggedInUserInfoValidator,
 } from './user-types.js';
 import { tNumber, tShape, tID } from '../utils/validation-utils.js';
 
 export const updateTypes = Object.freeze({
   DELETE_ACCOUNT: 0,
   UPDATE_THREAD: 1,
   UPDATE_THREAD_READ_STATUS: 2,
   DELETE_THREAD: 3,
   JOIN_THREAD: 4,
   BAD_DEVICE_TOKEN: 5,
   UPDATE_ENTRY: 6,
   UPDATE_CURRENT_USER: 7,
   UPDATE_USER: 8,
 });
 export type UpdateType = $Values<typeof updateTypes>;
 export function assertUpdateType(ourUpdateType: number): UpdateType {
   invariant(
     ourUpdateType === 0 ||
       ourUpdateType === 1 ||
       ourUpdateType === 2 ||
       ourUpdateType === 3 ||
       ourUpdateType === 4 ||
       ourUpdateType === 5 ||
       ourUpdateType === 6 ||
       ourUpdateType === 7 ||
       ourUpdateType === 8,
     'number is not UpdateType enum',
   );
   return ourUpdateType;
 }
 
 type AccountDeletionData = {
   +deletedUserID: string,
 };
 type ThreadData = {
   +threadID: string,
 };
 type ThreadReadStatusData = {
   +threadID: string,
   +unread: boolean,
 };
 type ThreadDeletionData = {
   +threadID: string,
 };
 type ThreadJoinData = {
   +threadID: string,
 };
 type BadDeviceTokenData = {
   +deviceToken: string,
 };
 type EntryData = {
   +entryID: string,
 };
 type CurrentUserData = {};
 type UserData = {
   // ID of the UserInfo being updated
   +updatedUserID: string,
 };
 
 type SharedUpdateData = {
   +userID: string,
   +time: number,
 };
 type AccountDeletionUpdateData = {
   ...SharedUpdateData,
   ...AccountDeletionData,
   +type: 0,
 };
 type ThreadUpdateData = {
   ...SharedUpdateData,
   ...ThreadData,
   +type: 1,
   +targetSession?: string,
 };
 type ThreadReadStatusUpdateData = {
   ...SharedUpdateData,
   ...ThreadReadStatusData,
   +type: 2,
 };
 type ThreadDeletionUpdateData = {
   ...SharedUpdateData,
   ...ThreadDeletionData,
   +type: 3,
 };
 type ThreadJoinUpdateData = {
   ...SharedUpdateData,
   ...ThreadJoinData,
   +type: 4,
   +targetSession?: string,
 };
 type BadDeviceTokenUpdateData = {
   ...SharedUpdateData,
   ...BadDeviceTokenData,
   +type: 5,
   +targetCookie: string,
 };
 type EntryUpdateData = {
   ...SharedUpdateData,
   ...EntryData,
   +type: 6,
   +targetSession: string,
 };
 type CurrentUserUpdateData = {
   ...SharedUpdateData,
   ...CurrentUserData,
   +type: 7,
 };
 type UserUpdateData = {
   ...SharedUpdateData,
   ...UserData,
   +type: 8,
   +targetSession?: string,
 };
 export type UpdateData =
   | AccountDeletionUpdateData
   | ThreadUpdateData
   | ThreadReadStatusUpdateData
   | ThreadDeletionUpdateData
   | ThreadJoinUpdateData
   | BadDeviceTokenUpdateData
   | EntryUpdateData
   | CurrentUserUpdateData
   | UserUpdateData;
 
 type SharedRawUpdateInfo = {
   +id: string,
   +time: number,
 };
 type AccountDeletionRawUpdateInfo = {
   ...SharedRawUpdateInfo,
   ...AccountDeletionData,
   +type: 0,
 };
 type ThreadRawUpdateInfo = {
   ...SharedRawUpdateInfo,
   ...ThreadData,
   +type: 1,
 };
 type ThreadReadStatusRawUpdateInfo = {
   ...SharedRawUpdateInfo,
   ...ThreadReadStatusData,
   +type: 2,
 };
 type ThreadDeletionRawUpdateInfo = {
   ...SharedRawUpdateInfo,
   ...ThreadDeletionData,
   +type: 3,
 };
 type ThreadJoinRawUpdateInfo = {
   ...SharedRawUpdateInfo,
   ...ThreadJoinData,
   +type: 4,
 };
 type BadDeviceTokenRawUpdateInfo = {
   ...SharedRawUpdateInfo,
   ...BadDeviceTokenData,
   +type: 5,
 };
 type EntryRawUpdateInfo = {
   ...SharedRawUpdateInfo,
   ...EntryData,
   +type: 6,
 };
 type CurrentUserRawUpdateInfo = {
   ...SharedRawUpdateInfo,
   ...CurrentUserData,
   +type: 7,
 };
 type UserRawUpdateInfo = {
   ...SharedRawUpdateInfo,
   ...UserData,
   +type: 8,
 };
 export type RawUpdateInfo =
   | AccountDeletionRawUpdateInfo
   | ThreadRawUpdateInfo
   | ThreadReadStatusRawUpdateInfo
   | ThreadDeletionRawUpdateInfo
   | ThreadJoinRawUpdateInfo
   | BadDeviceTokenRawUpdateInfo
   | EntryRawUpdateInfo
   | CurrentUserRawUpdateInfo
   | UserRawUpdateInfo;
 
 type AccountDeletionUpdateInfo = {
   +type: 0,
   +id: string,
   +time: number,
   +deletedUserID: string,
 };
 export const accountDeletionUpdateInfoValidator: TInterface<AccountDeletionUpdateInfo> =
   tShape<AccountDeletionUpdateInfo>({
     type: tNumber(updateTypes.DELETE_ACCOUNT),
     id: t.String,
     time: t.Number,
     deletedUserID: t.String,
   });
 
 type ThreadUpdateInfo = {
   +type: 1,
   +id: string,
   +time: number,
   +threadInfo: RawThreadInfo,
 };
 export const threadUpdateInfoValidator: TInterface<ThreadUpdateInfo> =
   tShape<ThreadUpdateInfo>({
     type: tNumber(updateTypes.UPDATE_THREAD),
     id: t.String,
     time: t.Number,
     threadInfo: rawThreadInfoValidator,
   });
 type ThreadReadStatusUpdateInfo = {
   +type: 2,
   +id: string,
   +time: number,
   +threadID: string,
   +unread: boolean,
 };
 export const threadReadStatusUpdateInfoValidator: TInterface<ThreadReadStatusUpdateInfo> =
   tShape<ThreadReadStatusUpdateInfo>({
     type: tNumber(updateTypes.UPDATE_THREAD_READ_STATUS),
     id: t.String,
     time: t.Number,
     threadID: tID,
     unread: t.Boolean,
   });
 type ThreadDeletionUpdateInfo = {
   +type: 3,
   +id: string,
   +time: number,
   +threadID: string,
 };
 export const threadDeletionUpdateInfoValidator: TInterface<ThreadDeletionUpdateInfo> =
   tShape<ThreadDeletionUpdateInfo>({
     type: tNumber(updateTypes.DELETE_THREAD),
     id: t.String,
     time: t.Number,
     threadID: tID,
   });
 
 type ThreadJoinUpdateInfo = {
   +type: 4,
   +id: string,
   +time: number,
   +threadInfo: RawThreadInfo,
   +rawMessageInfos: $ReadOnlyArray<RawMessageInfo>,
   +truncationStatus: MessageTruncationStatus,
   +rawEntryInfos: $ReadOnlyArray<RawEntryInfo>,
 };
 export const threadJoinUpdateInfoValidator: TInterface<ThreadJoinUpdateInfo> =
   tShape<ThreadJoinUpdateInfo>({
     type: tNumber(updateTypes.JOIN_THREAD),
     id: t.String,
     time: t.Number,
     threadInfo: rawThreadInfoValidator,
     rawMessageInfos: t.list(rawMessageInfoValidator),
     truncationStatus: messageTruncationStatusValidator,
     rawEntryInfos: t.list(rawEntryInfoValidator),
   });
 type BadDeviceTokenUpdateInfo = {
   +type: 5,
   +id: string,
   +time: number,
   +deviceToken: string,
 };
 export const badDeviceTokenUpdateInfoValidator: TInterface<BadDeviceTokenUpdateInfo> =
   tShape<BadDeviceTokenUpdateInfo>({
     type: tNumber(updateTypes.BAD_DEVICE_TOKEN),
     id: t.String,
     time: t.Number,
     deviceToken: t.String,
   });
 type EntryUpdateInfo = {
   +type: 6,
   +id: string,
   +time: number,
   +entryInfo: RawEntryInfo,
 };
 export const entryUpdateInfoValidator: TInterface<EntryUpdateInfo> =
   tShape<EntryUpdateInfo>({
     type: tNumber(updateTypes.UPDATE_ENTRY),
     id: t.String,
     time: t.Number,
     entryInfo: rawEntryInfoValidator,
   });
 type CurrentUserUpdateInfo = {
   +type: 7,
   +id: string,
   +time: number,
   +currentUserInfo: LoggedInUserInfo,
 };
 type UserUpdateInfo = {
   +type: 8,
   +id: string,
   +time: number,
   // Updated UserInfo is already contained within the UpdatesResultWithUserInfos
   +updatedUserID: string,
 };
 export const userUpdateInfoValidator: TInterface<UserUpdateInfo> =
   tShape<UserUpdateInfo>({
     type: tNumber(updateTypes.UPDATE_USER),
     id: t.String,
     time: t.Number,
     updatedUserID: t.String,
   });
 export type ClientUpdateInfo =
   | AccountDeletionUpdateInfo
   | ThreadUpdateInfo
   | ThreadReadStatusUpdateInfo
   | ThreadDeletionUpdateInfo
   | ThreadJoinUpdateInfo
   | BadDeviceTokenUpdateInfo
   | EntryUpdateInfo
   | CurrentUserUpdateInfo
   | UserUpdateInfo;
 
 type ServerCurrentUserUpdateInfo = {
   +type: 7,
   +id: string,
   +time: number,
   +currentUserInfo: LoggedInUserInfo | OldLoggedInUserInfo,
 };
 export const serverCurrentUserUpdateInfoValidator: TInterface<ServerCurrentUserUpdateInfo> =
   tShape<ServerCurrentUserUpdateInfo>({
     type: tNumber(updateTypes.UPDATE_CURRENT_USER),
     id: t.String,
     time: t.Number,
     currentUserInfo: t.union([
       loggedInUserInfoValidator,
       oldLoggedInUserInfoValidator,
     ]),
   });
 export type ServerUpdateInfo =
   | AccountDeletionUpdateInfo
   | ThreadUpdateInfo
   | ThreadReadStatusUpdateInfo
   | ThreadDeletionUpdateInfo
   | ThreadJoinUpdateInfo
   | BadDeviceTokenUpdateInfo
   | EntryUpdateInfo
   | ServerCurrentUserUpdateInfo
   | UserUpdateInfo;
 export const serverUpdateInfoValidator: TUnion<ServerUpdateInfo> = t.union([
   accountDeletionUpdateInfoValidator,
   threadUpdateInfoValidator,
   threadReadStatusUpdateInfoValidator,
   threadDeletionUpdateInfoValidator,
   threadJoinUpdateInfoValidator,
   badDeviceTokenUpdateInfoValidator,
   entryUpdateInfoValidator,
   serverCurrentUserUpdateInfoValidator,
   userUpdateInfoValidator,
 ]);
 
 export type ServerUpdatesResult = {
   +currentAsOf: number,
   +newUpdates: $ReadOnlyArray<ServerUpdateInfo>,
 };
 export type ServerUpdatesResultWithUserInfos = {
   +updatesResult: ServerUpdatesResult,
   +userInfos: $ReadOnlyArray<UserInfo>,
 };
 
 export type ClientUpdatesResult = {
   +currentAsOf: number,
   +newUpdates: $ReadOnlyArray<ClientUpdateInfo>,
 };
 export type ClientUpdatesResultWithUserInfos = {
   +updatesResult: ClientUpdatesResult,
   +userInfos: $ReadOnlyArray<UserInfo>,
 };
 
 export type CreateUpdatesResult = {
   +viewerUpdates: $ReadOnlyArray<ServerUpdateInfo>,
   +userInfos: UserInfos,
 };
+export const createUpdatesResultValidator: TInterface<CreateUpdatesResult> =
+  tShape<CreateUpdatesResult>({
+    viewerUpdates: t.list(serverUpdateInfoValidator),
+    userInfos: userInfosValidator,
+  });
 
 export type ServerCreateUpdatesResponse = {
   +viewerUpdates: $ReadOnlyArray<ServerUpdateInfo>,
   +userInfos: $ReadOnlyArray<UserInfo>,
 };
 
 export const serverCreateUpdatesResponseValidator: TInterface<ServerCreateUpdatesResponse> =
   tShape<ServerCreateUpdatesResponse>({
     viewerUpdates: t.list(serverUpdateInfoValidator),
     userInfos: t.list(userInfoValidator),
   });
 
 export type ClientCreateUpdatesResponse = {
   +viewerUpdates: $ReadOnlyArray<ClientUpdateInfo>,
   +userInfos: $ReadOnlyArray<UserInfo>,
 };
 
 export const processUpdatesActionType = 'PROCESS_UPDATES';