Mastering File Compression in Apex A Beginner's Guide to ZipWriter and ZipReader

Mastering File Compression in Apex: A Beginner’s Guide to ZipWriter and ZipReader

—

,

Introduction

With the Salesforce Spring ’25 release, Apex gained native support for ZIP file operations through the Compression namespace. This powerful enhancement introduces the ZipWriter and ZipReader classes—enabling you to create, read, and manage .zip archives entirely within Apex.

Gone are the days of relying on external libraries, middleware, or complex workarounds. Whether you need to bundle multiple documents for download, Salesforce provides a streamlined solution. You can also compress large blobs to conserve storage. Additionally, it is perfect if you need to unpack incoming ZIP uploads. It is an out‑of‑the‑box feature.

In this post, we’ll dive into:

  • The core classes: ZipWriter, ZipReader, and ZipEntry
  • Compression settings: How to fine‑tune using Compression.Level and Compression.Method
  • Hands‑on examples: One for zipping, one for unzipping
  • Real‑world use cases and performance considerations
  • Limitations and best practices to keep your implementations robust

Features –

Salesforce’s built‑in ZIP capabilities unlock a variety of scenarios:

  1. Download Bundles
    Package multiple reports, PDFs, or images into a single ZIP for user download.
  2. Storage Optimization
    Compress large data blobs—like base64‑encoded logs or large attachments—to reduce space usage.
  3. Batch Data Ingestion
    Upload ZIP files containing CSVs or XMLs, then extract and process each file in bulk jobs.
  4. Email Attachments
    Send multiple documents in one compressed attachment via Messaging.EmailFileAttachment.
  5. API Integrations
    Communicate with external systems that require ZIP‑formatted payloads.

Core Classes and Enums

1. ZipEntry Class

Each ZipEntry represents one item—either a file or a directory—inside your ZIP archive. Whether you’re building an archive with ZipWriter or inspecting one with ZipReader, ZipEntry provides access to key metadata. It also allows you to view the content. Here’s how to make the most of it:

1. Creating a New Entry (for Zipping)
When using ZipWriter, you can package files by instantiating ZipEntry objects directly:

// Create entries for two files
Compression.ZipEntry entry1 = new Compression.ZipEntry('docs/overview.txt', overviewBlob);
Compression.ZipEntry entry2 = new Compression.ZipEntry('images/logo.png', logoBlob);

// Add them in a batch
List<Compression.ZipEntry> entries = new List<Compression.ZipEntry>{ entry1, entry2 };
writer.addEntries(entries);

2. Retrieving Entries (for Unzipping)
With ZipReader, you fetch a list of existing entries:

List<Compression.ZipEntry> entries = reader.getEntries();

3. Key Methods

  • entry.getName() (Return Type – String): The path and filename within the ZIP (e.g., "reports/Q1.pdf").
  • entry.getCompressedSize() (Return Type – Long): The size after compression—useful for gauging compression efficiency.
  • entry.getUncompressedSize() (Return Type – Long): The size after uncompression—useful for gauging compression efficiency.
  • entry.getContent() (Return Type – Blob): Holds the binary data only after you call reader.extract(entry).

4. Inspecting Metadata
Before extracting, you can log or filter based on these fields:

for (Compression.ZipEntry entry : entries) {
    System.debug('Entry Name: ' + entry.getName());
	System.debug('Entry Content: ' + entry.getContent());
	System.debug('Entry Compressed Size: ' + entry.getCompressedSize());
    System.debug('Entry Uncompressed Size: ' + entry.getUncompressedSize());
}

5. Extracting File Data
Only non-directory entries contain usable data:

if (!entry.isDirectory) {
    Blob fileBlob = reader.extract(entry);
    // Now entry.data is available if you need it again:
    Blob cached = entry.data;
}
2. ZipReader Class

The ZipReader class empowers you to open, inspect, and extract files from a ZIP archive entirely within Apex. Given a Blob that represents your .zip file, you can unpack its contents, examine metadata, and process each entry as needed. Here’s how to harness ZipReader:

1. Instantiate the Writer

Compression.ZipReader reader = new Compression.ZipReader(zipBlob);

Supply the Blob of your ZIP archive to the constructor.

2. Retrieve All Entries

List<Compression.ZipEntry> entries = reader.getEntries();

getEntries() returns every file and folder inside the ZIP as a list of ZipEntry objects.

3. Examine Entry Details

For each entry, you can inspect its properties:

for (Compression.ZipEntry entry : entries) {
	System.debug('Entry Path and Name: ' + entry.getName());
	System.debug('Entry Content: ' + entry.getContent());
	System.debug('Entry Compressed Size: ' + entry.getCompressedSize());
	System.debug('Entry Uncompressed Size: ' + entry.getUncompressedSize());
}

Use these fields to filter out directories or to log archive contents before extraction.

4. Extract Individual Files

for (Compression.ZipEntry entry : entries) {
    if (!entry.isDirectory()) {
        Blob fileData = reader.extract(entry);
        // Now you can:
        // • Create a ContentVersion record
        // • Parse CSV or JSON content
        // • Attach the blob to a record
    }
}

extract(entry) returns the raw Blob data for that file entry.

5. Fetch a Specific Entry by Name

Compression.ZipEntry invoiceEntry = reader.getEntry('invoices/July2025.pdf');
if (invoiceEntry != null) {
    Blob invoiceBlob = reader.extract(invoiceEntry);
    // Process the invoice blob as needed
}

getEntry(String name) locates one entry by its internal path; returns null if not found.

6. Handle Errors Gracefully

Use Compression.ZipException class for handling exceptions in zip process

try {
    // Reader initialization and extraction logic
} catch (Exception e) {
    // Log the error, notify users, or implement fallback logic
    System.debug('ZIP processing error: ' + e.getMessage());
}

Always wrap ZIP operations in try-catch to manage corrupt archives or unexpected failures.

3. ZipWriter Class

The ZipWriter class allows you to create a .zip file directly within Apex and retrieve the finished zip archive as a single Blob. Once you have this Blob, you can:

  • Link it to any standard or custom record as a traditional attachment.
  • Save it into Salesforce Files by inserting a ContentVersion.
  • Include it as an attachment in an outbound email via Messaging.EmailFileAttachment.

Under the hood, ZipWriter organizes your files into “entries”—each entry representing one file (or directory) inside the ZIP package. Here’s how you work with it:

1. Instantiate the Writer

Compression.ZipWriter writer = new Compression.ZipWriter();

2. Configure Compression (Optional)
You can fine‑tune how aggressively files are compressed:

writer.setCompressionLevel(Compression.Level.BEST_COMPRESSION);
writer.setCompressionMethod(Compression.Method.DEFLATED);
  • Compression.Level lets you choose between faster compression (lower CPU) or smaller archive size.
  • Compression.Method determines whether data is actually compressed (DEFLATED) or simply stored (STORED).

3. Add Single Files
To include one file at a time, call:

writer.addEntry('reports/sales_report.pdf', pdfBlob);
  • The first argument is the internal path and filename inside the ZIP.
  • The second is the file’s binary content as a Blob.

4. Add Multiple Files at Once

List<Compression.ZipEntry> entries = new List<Compression.ZipEntry>{
    new Compression.ZipEntry('image1.png', imageBlob1),
    new Compression.ZipEntry('notes.txt', textBlob)
};
writer.addEntries(entries);

5. Generate the Archive
After all desired entries have been queued up, compile everything into the final archive:

Blob zipArchive = writer.getArchive();

This method packages all entries into a single Blob representing your .zip file—ready for storage, download, or transmission.

Some Examples

Example 1: Unpacking Community‑Uploaded ZIPs to Account Attachments

Scenario: A community user uploads a ZIP file (which contain nested folders like pdfs/, word/, etc.) against an Account record. We need to extract each file and attach it to the Account.

/**
* CommunityZipHandler
* 
* This class handles the processing of ZIP files uploaded to a community,
* extracting files and creating Attachment records for each file.
* It supports nested ZIP files by recursively processing them.
*/
public with sharing class CommunityZipHandler {
    /**
    * Recursively processes a ZIP file, extracting files and handling nested ZIPs.
    *
    * @param accountId The target Account ID.
    * @param zipBlob   The uploaded ZIP file as a Blob.
    */
    public static void processZip(Id accountId, Blob zipBlob, List<Attachment> attachmentToInsert) {
        try {
            // 1️. Initialize the reader with the incoming ZIP Blob
            Compression.ZipReader reader = new Compression.ZipReader(zipBlob);
            // 2️. Enumerate all entries (files + folders)
            List<Compression.ZipEntry> entries = reader.getEntries();
            // Loop through each entry in the ZIP
            for (Compression.ZipEntry entry : entries) {
                // 3️. Skip directories
                if (entry.getName().endsWith('/')) continue;
                // Check if the entry is a nested ZIP file
                if (entry.getName().toLowerCase().endsWith('.zip')) {
                    // 4️. If the entry is a nested ZIP, recursively process it
                    Blob nestedZipBlob = reader.extract(entry);
                    processZip(accountId, nestedZipBlob, attachmentToInsert);
                } else {
                    // 5️. Extract the file data from the entry
                    Blob fileData = reader.extract(entry);
                    // 6️. Create an Attachment record for the file
                    Attachment a = new Attachment();
                    a.ParentId    = accountId;
                    a.Name        = entry.getName().contains('/') ? entry.getName().substringAfterLast('/') : entry.getName();
                    a.Body        = fileData;
                    attachmentToInsert.add(a);
                }
            }
        } catch (Compression.ZipException ze) {
            //Handle exception here
            System.debug('ze+++'+ze);
        }
    }
    
    /**
    * Handles the ZIP upload and creates Attachment records.
    *
    * @param accountId The target Account ID.
    * @param zipBlob   The uploaded ZIP file as a Blob.
    */
    public static void handleZipUpload(Id accountId, Blob zipBlob) {
        try{
            //Define a list to hold Attachment records to insert
            List<Attachment> attachmentToInsert = new List<Attachment>();
            // 7️. Process the ZIP file and populate the Attachment list
            processZip(accountId, zipBlob, attachmentToInsert);
            // 8️. Check if there are any attachments to insert
            if (!attachmentToInsert.isEmpty()) {
                // 9️. Insert the attachments
                insert attachmentToInsert;
            }
        } catch (Exception ex) {
            System.debug('ex+++'+ex.getMessage()+' - '+ex.getLineNumber());
        }
    }
}

Test Class –

/**
 * @description Unit tests for the CommunityZipHandler class.
 * This class tests the functionality of handling ZIP uploads,
 */
@isTest
private class CommunityZipHandlerTest {
    /*
     * Test setup method to create a test Account.
     */
    @testSetup
    static void setup() {
        Account acc = new Account(Name = 'Test Account');
        insert acc;
    }

    /*
     * Helper method to create a simple ZIP Blob with one file.
     * This is used in the test cases to simulate a ZIP upload.
     */
    private static Blob createSimpleZipBlob() {
        Compression.ZipWriter zipWriter = new Compression.ZipWriter();
        Blob fileBlob = Blob.valueOf('Hello, World!');
        zipWriter.addEntry('hello.txt', fileBlob);
        return zipWriter.getArchive();
    }

    /**
     * Helper method to create a nested ZIP Blob.
     * This ZIP contains another ZIP file inside it.
     * This is used to test the handling of nested ZIP files.
     */
    private static Blob createNestedZipBlob() {
        Compression.ZipWriter innerZip = new Compression.ZipWriter();
        innerZip.addEntry('inner.txt', Blob.valueOf('Inner file'));
        Blob innerZipBlob = innerZip.getArchive();

        Compression.ZipWriter outerZip = new Compression.ZipWriter();
        outerZip.addEntry('outer.txt', Blob.valueOf('Outer file'));
        outerZip.addEntry('nested.zip', innerZipBlob);
        return outerZip.getArchive();
    }

    /**
     * Helper method to create a ZIP Blob that contains only folders.
     * This is used to test the case where the ZIP contains no files.
     */
    private static Blob createZipWithFoldersOnly() {
        Compression.ZipWriter zipWriter = new Compression.ZipWriter();
        zipWriter.addEntry('folder/', Blob.valueOf(''));
        return zipWriter.getArchive();
    }

    /**
     * Test method to verify that a simple ZIP file with one file
     * creates the correct Attachment record.
     * This test checks that the file is extracted and stored correctly.
     */
    @isTest
    static void testHandleZipUpload_SimpleZip() {
        Id testAccountId = [Select Id from Account].Id;
        Blob zipBlob = createSimpleZipBlob();
        Test.startTest();
        CommunityZipHandler.handleZipUpload(testAccountId, zipBlob);
        Test.stopTest();

        List<Attachment> attachments = [SELECT Id, Name, ParentId FROM Attachment WHERE ParentId = :testAccountId];
        System.assertEquals(1, attachments.size(), 'Should create one attachment');
        System.assertEquals('hello.txt', attachments[0].Name);
    }

    /**
     * Test method to verify that a nested ZIP file is processed correctly.
     * This test checks that both the outer and inner files are extracted
     * and stored as Attachment records.
     */
    @isTest
    static void testHandleZipUpload_NestedZip() {
        Id testAccountId = [Select Id from Account].Id;
        Blob zipBlob = createNestedZipBlob();
        Test.startTest();
        CommunityZipHandler.handleZipUpload(testAccountId, zipBlob);
        Test.stopTest();

        List<Attachment> attachments = [SELECT Id, Name, ParentId FROM Attachment WHERE ParentId = :testAccountId];
        Set<String> expectedNames = new Set<String>{'outer.txt', 'inner.txt'};
        System.assertEquals(2, attachments.size(), 'Should create two attachments');
        for (Attachment a : attachments) {
            System.assert(expectedNames.contains(a.Name), 'Unexpected attachment name: ' + a.Name);
        }
    }

    /**
     * Test method to verify that an empty ZIP file does not create any Attachment records.
     * This test checks that the system handles empty ZIP files gracefully.
     */
    @isTest
    static void testHandleZipUpload_EmptyZip() {
        Id testAccountId = [Select Id from Account].Id;
        Compression.ZipWriter zipWriter = new Compression.ZipWriter();
        Blob zipBlob = zipWriter.getArchive();
        Test.startTest();
        CommunityZipHandler.handleZipUpload(testAccountId, zipBlob);
        Test.stopTest();

        List<Attachment> attachments = [SELECT Id FROM Attachment WHERE ParentId = :testAccountId];
        System.assertEquals(0, attachments.size(), 'No attachments should be created for empty zip');
    }

    /**
     * Test method to verify that a ZIP file containing only folders does not create any Attachment records.
     * This test checks that the system correctly identifies and skips folders.
     */
    @isTest
    static void testHandleZipUpload_FoldersOnly() {
        Id testAccountId = [Select Id from Account].Id;
        Blob zipBlob = createZipWithFoldersOnly();
        Test.startTest();
        CommunityZipHandler.handleZipUpload(testAccountId, zipBlob);
        Test.stopTest();

        List<Attachment> attachments = [SELECT Id FROM Attachment WHERE ParentId = :testAccountId];
        System.assertEquals(0, attachments.size(), 'No attachments should be created for zip with only folders');
    }

    /**
     * Test method to verify that an exception in the ZIP processing does not create any Attachment records.
     * This test checks that the system handles exceptions gracefully without leaving behind incomplete records.
     * This test simulates an exception by passing an invalid Blob.
     */
    @isTest
    static void testProcessZip_ExceptionOfZipClass() {
        Id testAccountId = [Select Id from Account].Id;
        Blob invalidBlob = Blob.valueOf('not a zip');
        List<Attachment> attachments = new List<Attachment>();
        Test.startTest();
        CommunityZipHandler.processZip(testAccountId, invalidBlob, attachments);
        Test.stopTest();
        System.assertEquals(0, attachments.size(), 'Zip load exception should not create any attachments');
    }
    
    /**
     * Test method to verify that when the ParentId is null, no Attachment records are created.
     * This test ensure that that the system handles exceptions while inserting attachments gracefully.
     */
    @isTest
    static void testProcessZip_ExceptionCoverageofAttachmentInsert() {
        Id testAccountId = null;
        Blob zipBlob = createSimpleZipBlob();
        Test.startTest();
        CommunityZipHandler.handleZipUpload(testAccountId, zipBlob);
        Test.stopTest();

        List<Attachment> attachments = [SELECT Id, Name, ParentId FROM Attachment WHERE ParentId = :testAccountId];
       System.assertEquals(0, attachments.size(), 'No attachments should be created when ParentId is null.');
    }
}
Example 2: Zipping Individual Case Files into One ZIP in Salesforce Files

Scenario: A user adds multiple files (ContentVersion records) to a Case. We must bundle them into a single ZIP and link it via a new ContentVersion on the Case’s Contact.

public with sharing class CaseFilesZipper {
    /**
     * Compresses all ContentVersions for a Case into one ZIP and saves it under the Case Contact.
     *
     * @param caseId The Case whose files should be zipped.
     */
    public static void zipCaseFiles(Id caseId) {
        // 1️. Query all related ContentDocumentLinks for the Case
        List<ContentDocumentLink> links = [
            SELECT ContentDocumentId
              FROM ContentDocumentLink
             WHERE LinkedEntityId = :caseId
        ];
        Set<Id> docIds = new Set<Id>();
        for (ContentDocumentLink l : links) {
            docIds.add(l.ContentDocumentId);
        }

        // 2️. Query all related ContentVersions
        List<ContentVersion> cvs = new List<ContentVersion>();
        if (!docIds.isEmpty()) {
            cvs = [
                SELECT Id, Title, PathOnClient, VersionData, ContentDocumentId
                  FROM ContentVersion
                 WHERE ContentDocumentId IN :docIds
            ];
        }
         
        // 3️. Initialize the writer and configure compression
        Compression.ZipWriter writer = new Compression.ZipWriter();
        writer.setLevel(compression.Level.DEFAULT_LEVEL);
        // writer.setCompressionMethod(Compression.Method.DEFLATED); // Removed: method does not exist
         
        // 4️. Add each file as a separate entry
        for (ContentVersion cv : cvs) {
            writer.addEntry(cv.PathOnClient, cv.VersionData);
        }
         
        // 5️. Compile the ZIP Blob
        Blob zipBlob = writer.getArchive();
         
        // 6️. Create a new ContentVersion for the ZIP itself
        ContentVersion zipCv = new ContentVersion(
            Title       = 'CaseFiles_' + caseId + '.zip',
            PathOnClient= 'CaseFiles_' + caseId + '.zip',
            VersionData = zipBlob,
            Origin      = 'H'
        );
        insert zipCv;
         
        // 7️. Link the ZIP file to the Case Contact
        Case c = [SELECT ContactId FROM Case WHERE Id = :caseId];
        if (c.ContactId != null) {
            ContentDocumentLink link = new ContentDocumentLink(
                ContentDocumentId = [SELECT ContentDocumentId 
                                       FROM ContentVersion 
                                      WHERE Id = :zipCv.Id].ContentDocumentId,
                LinkedEntityId    = c.ContactId,
                ShareType         = 'V',
                Visibility        = 'AllUsers'
            );
            insert link;
        }
    }
}

Test Class –

@isTest
private class CaseFilesZipperTest {
    @testSetup
    static void setup() {
        // Create a Contact and a Case linked to that Contact
        Contact con = new Contact(FirstName = 'Test', LastName = 'Contact', Email = 'test@example.com');
        insert con;
        Case c = new Case(ContactId = con.Id, Subject = 'Test Case');
        insert c;

        // Create a ContentDocument and ContentVersion, then link to the Case
        ContentVersion cv = new ContentVersion(
            Title = 'TestFile.txt',
            PathOnClient = 'TestFile.txt',
            VersionData = Blob.valueOf('Test file content'),
            Origin = 'H'
        );
        insert cv;

        // Get ContentDocumentId from ContentVersion
        cv = [SELECT Id, ContentDocumentId FROM ContentVersion WHERE Id = :cv.Id];
        ContentDocumentLink cdl = new ContentDocumentLink(
            ContentDocumentId = cv.ContentDocumentId,
            LinkedEntityId = c.Id,
            ShareType = 'V',
            Visibility = 'AllUsers'
        );
        insert cdl;
    }

    @isTest
    static void testZipCaseFiles_CreatesZipAndLinksToContact() {
        // Get the test Case and Contact
        Case testCase = [SELECT Id, ContactId FROM Case LIMIT 1];
        Contact testContact = [SELECT Id FROM Contact WHERE Id = :testCase.ContactId];

        // Run the method
        Test.startTest();
        CaseFilesZipper.zipCaseFiles(testCase.Id);
        Test.stopTest();

        // Find the new ContentVersion for the ZIP
        List<ContentVersion> zipVersions = [
            SELECT Id, Title, ContentDocumentId
            FROM ContentVersion
            WHERE Title LIKE 'CaseFiles_%'
        ];
        System.assertEquals(1, zipVersions.size(), 'Should create one ZIP ContentVersion');

        // Check that the ContentDocumentLink exists for the Contact
        List<ContentDocumentLink> links = [
            SELECT Id, ContentDocumentId, LinkedEntityId
            FROM ContentDocumentLink
            WHERE LinkedEntityId = :testContact.Id
            AND ContentDocumentId = :zipVersions[0].ContentDocumentId
        ];
        System.assertEquals(1, links.size(), 'Should link ZIP to the Case Contact');
    }

    @isTest
    static void testZipCaseFiles_NoContactOnCase() {
        // Create a Case with no Contact
        Case c = new Case(Subject = 'No Contact');
        insert c;

        // Run the method
        Test.startTest();
        CaseFilesZipper.zipCaseFiles(c.Id);
        Test.stopTest();

        // Should create the ZIP ContentVersion but not link to a Contact
        List<ContentVersion> zipVersions = [
            SELECT Id, Title, ContentDocumentId
            FROM ContentVersion
            WHERE Title LIKE 'CaseFiles_%'
        ];
        System.assert(zipVersions.size() > 0, 'Should create a ZIP ContentVersion');

        List<ContentDocumentLink> links = [
            SELECT Id FROM ContentDocumentLink WHERE LinkedEntityId = :c.Id
        ];
        System.assertEquals(0, links.size(), 'Should not link ZIP to any Contact');
    }
}
Example 3: Generating & Emailing a Monthly ZIP Report

Scenario: On the last day of each month, a scheduled job runs a report. It pulls closed Opportunities. The job zips the generated PDFs and emails the bundle to a business user.

global class MonthlyReportScheduler implements Schedulable {
    // This class is scheduled to run monthly to send a zipped report of closed opportunities.
    global void execute(SchedulableContext sc) {
        MonthlyReportService.sendZippedReport('executive@example.com');
    }
}

public class MonthlyReportService {
    /**
     * Runs reports, zips the resulting PDF, and emails the ZIP.
     *
     * @param recipientEmail The business user's email address.
     */
    public static void sendZippedReport(String recipientEmail) {
        // 1️. Fetch the Opportunity Closure Report as a PDF Blob using Analytics API
        HttpRequest req = new HttpRequest();
        // Set the endpoint to the report URL to use analytics API and pass the export parameters as reportId and export format
        req.setEndpoint(URL.getOrgDomainUrl().toExternalForm() + '/services/data/v60.0/analytics/reports/00O5h0000080NdfEAE?export=1&enc=UTF-8&xf=pdf');
        // Set the method to GET
        req.setMethod('GET');
        // Set the header with the Authorization Bearer token as the session ID
        req.setHeader('Authorization', 'Bearer ' + UserInfo.getSessionId());
        // Create an HTTP object
        Http http = new Http();
        // Send the request and get the response
        HttpResponse res = http.send(req);
        // Store the response body as a Blob
        Blob oppPdf = res.getBodyAsBlob();

        // 2️. Initialize ZipWriter
        Compression.ZipWriter writer = new Compression.ZipWriter();
        writer.setLevel(Compression.Level.BEST_SPEED);
         
        // 3️. Add the report file
        writer.addEntry('ClosedOpportunities.pdf', oppPdf);
         
        // 4️. Produce the ZIP
        Blob reportZip = writer.getArchive();
         
        // 5️. Build and send the email with ZIP attachment
        Messaging.EmailFileAttachment attachment = new Messaging.EmailFileAttachment();
        attachment.setFileName('MonthlyReport.zip');
        attachment.setBody(reportZip);
        System.debug('attachment+++'+attachment);
        Messaging.SingleEmailMessage mail = new Messaging.SingleEmailMessage();
        mail.setToAddresses(new List<String>{ recipientEmail });
        mail.setSubject('Monthly Closure Reports');
        mail.setPlainTextBody('Please find attached the ZIP with this month’s closed items.');
        mail.setFileAttachments(new List<Messaging.EmailFileAttachment>{ attachment });
        // 6️. Send the email
        Messaging.sendEmail(new List<Messaging.SingleEmailMessage>{ mail });
        
    }
}

Limitations and Considerations

When working with ZIP operations, keep in mind:

Limit TypeSynchronous ApexAsynchronous Apex
Max Blob Size6 MB12 MB
Heap Size6 MB12 MB
Max Files/ZIP1,000 entries—
Total Uncompressed20 MB—
Max Compressed ZIP10 MB—
  • Heap Usage: Bulk compression/extraction can spike memory.
  • Asynchronous Processing: For large archives, wrap logic in Queueable or Batchable Apex.
  • Filename Safety: Avoid spaces or special characters that can impede extraction.
  • Error Handling: Always enclose ZIP logic in try-catch to manage corrupt archives or unexpected failures.

Best Practices

  1. Plan for Limits
    Test with files of varying sizes to ensure you stay within heap and blob constraints.
  2. Use Asynchronous Apex
    Offload heavy ZIP tasks to avoid blocking UI threads or hitting synchronous time limits.
  3. Graceful Exception Handling
    Catch and log errors. Provide fallback paths if extraction or compression fails.
  4. Validate Inputs
    Check incoming ZIP files for malicious content before extracting.
  5. Leverage Compression Settings
    Tune Compression.Level and Compression.Method to strike the right balance between speed and archive size.
  6. Validate File Names: Ensure file names are properly formatted to prevent issues during extraction
  7. Encrypt Sensitive Data: Ensure to encrypt the files, if contains sensitive information.

Additional Resources

Conclusion

The Compression namespace in Apex marks a significant step forward in simplifying file management on the Salesforce platform. By mastering ZipWriter and ZipReader, developers can create more efficient data pipelines. They can improve user experiences and also reduce reliance on external services. Start experimenting with these classes today, and unlock new possibilities for your Salesforce applications.

Leave a comment