Overcoming the DUPLICATE_VALUE Email Exception

(Salesforce Known Issue: a028c00000zKD3K)

At BigSolve, we’re dedicated to delivering robust Salesforce solutions. Recently, while sending multiple emails in rapid succession—especially those with multiple attachments—we encountered the following error:

_{Error Message}

System.EmailException: SendEmail failed. First exception on row 1; first error: DUPLICATE_VALUE, duplicate value found: <unknown> duplicates value on record with id: <unknown>: []

‍

After reaching out to Salesforce Support, we received a detailed explanation that confirmed this is a known issue. Here’s a summary of their response:
The issue occurs because when you attach multiple files and send emails to multiple users, Salesforce attempts to create multiple ContentDelivery records for the same ContentVersion within a single second. Since the platform records the Created Date only up to seconds (formatted as yyyy-mm-dd hh:mm:ss)—without millisecond precision—all records created within the same second appear identical. This results in a UniqueConstraintException on the AKDISTRIBUTION index in the content.distribution table.

Recommendation: Send one email at a time or generate all SingleEmailMessages and add a 1-second delay between sending each email to avoid creating records with the same timestamp.

‍

Understanding the Root Cause

When Salesforce processes multiple email sends rapidly, it creates several ContentDelivery records almost simultaneously. Because the platform only captures the timestamp up to the second, any emails sent within the same second share an identical timestamp. This leads to a duplicate value error on the AKDISTRIBUTION index, as Salesforce attempts to enforce uniqueness for each record.

‍

Our Simple Workaround: A 1-Second Delay

To mitigate this issue, we implemented a 1-second delay between each email send. This delay gives Salesforce enough time to register a unique timestamp for each email, thereby preventing the duplicate value error.

‍

Apex Controller Implementation

Our Apex controller, SendEmailController, manages email parameters and sends emails using Messaging.sendEmail(). Here’s the controller code:

_{SendEmailController}

public with sharing class SendEmailController {
    
    // Email object definition
    public class Email {
        @AuraEnabled public List<String> toAddresses { get; set; }
        @AuraEnabled public List<String> ccAddresses { get; set; }
        @AuraEnabled public String fromAddress { get; set; }
        @AuraEnabled public Id orgWideEmailId { get; set; }
        @AuraEnabled public Id whatId { get; set; }
        @AuraEnabled public String subject { get; set; }
        @AuraEnabled public String body { get; set; }
        @AuraEnabled public List<String> fileIds { get; set; }
    }
    
    // Send Email method
    @AuraEnabled
    public static void sendEmail(Email email) {
        Messaging.SingleEmailMessage mail = new Messaging.SingleEmailMessage();
        Boolean hasRecipients = false;
        
        if (email.toAddresses != null && email.toAddresses.size() > 0) {
            mail.setToAddresses(new List<String>(new Set<String>(email.toAddresses)));
            hasRecipients = true;
        }
        
        if (email.ccAddresses != null && email.ccAddresses.size() > 0) {
            mail.setCcAddresses(new List<String>(new Set<String>(email.ccAddresses)));
            hasRecipients = true;
        }
        
        if (hasRecipients) {
            mail.setSubject(email.subject);
            mail.setPlainTextBody(email.body);
            mail.setReplyTo(email.fromAddress);
            
            if (email.orgWideEmailId != null) {
                mail.setOrgWideEmailAddressId(email.orgWideEmailId);
            }
            
            if (email.whatId != null) {
                mail.setWhatId(email.whatId);
                mail.setSaveAsActivity(true);
            }
            
            if (email.fileIds != null && email.fileIds.size() > 0) {
                mail.setEntityAttachments(email.fileIds);
            }
            
            try {
                Messaging.sendEmail(new Messaging.SingleEmailMessage[] { mail });
            } catch (Exception e) {
                System.debug('Exception during Messaging.sendEmail: ' + e.getMessage());
                throw new AuraHandledException('Error sending email: ' + e.getMessage());
            }
        }
    }
}

‍

Asynchronous Email Sending with a 1-Second Delay

To ensure each email is processed independently and avoid the duplicate record creation, we adjusted our JavaScript logic to include a 1-second delay between sends:

_sendEmails

// Send emails individually with a 1-second delay between each
async sendEmails(emails) {
    if (emails.length > 0) {
        // Send the first email and await its completion.
        await sendEmail({ email: emails[0] });
        // Schedule remaining emails with a delay.
        emails.slice(1).forEach((email, index) => {
            setTimeout(() => {
                sendEmail({ email }).catch(error => {
                    console.error('Error sending email:', error);
                });
            }, 1000 * (index + 1));
        });
    }
}

‍

This simple delay ensures that no two ContentDelivery records are created in the same second, effectively bypassing the unique constraint violation.

‍

Results and Benefits

• Error-Free Email Processing: The 1-second delay completely eliminates the DUPLICATE_VALUE error.
• Stable Operations: Each email is processed as a separate transaction, ensuring system stability.
• Enhanced User Experience: Our users now enjoy seamless email sends without unexpected interruptions.

‍

Final Thoughts

Salesforce’s limitation of recording timestamps only to the second can have unintended consequences when sending multiple emails rapidly. Our workaround, inspired by the detailed feedback from Salesforce Support, has proven to be a reliable solution for this known issue. We hope our experience helps others facing similar challenges!