diff --git a/apps/remix/app/components/dialogs/envelope-download-dialog.tsx b/apps/remix/app/components/dialogs/envelope-download-dialog.tsx
index eb046ac446..811827f3f6 100644
--- a/apps/remix/app/components/dialogs/envelope-download-dialog.tsx
+++ b/apps/remix/app/components/dialogs/envelope-download-dialog.tsx
@@ -5,6 +5,7 @@ import { Trans } from '@lingui/react/macro';
 import { DocumentStatus, type EnvelopeItem } from '@prisma/client';
 import { DownloadIcon, FileTextIcon } from 'lucide-react';
 
+import { downloadEnvelopeZip } from '@documenso/lib/client-only/download-envelope-zip';
 import { downloadPDF } from '@documenso/lib/client-only/download-pdf';
 import { trpc } from '@documenso/trpc/react';
 import { Button } from '@documenso/ui/primitives/button';
@@ -28,6 +29,11 @@ type EnvelopeDownloadDialogProps = {
   envelopeStatus: DocumentStatus;
   envelopeItems?: EnvelopeItemToDownload[];
 
+  /**
+   * The envelope title, used to name the "download all" ZIP archive.
+   */
+  envelopeTitle?: string;
+
   /**
    * The recipient token to download the document.
    *
@@ -48,6 +54,7 @@ export const EnvelopeDownloadDialog = ({
   envelopeId,
   envelopeStatus,
   envelopeItems: initialEnvelopeItems,
+  envelopeTitle,
   token,
   canDownloadPartial = false,
   trigger,
@@ -61,6 +68,8 @@ export const EnvelopeDownloadDialog = ({
     [envelopeItemIdAndVersion: string]: boolean;
   }>({});
 
+  const [isDownloadingAll, setIsDownloadingAll] = useState(false);
+
   const generateDownloadKey = (envelopeItemId: string, version: DownloadVersion) =>
     `${envelopeItemId}-${version}`;
 
@@ -121,6 +130,34 @@ export const EnvelopeDownloadDialog = ({
     }
   };
 
+  const onDownloadAll = async () => {
+    if (isDownloadingAll) {
+      return;
+    }
+
+    setIsDownloadingAll(true);
+
+    try {
+      await downloadEnvelopeZip({
+        envelopeId,
+        token,
+        fileName: envelopeTitle,
+        version: envelopeStatus === DocumentStatus.COMPLETED ? 'signed' : 'original',
+      });
+    } catch (error) {
+      console.error(error);
+
+      toast({
+        title: t`Something went wrong`,
+        description: t`These documents could not be downloaded at this time. Please try again.`,
+        variant: 'destructive',
+        duration: 7500,
+      });
+    } finally {
+      setIsDownloadingAll(false);
+    }
+  };
+
   return (
     <Dialog open={open} onOpenChange={(value) => setOpen(value)}>
       <DialogTrigger asChild>{trigger}</DialogTrigger>
@@ -135,7 +172,20 @@ export const EnvelopeDownloadDialog = ({
           </DialogDescription>
         </DialogHeader>
 
-        <div className="flex w-full flex-col gap-4 overflow-hidden">
+        {!isLoadingEnvelopeItems && envelopeItems.length > 1 && (
+          <div className="flex items-center justify-between gap-2">
+            <p className="text-muted-foreground text-xs">
+              {t`${envelopeItems.length} documents`}
+            </p>
+
+            <Button variant="default" size="sm" onClick={onDownloadAll} loading={isDownloadingAll}>
+              {!isDownloadingAll && <DownloadIcon className="mr-2 h-4 w-4" />}
+              <Trans>Download all</Trans>
+            </Button>
+          </div>
+        )}
+
+        <div className="-mx-1 flex max-h-[60vh] w-full flex-col gap-4 overflow-y-auto px-1">
           {isLoadingEnvelopeItems ? (
             <>
               {Array.from({ length: 1 }).map((_, index) => (
diff --git a/apps/remix/app/components/general/document/document-page-view-button.tsx b/apps/remix/app/components/general/document/document-page-view-button.tsx
index e3e7e0afc2..9864d34a6f 100644
--- a/apps/remix/app/components/general/document/document-page-view-button.tsx
+++ b/apps/remix/app/components/general/document/document-page-view-button.tsx
@@ -74,6 +74,7 @@ export const DocumentPageViewButton = ({ envelope }: DocumentPageViewButtonProps
         envelopeId={envelope.id}
         envelopeStatus={envelope.status}
         envelopeItems={envelope.envelopeItems}
+        envelopeTitle={envelope.title}
         token={recipient?.token}
         trigger={
           <Button className="w-full">
diff --git a/apps/remix/app/components/general/document/document-page-view-dropdown.tsx b/apps/remix/app/components/general/document/document-page-view-dropdown.tsx
index d786545088..bd877b0751 100644
--- a/apps/remix/app/components/general/document/document-page-view-dropdown.tsx
+++ b/apps/remix/app/components/general/document/document-page-view-dropdown.tsx
@@ -106,6 +106,7 @@ export const DocumentPageViewDropdown = ({ envelope }: DocumentPageViewDropdownP
           envelopeStatus={envelope.status}
           token={recipient?.token}
           envelopeItems={envelope.envelopeItems}
+          envelopeTitle={envelope.title}
           canDownloadPartial={canManageDocument}
           trigger={
             <DropdownMenuItem asChild onSelect={(e) => e.preventDefault()}>
diff --git a/apps/remix/app/components/tables/documents-table-action-button.tsx b/apps/remix/app/components/tables/documents-table-action-button.tsx
index 506c6afa03..bdcfd2d383 100644
--- a/apps/remix/app/components/tables/documents-table-action-button.tsx
+++ b/apps/remix/app/components/tables/documents-table-action-button.tsx
@@ -103,6 +103,7 @@ export const DocumentsTableActionButton = ({ row }: DocumentsTableActionButtonPr
       <EnvelopeDownloadDialog
         envelopeId={row.envelopeId}
         envelopeStatus={row.status}
+        envelopeTitle={row.title}
         token={recipient?.token}
         trigger={
           <Button className="w-32">
diff --git a/apps/remix/app/components/tables/documents-table-action-dropdown.tsx b/apps/remix/app/components/tables/documents-table-action-dropdown.tsx
index c6f1047820..332b90f84e 100644
--- a/apps/remix/app/components/tables/documents-table-action-dropdown.tsx
+++ b/apps/remix/app/components/tables/documents-table-action-dropdown.tsx
@@ -152,6 +152,7 @@ export const DocumentsTableActionDropdown = ({
         <EnvelopeDownloadDialog
           envelopeId={row.envelopeId}
           envelopeStatus={row.status}
+          envelopeTitle={row.title}
           token={recipient?.token}
           canDownloadPartial={canManageDocument}
           trigger={
diff --git a/apps/remix/app/components/tables/inbox-table.tsx b/apps/remix/app/components/tables/inbox-table.tsx
index a214461650..53437d7938 100644
--- a/apps/remix/app/components/tables/inbox-table.tsx
+++ b/apps/remix/app/components/tables/inbox-table.tsx
@@ -334,6 +334,7 @@ export const InboxTableActionButton = ({ row }: InboxTableActionButtonProps) =>
       <EnvelopeDownloadDialog
         envelopeId={row.envelopeId}
         envelopeStatus={row.status}
+        envelopeTitle={row.title}
         token={recipient?.token}
         trigger={
           <Button className="w-32">
diff --git a/apps/remix/app/routes/_recipient+/sign.$token+/complete.tsx b/apps/remix/app/routes/_recipient+/sign.$token+/complete.tsx
index c64292fdfb..b3ff741701 100644
--- a/apps/remix/app/routes/_recipient+/sign.$token+/complete.tsx
+++ b/apps/remix/app/routes/_recipient+/sign.$token+/complete.tsx
@@ -255,6 +255,7 @@ export default function CompletedSigningPage({ loaderData }: Route.ComponentProp
                 envelopeId={document.envelopeId}
                 envelopeStatus={document.status}
                 envelopeItems={document.envelopeItems}
+                envelopeTitle={document.title}
                 token={recipient?.token}
                 trigger={
                   <Button type="button" variant="outline" className="flex-1 md:flex-initial">
diff --git a/apps/remix/server/api/files/files.helpers.ts b/apps/remix/server/api/files/files.helpers.ts
index 7e50b93a95..729727e874 100644
--- a/apps/remix/server/api/files/files.helpers.ts
+++ b/apps/remix/server/api/files/files.helpers.ts
@@ -12,6 +12,7 @@ import { generatePartialDocumentPdf } from '@documenso/lib/server-only/pdf/gener
 import { getTeamById } from '@documenso/lib/server-only/team/get-team';
 import { sha256 } from '@documenso/lib/universal/crypto';
 import { getFileServerSide } from '@documenso/lib/universal/upload/get-file.server';
+import { type ZipFile, createZip } from '@documenso/lib/universal/zip';
 import { prisma } from '@documenso/prisma';
 
 import type { HonoEnv } from '../../router';
@@ -130,6 +131,112 @@ export const handleEnvelopeItemFileRequest = async ({
   return c.body(file);
 };
 
+type EnvelopeZipItem = {
+  title: string;
+  documentData: {
+    type: DocumentDataType;
+    data: string;
+    initialData: string;
+  } | null;
+};
+
+type BuildEnvelopeZipResponseOptions = {
+  envelopeTitle: string;
+  items: EnvelopeZipItem[];
+  version: 'signed' | 'original';
+  context: Context<HonoEnv>;
+};
+
+/**
+ * Ensures every entry in the archive has a unique name. PDF titles within an
+ * envelope are not guaranteed to be unique, so colliding names get a numeric
+ * suffix (e.g. "report (2).pdf") to avoid silently overwriting an entry.
+ */
+const dedupeFileName = (name: string, usedNames: Set<string>): string => {
+  if (!usedNames.has(name)) {
+    usedNames.add(name);
+
+    return name;
+  }
+
+  const extensionMatch = /\.[^.]+$/.exec(name);
+  const extension = extensionMatch ? extensionMatch[0] : '';
+  const base = extension ? name.slice(0, -extension.length) : name;
+
+  let counter = 2;
+  let candidate = `${base} (${counter})${extension}`;
+
+  while (usedNames.has(candidate)) {
+    counter += 1;
+    candidate = `${base} (${counter})${extension}`;
+  }
+
+  usedNames.add(candidate);
+
+  return candidate;
+};
+
+/**
+ * Bundles every document in an envelope into a single ZIP archive and returns
+ * it as a download. Used by the "Download all" action so a user does not have
+ * to download each document in a multi-document envelope individually.
+ */
+export const buildEnvelopeZipResponse = async ({
+  envelopeTitle,
+  items,
+  version,
+  context: c,
+}: BuildEnvelopeZipResponseOptions) => {
+  const usedNames = new Set<string>();
+  const suffix = version === 'signed' ? '_signed.pdf' : '.pdf';
+
+  const files: ZipFile[] = [];
+
+  for (const item of items) {
+    if (!item.documentData) {
+      continue;
+    }
+
+    const documentDataToUse =
+      version === 'signed' ? item.documentData.data : item.documentData.initialData;
+
+    const file = await getFileServerSide({
+      type: item.documentData.type,
+      data: documentDataToUse,
+    }).catch((error) => {
+      console.error(error);
+
+      return null;
+    });
+
+    if (!file) {
+      continue;
+    }
+
+    const baseTitle = item.title.replace(/\.pdf$/, '');
+    const name = dedupeFileName(`${baseTitle}${suffix}`, usedNames);
+
+    files.push({ name, data: file });
+  }
+
+  if (files.length === 0) {
+    return c.json({ error: 'No files available to download' }, 404);
+  }
+
+  const zip = createZip(files);
+
+  const baseZipTitle = envelopeTitle.replace(/\.pdf$/, '') || 'documents';
+  const zipFilename = `${baseZipTitle}.zip`;
+
+  c.header('Content-Type', 'application/zip');
+  c.header('Content-Disposition', contentDisposition(zipFilename));
+  c.header('Cache-Control', 'no-cache, no-store, must-revalidate');
+  c.header('Pragma', 'no-cache');
+  c.header('Expires', '0');
+
+  return c.body(zip);
+};
+
 type CheckEnvelopeFileAccessOptions = {
   userId: number;
   teamId: number;
diff --git a/apps/remix/server/api/files/files.ts b/apps/remix/server/api/files/files.ts
index cb1d0dd31d..40dee4ca8e 100644
--- a/apps/remix/server/api/files/files.ts
+++ b/apps/remix/server/api/files/files.ts
@@ -11,9 +11,15 @@ import { getPresignPostUrl } from '@documenso/lib/universal/upload/server-action
 import { prisma } from '@documenso/prisma';
 
 import type { HonoEnv } from '../../router';
-import { checkEnvelopeFileAccess, handleEnvelopeItemFileRequest } from './files.helpers';
+import {
+  buildEnvelopeZipResponse,
+  checkEnvelopeFileAccess,
+  handleEnvelopeItemFileRequest,
+} from './files.helpers';
 import {
   type TGetPresignedPostUrlResponse,
+  ZDownloadAllEnvelopeFilesRequestParamsSchema,
+  ZDownloadAllEnvelopeFilesTokenRequestParamsSchema,
   ZGetEnvelopeItemFileDownloadRequestParamsSchema,
   ZGetEnvelopeItemFileRequestParamsSchema,
   ZGetEnvelopeItemFileRequestQuerySchema,
@@ -216,6 +222,60 @@ export const filesRoute = new Hono<HonoEnv>()
       });
     },
   )
+  .get(
+    '/envelope/:envelopeId/download-all/:version?',
+    sValidator('param', ZDownloadAllEnvelopeFilesRequestParamsSchema),
+    async (c) => {
+      const { envelopeId, version } = c.req.valid('param');
+
+      const session = await getOptionalSession(c);
+
+      if (!session.user) {
+        return c.json({ error: 'Unauthorized' }, 401);
+      }
+
+      const envelope = await prisma.envelope.findFirst({
+        where: {
+          id: envelopeId,
+        },
+        include: {
+          envelopeItems: {
+            orderBy: {
+              order: 'asc',
+            },
+            include: {
+              documentData: true,
+            },
+          },
+        },
+      });
+
+      if (!envelope) {
+        return c.json({ error: 'Envelope not found' }, 404);
+      }
+
+      const hasDownloadAccess = await checkEnvelopeFileAccess({
+        userId: session.user.id,
+        teamId: envelope.teamId,
+        envelopeType: envelope.type,
+        templateType: envelope.templateType,
+      });
+
+      if (!hasDownloadAccess) {
+        return c.json(
+          { error: 'User does not have access to the team that this envelope is associated with' },
+          403,
+        );
+      }
+
+      return await buildEnvelopeZipResponse({
+        envelopeTitle: envelope.title,
+        items: envelope.envelopeItems,
+        version,
+        context: c,
+      });
+    },
+  )
   .get(
     '/token/:token/envelopeItem/:envelopeItemId',
     sValidator('param', ZGetEnvelopeItemFileTokenRequestParamsSchema),
@@ -323,6 +383,52 @@ export const filesRoute = new Hono<HonoEnv>()
         context: c,
       });
     },
+  )
+  .get(
+    '/token/:token/download-all/:version?',
+    sValidator('param', ZDownloadAllEnvelopeFilesTokenRequestParamsSchema),
+    async (c) => {
+      const { token, version } = c.req.valid('param');
+
+      let envelopeWhereQuery: Prisma.EnvelopeWhereInput = {
+        recipients: {
+          some: {
+            token,
+          },
+        },
+      };
+
+      if (token.startsWith('qr_')) {
+        envelopeWhereQuery = {
+          qrToken: token,
+        };
+      }
+
+      const envelope = await prisma.envelope.findFirst({
+        where: envelopeWhereQuery,
+        include: {
+          envelopeItems: {
+            orderBy: {
+              order: 'asc',
+            },
+            include: {
+              documentData: true,
+            },
+          },
+        },
+      });
+
+      if (!envelope) {
+        return c.json({ error: 'Envelope not found' }, 404);
+      }
+
+      return await buildEnvelopeZipResponse({
+        envelopeTitle: envelope.title,
+        items: envelope.envelopeItems,
+        version,
+        context: c,
+      });
+    },
   );
 
 // PDF routes for both tokens and auth based
diff --git a/apps/remix/server/api/files/files.types.ts b/apps/remix/server/api/files/files.types.ts
index 4d581729c6..437e742138 100644
--- a/apps/remix/server/api/files/files.types.ts
+++ b/apps/remix/server/api/files/files.types.ts
@@ -72,3 +72,21 @@ export const ZGetEnvelopeItemFileTokenDownloadRequestParamsSchema = z.object({
 export type TGetEnvelopeItemFileTokenDownloadRequestParams = z.infer<
   typeof ZGetEnvelopeItemFileTokenDownloadRequestParamsSchema
 >;
+
+export const ZDownloadAllEnvelopeFilesRequestParamsSchema = z.object({
+  envelopeId: z.string().min(1),
+  version: z.enum(['signed', 'original']).default('signed'),
+});
+
+export type TDownloadAllEnvelopeFilesRequestParams = z.infer<
+  typeof ZDownloadAllEnvelopeFilesRequestParamsSchema
+>;
+
+export const ZDownloadAllEnvelopeFilesTokenRequestParamsSchema = z.object({
+  token: z.string().min(1),
+  version: z.enum(['signed', 'original']).default('signed'),
+});
+
+export type TDownloadAllEnvelopeFilesTokenRequestParams = z.infer<
+  typeof ZDownloadAllEnvelopeFilesTokenRequestParamsSchema
+>;
diff --git a/packages/lib/client-only/download-envelope-zip.ts b/packages/lib/client-only/download-envelope-zip.ts
new file mode 100644
index 0000000000..aaeda160ef
--- /dev/null
+++ b/packages/lib/client-only/download-envelope-zip.ts
@@ -0,0 +1,48 @@
+import { getEnvelopeDownloadAllUrl } from '../utils/envelope-download';
+import { downloadFile } from './download-file';
+
+type DownloadEnvelopeZipProps = {
+  envelopeId: string;
+  token: string | undefined;
+
+  /**
+   * Specifies which version of each document to include in the archive.
+   * 'signed': The signed version (default).
+   * 'original': The original (unsigned) version.
+   */
+  version?: 'original' | 'signed';
+
+  /** The base name to use for the downloaded archive (the envelope title). */
+  fileName?: string;
+};
+
+/**
+ * Downloads every document in an envelope as a single ZIP archive.
+ */
+export const downloadEnvelopeZip = async ({
+  envelopeId,
+  token,
+  version = 'signed',
+  fileName,
+}: DownloadEnvelopeZipProps) => {
+  const downloadUrl = getEnvelopeDownloadAllUrl({
+    envelopeId,
+    token,
+    version,
+  });
+
+  const response = await fetch(downloadUrl);
+
+  if (!response.ok) {
+    throw new Error(`Failed to download archive (${response.status})`);
+  }
+
+  const blob = await response.blob();
+
+  const baseTitle = (fileName ?? 'documents').replace(/\.zip$/, '');
+
+  downloadFile({
+    filename: `${baseTitle}.zip`,
+    data: blob,
+  });
+};
diff --git a/packages/lib/universal/zip.ts b/packages/lib/universal/zip.ts
new file mode 100644
index 0000000000..16957035d4
--- /dev/null
+++ b/packages/lib/universal/zip.ts
@@ -0,0 +1,153 @@
+/**
+ * A tiny, dependency-free ZIP archive writer.
+ *
+ * Files are stored uncompressed (the "store" method). This is intentional:
+ * the only consumer bundles already-compressed PDFs, where deflate would add
+ * CPU cost for virtually no size benefit. Keeping this dependency-free avoids
+ * pulling a zip library into the server bundle.
+ *
+ * Limitations: no ZIP64, so the archive and each individual entry must be
+ * smaller than 4GB. This is well within the bounds of bundling signed PDFs.
+ */
+
+export type ZipFile = {
+  /** The name (including any directory path) the file should have inside the archive. */
+  name: string;
+  /** The raw file contents. */
+  data: Uint8Array;
+};
+
+const CRC_TABLE = (() => {
+  const table = new Uint32Array(256);
+
+  for (let n = 0; n < 256; n++) {
+    let c = n;
+
+    for (let k = 0; k < 8; k++) {
+      c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+    }
+
+    table[n] = c >>> 0;
+  }
+
+  return table;
+})();
+
+const crc32 = (data: Uint8Array): number => {
+  let crc = 0xffffffff;
+
+  for (let i = 0; i < data.length; i++) {
+    crc = (crc >>> 8) ^ CRC_TABLE[(crc ^ data[i]) & 0xff];
+  }
+
+  return (crc ^ 0xffffffff) >>> 0;
+};
+
+// Fixed DOS timestamp (1980-01-01 00:00:00). The modification time is not
+// meaningful for these archives, so a constant keeps the output deterministic.
+const DOS_TIME = 0;
+const DOS_DATE = 0x0021;
+
+// General purpose bit 11 flags that file names are UTF-8 encoded.
+const FLAG_UTF8 = 0x0800;
+
+type ZipEntry = {
+  nameBytes: Uint8Array;
+  data: Uint8Array;
+  crc: number;
+  offset: number;
+};
+
+/**
+ * Builds a ZIP archive (store method) from the provided files and returns the
+ * raw bytes.
+ */
+export const createZip = (files: ZipFile[]): Uint8Array => {
+  const encoder = new TextEncoder();
+  const entries: ZipEntry[] = [];
+
+  const localParts: Uint8Array[] = [];
+  let offset = 0;
+
+  for (const file of files) {
+    const nameBytes = encoder.encode(file.name);
+    const crc = crc32(file.data);
+
+    const header = new Uint8Array(30 + nameBytes.length);
+    const view = new DataView(header.buffer);
+
+    view.setUint32(0, 0x04034b50, true); // Local file header signature
+    view.setUint16(4, 20, true); // Version needed to extract
+    view.setUint16(6, FLAG_UTF8, true); // General purpose bit flag
+    view.setUint16(8, 0, true); // Compression method (0 = store)
+    view.setUint16(10, DOS_TIME, true); // Last mod file time
+    view.setUint16(12, DOS_DATE, true); // Last mod file date
+    view.setUint32(14, crc, true); // CRC-32
+    view.setUint32(18, file.data.length, true); // Compressed size
+    view.setUint32(22, file.data.length, true); // Uncompressed size
+    view.setUint16(26, nameBytes.length, true); // File name length
+    view.setUint16(28, 0, true); // Extra field length
+    header.set(nameBytes, 30);
+
+    entries.push({ nameBytes, data: file.data, crc, offset });
+
+    localParts.push(header, file.data);
+    offset += header.length + file.data.length;
+  }
+
+  const centralStart = offset;
+  const centralParts: Uint8Array[] = [];
+
+  for (const entry of entries) {
+    const header = new Uint8Array(46 + entry.nameBytes.length);
+    const view = new DataView(header.buffer);
+
+    view.setUint32(0, 0x02014b50, true); // Central directory file header signature
+    view.setUint16(4, 20, true); // Version made by
+    view.setUint16(6, 20, true); // Version needed to extract
+    view.setUint16(8, FLAG_UTF8, true); // General purpose bit flag
+    view.setUint16(10, 0, true); // Compression method
+    view.setUint16(12, DOS_TIME, true); // Last mod file time
+    view.setUint16(14, DOS_DATE, true); // Last mod file date
+    view.setUint32(16, entry.crc, true); // CRC-32
+    view.setUint32(20, entry.data.length, true); // Compressed size
+    view.setUint32(24, entry.data.length, true); // Uncompressed size
+    view.setUint16(28, entry.nameBytes.length, true); // File name length
+    view.setUint16(30, 0, true); // Extra field length
+    view.setUint16(32, 0, true); // File comment length
+    view.setUint16(34, 0, true); // Disk number start
+    view.setUint16(36, 0, true); // Internal file attributes
+    view.setUint32(38, 0, true); // External file attributes
+    view.setUint32(42, entry.offset, true); // Relative offset of local header
+    header.set(entry.nameBytes, 46);
+
+    centralParts.push(header);
+    offset += header.length;
+  }
+
+  const centralSize = offset - centralStart;
+
+  const eocd = new Uint8Array(22);
+  const eocdView = new DataView(eocd.buffer);
+
+  eocdView.setUint32(0, 0x06054b50, true); // End of central directory signature
+  eocdView.setUint16(4, 0, true); // Number of this disk
+  eocdView.setUint16(6, 0, true); // Disk where central directory starts
+  eocdView.setUint16(8, entries.length, true); // Number of entries on this disk
+  eocdView.setUint16(10, entries.length, true); // Total number of entries
+  eocdView.setUint32(12, centralSize, true); // Size of central directory
+  eocdView.setUint32(16, centralStart, true); // Offset of central directory
+  eocdView.setUint16(20, 0, true); // Comment length
+
+  const totalSize = offset + eocd.length;
+  const output = new Uint8Array(totalSize);
+
+  let cursor = 0;
+
+  for (const part of [...localParts, ...centralParts, eocd]) {
+    output.set(part, cursor);
+    cursor += part.length;
+  }
+
+  return output;
+};
diff --git a/packages/lib/utils/envelope-download.ts b/packages/lib/utils/envelope-download.ts
index 82b1ed3eba..e8a5a62ad2 100644
--- a/packages/lib/utils/envelope-download.ts
+++ b/packages/lib/utils/envelope-download.ts
@@ -37,6 +37,26 @@ export const getEnvelopeItemPdfUrl = (options: EnvelopeItemPdfUrlOptions) => {
     : `${NEXT_PUBLIC_WEBAPP_URL()}/api/files/envelope/${envelopeId}/envelopeItem/${id}${presignToken ? `?token=${presignToken}` : ''}`;
 };
 
+export type EnvelopeDownloadAllUrlOptions = {
+  envelopeId: string;
+  token: string | undefined;
+  version: 'original' | 'signed';
+};
+
+/**
+ * Builds the URL that returns every document in an envelope bundled into a
+ * single ZIP archive.
+ */
+export const getEnvelopeDownloadAllUrl = ({
+  envelopeId,
+  token,
+  version,
+}: EnvelopeDownloadAllUrlOptions) => {
+  return token
+    ? `${NEXT_PUBLIC_WEBAPP_URL()}/api/files/token/${token}/download-all/${version}`
+    : `${NEXT_PUBLIC_WEBAPP_URL()}/api/files/envelope/${envelopeId}/download-all/${version}`;
+};
+
 export type DocumentDataUrlOptions = {
   envelopeId: string;
   envelopeItemId: string;