diff --git a/app/api/job/handler/sync-analysis-results.ts b/app/api/job/handler/sync-analysis-results.ts
index ddf07de..c7fd529 100644
--- a/app/api/job/handler/sync-analysis-results.ts
+++ b/app/api/job/handler/sync-analysis-results.ts
@@ -1,29 +1,62 @@
 import { readPrivateMessageResponse } from "~/lib/services/medipost.service";
 
+type ProcessedMessage = {
+  messageId: string;
+  hasAnalysisResponse: boolean;
+  hasPartialAnalysisResponse: boolean;
+  hasFullAnalysisResponse: boolean;
+  medusaOrderId: string | undefined;
+};
+
+type GroupedResults = {
+  processed: Pick<ProcessedMessage, 'messageId' | 'medusaOrderId'>[];
+  waitingForResults: Pick<ProcessedMessage, 'messageId' | 'medusaOrderId'>[];
+};
+
 export default async function syncAnalysisResults() {
   console.info("Syncing analysis results");
   
-  let processedMessageIds: string[] = [];
+  let processedMessages: ProcessedMessage[] = [];
   const excludedMessageIds: string[] = [];
   while (true) {
-    console.info("Fetching private messages");
-    const { messageIdErrored, messageIdProcessed } = await readPrivateMessageResponse({ excludedMessageIds });
-    if (messageIdProcessed) {
-      processedMessageIds.push(messageIdProcessed);
+    const result = await readPrivateMessageResponse({ excludedMessageIds });
+    if (result.messageId) {
+      processedMessages.push(result as ProcessedMessage);
     }
 
-    if (!messageIdErrored) {
+    if (!result.messageId) {
       console.info("No more messages to process");
       break;
     }
 
-    if (excludedMessageIds.includes(messageIdErrored)) {
-      console.info(`Message id=${messageIdErrored} has already been processed, stopping`);
+    if (!excludedMessageIds.includes(result.messageId)) {
+      excludedMessageIds.push(result.messageId);
+    } else {
       break;
     }
-
-    excludedMessageIds.push(messageIdErrored);
   }
 
-  console.info(`Processed ${processedMessageIds.length} messages, ids: ${processedMessageIds.join(', ')}`);
+  const groupedResults = processedMessages.reduce((acc, result) => {
+    if (result.medusaOrderId) {
+      if (result.hasAnalysisResponse) {
+        if (!acc.processed) {
+          acc.processed = [];
+        }
+        acc.processed.push({
+          messageId: result.messageId,
+          medusaOrderId: result.medusaOrderId,
+        });
+      } else {
+        if (!acc.waitingForResults) {
+          acc.waitingForResults = [];
+        }
+        acc.waitingForResults.push({
+          messageId: result.messageId,
+          medusaOrderId: result.medusaOrderId,
+        });
+      }
+    }
+    return acc;
+  }, {} as GroupedResults);
+  console.info(`Processed ${processedMessages.length} messages, results: ${JSON.stringify(groupedResults, undefined, 2)}`);
 }
diff --git a/lib/services/medipost.service.ts b/lib/services/medipost.service.ts
index 4b299d2..39763cf 100644
--- a/lib/services/medipost.service.ts
+++ b/lib/services/medipost.service.ts
@@ -202,28 +202,60 @@ export async function readPrivateMessageResponse({
   excludedMessageIds,
 }: {
   excludedMessageIds: string[];
-}) {
-  let messageIdErrored: string | null = null;
-  let messageIdProcessed: string | null = null;
+}): Promise<{ messageId: string | null; hasAnalysisResponse: boolean; hasPartialAnalysisResponse: boolean; hasFullAnalysisResponse: boolean; medusaOrderId: string | undefined }> {
+  let messageId: string | null = null;
+  let hasAnalysisResponse = false;
+  let hasPartialAnalysisResponse = false;
+  let hasFullAnalysisResponse = false;
+  let medusaOrderId: string | undefined = undefined;
+
   try {
     const privateMessage = await getLatestPrivateMessageListItem({ excludedMessageIds });
     if (!privateMessage) {
-      throw new Error(`No private message found`);
+      return {
+        messageId: null,
+        hasAnalysisResponse: false,
+        hasPartialAnalysisResponse: false,
+        hasFullAnalysisResponse: false,
+        medusaOrderId: undefined,
+      };
     }
 
-    messageIdErrored = privateMessage.messageId;
-    if (!messageIdErrored) {
-      throw new Error(`No message id found`);
+    messageId = privateMessage.messageId;
+    if (!messageId) {
+      return {
+        messageId: null,
+        hasAnalysisResponse: false,
+        hasPartialAnalysisResponse: false,
+        hasFullAnalysisResponse: false,
+        medusaOrderId: undefined,
+      };
     }
 
     const privateMessageContent = await getPrivateMessage(
       privateMessage.messageId,
     );
     const messageResponse = privateMessageContent?.Saadetis?.Vastus;
-    const medusaOrderId = privateMessageContent?.Saadetis?.Tellimus?.ValisTellimuseId || messageResponse?.ValisTellimuseId;
+    medusaOrderId = privateMessageContent?.Saadetis?.Tellimus?.ValisTellimuseId || messageResponse?.ValisTellimuseId;
+
+    if (!medusaOrderId || !medusaOrderId.toString().startsWith('order_')) {
+      return {
+        messageId,
+        hasAnalysisResponse: false,
+        hasPartialAnalysisResponse: false,
+        hasFullAnalysisResponse: false,
+        medusaOrderId: undefined,
+      };
+    }
 
     if (!messageResponse) {
-      throw new Error(`Private message response has no results yet for order=${medusaOrderId}`);
+      return {
+        messageId,
+        hasAnalysisResponse: false,
+        hasPartialAnalysisResponse: false,
+        hasFullAnalysisResponse: false,
+        medusaOrderId,
+      };
     }
 
     let order: Tables<{ schema: 'medreport' }, 'analysis_orders'>;
@@ -238,17 +270,19 @@ export async function readPrivateMessageResponse({
 
     if (status.isPartial) {
       await updateOrderStatus({ medusaOrderId, orderStatus: 'PARTIAL_ANALYSIS_RESPONSE' });
-      messageIdProcessed = privateMessage.messageId;
+      hasAnalysisResponse = true;
+      hasPartialAnalysisResponse = true;
     } else if (status.isCompleted) {
       await updateOrderStatus({ medusaOrderId, orderStatus: 'FULL_ANALYSIS_RESPONSE' });
       await deletePrivateMessage(privateMessage.messageId);
-      messageIdProcessed = privateMessage.messageId;
+      hasAnalysisResponse = true;
+      hasFullAnalysisResponse = true;
     }
   } catch (e) {
-    console.warn(`Failed to process private message id=${messageIdErrored}, message=${(e as Error).message}`);
+    console.warn(`Failed to process private message id=${messageId}, message=${(e as Error).message}`);
   }
 
-  return { messageIdErrored, messageIdProcessed };
+  return { messageId, hasAnalysisResponse, hasPartialAnalysisResponse, hasFullAnalysisResponse, medusaOrderId };
 }
 
 async function saveAnalysisGroup(