Outlook VBA Code to Forward Email: A Comprehensive Guide

Last Updated on July 1, 2023 by Amit Bansal

In the world of email management, automation can be a game-changer for those who handle countless emails daily.

One such powerful automation tool is Visual Basic for Applications (VBA) in Microsoft Outlook.

VBA allows users to perform various actions automatically, streamlining their work processes and reducing manual efforts.

One common task that VBA can help with is forwarding emails to specific recipients or processing the content before forwarding.

Outlook’s VBA, though a bit technical, provides flexibility and customization options for handling email-related tasks, such as forwarding emails.

With just a few lines of code, we can create a simple script that can enable Outlook to forward an email from a specific folder or automatically forward an email that meets certain conditions.

By understanding and utilizing VBA in Outlook, we can improve our overall email management efficiency and simplify a variety of tasks.

Setting Up an Outlook VBA Environment

Setting up an Outlook VBA environment is a crucial first step to automate tasks such as forwarding emails.

We are here to help guide you through this process in a clear and straightforward manner.

First, we need to ensure that the Developer tab is enabled in Outlook.

To do this, navigate to File >> Options >> Customize Ribbon and check the Developer box. Now you should see the Developer tab in your Outlook menu.

Next, click the Developer tab and select Visual Basic to open the VBA editor.

In the VBA editor, go to Insert >> Module to create a new module where you can write your code.

To set up an Outlook VBA environment, we must first create an event that triggers when the application starts up.

The Application_Startup event is essential for our automation process. Here’s a simple example to define the event within the VBA editor:

Public WithEvents objInbox As Outlook.Folder
Public WithEvents objInboxItems As Outlook.Items

Private Sub Application_Startup()
    Set objInbox = Outlook.Application.Session.GetDefaultFolder(olFolderInbox)
    Set objInboxItems = objInbox.Items
End Sub

In this example, we declare two global variables to handle the Inbox folder (objInbox) and its items (objInboxItems).

The Application_Startup event is responsible for initializing these variables, connecting to the default Inbox folder, and its items.

To customize the behavior of the VBA environment and handle more specific tasks like forwarding emails, we must add additional code to the Application_Startup event.

The following example demonstrates this customization by forwarding an email when specific conditions are met:

Private Sub objInboxItems_ItemAdd(ByVal item As Object)
    Dim objMail As Outlook.MailItem
    Dim objForward As Outlook.MailItem

    If TypeOf item Is MailItem Then
        Set objMail = item
        ' Check if it's a specific new email
        If objMail.Subject = "Your target email subject" Then
            ' Forward the email to the desired recipient
            Set objForward = objMail.Forward
            objForward.Recipients.Add "example@email.com"
        End If
    End If
End Sub

This code snippet forwards an email with a specific subject to a designated email address. It adds a new event, which is triggered when a new item is added to the Inbox folder.

By incorporating these code examples into your Outlook VBA environment, you can effectively set up and customize the process of forwarding emails automatically.

Remember, VBA offers a diverse range of automation possibilities, allowing you to explore more advanced solutions tailored to your needs.

Related Article: How to Add VBA Code to Outlook: [A Concise Guide]

Forwarding Emails with VBA

In the world of Microsoft Outlook, VBA (Visual Basic for Applications) is a powerful tool for automating tasks such as forwarding emails.

By using the VBA code, we can enhance productivity and simplify email management. In this section, we will discuss how to forward emails using VBA in Outlook.

First, let’s begin by understanding the MailItem object. In Outlook VBA, the MailItem object represents a mail item, which includes attributes like subject, sender, recipient, and body.

To forward an email, we utilize the Forward method of the MailItem object.

This method creates a new MailItem object that is a copy of the original email with all its contents and formatting.

Here’s a simple example of how to forward an email:

Sub ForwardEmail()
  Dim OriginalEmail As MailItem
  Dim ForwardedEmail As MailItem

  Set OriginalEmail = Application.ActiveExplorer.Selection.Item(1)
  Set ForwardedEmail = OriginalEmail.Forward

  ' Customizing the forwarded email
  ForwardedEmail.Subject = "FW: " & OriginalEmail.Subject
  ForwardedEmail.Recipients.Add "email@example.com"
End Sub

In this code snippet, we first selected the email we want to forward using the ActiveExplorer.Selection.Item() method.

Then, we called the Forward method on the selected email to create a new MailItem object that contains the forwarded content.

Next, we customized the forwarded email’s subject, added recipients, and finally sent the email.

To make the VBA code more efficient, we can also automate forwarding emails based on certain conditions, such as subject or sender.

For instance, if we want to forward all emails with a specific keyword in their subject to a designated recipient, we can use the following code:

Sub ForwardEmailBasedOnSubject()
  Dim Inbox As Outlook.MAPIFolder
  Dim Email As Outlook.MailItem
  Dim Keyword As String

  Keyword = "Important"

  Set Inbox = Application.GetNamespace("MAPI").GetDefaultFolder(olFolderInbox)

  For Each Email In Inbox.Items
    If InStr(1, Email.Subject, Keyword, vbTextCompare) > 0 Then
      Dim ForwardedEmail As MailItem
      Set ForwardedEmail = Email.Forward

      ForwardedEmail.Recipients.Add "email@example.com"
    End If
  Next Email
End Sub

In this example, we searched the inbox for emails containing a specific keyword in the subject and then forwarded those emails to the designated recipient.

In conclusion, VBA enables us to efficiently manage and forward emails in Microsoft Outlook based on our needs and requirements.

By using the MailItem object and its associated methods, we can create custom solutions to handle email forwarding and improve our overall productivity.

Working with Recipients

In this section, we will discuss how to work with recipients when using Outlook VBA code to forward emails.

We will specifically focus on adding and modifying recipients in the email.

Adding and Modifying Recipients

When forwarding an email using VBA, we usually need to specify the recipients to whom the email should be forwarded.

To add recipients, we can use the Recipients.Add method. The Recipients the collection represents all the recipients, including “To”, “CC”, and “BCC” fields, of an MailItem object. Here’s an example of how to add a recipient to a forwarded email:

Sub ForwardEmail(Item As Outlook.MailItem)
    If TypeName(Item) = "MailItem" Then
        With Item.Forward
            .Recipients.Add "email@example.com"
            .Subject = "Forwarded Email - " & Item.Subject
        End With
    End If
End Sub

To modify recipients in the email, we can loop through the Recipients collection and perform operations like removing a recipient or modifying their properties.

For instance, if we want to add recipients in the “CC” field, we can use the Type property of a Recipient object and set it to olCC:

Sub ForwardEmailCC(Item As Outlook.MailItem)
    If TypeName(Item) = "MailItem" Then
        With Item.Forward
            .Recipients.Add "email@example.com"
            Dim newRecipient As Outlook.Recipient
            Set newRecipient = .Recipients.Add("email.cc@example.com")
            newRecipient.Type = olCC
            .Subject = "Forwarded Email - " & Item.Subject
        End With
    End If
End Sub

When working with recipients, we should also be aware of resolving their names against the address book.

We can use the Recipient.Resolve method to ensure that recipient addresses are valid before sending the forwarded email.

This can help prevent errors due to mistyped email addresses or incorrect formatting:

Sub ForwardAndResolveEmail(Item As Outlook.MailItem)
    If TypeName(Item) = "MailItem" Then
        With Item.Forward
            Dim newRecipient As Outlook.Recipient
            Set newRecipient = .Recipients.Add("email@example.com")
            If Not newRecipient.Resolve Then
                MsgBox "Unable to resolve recipient: " & newRecipient.Name
                .Subject = "Forwarded Email - " & Item.Subject
            End If
        End With
    End If
End Sub

By following these approaches, we can easily manage recipients while forwarding emails using the Outlook VBA code.

Manipulating Email Content

When working with Outlook VBA code to forward an email, it’s essential to know how to manipulate various aspects of the email content, including the subject, body, and attachments.

In this section, we will discuss how to modify these components using VBA code.

Modifying the Subject

To alter the subject of an email when forwarding, we can use the Subject property of the MailItem object.

For instance, we might want to add a prefix to the original subject to indicate that the email has been forwarded:

Dim fwdMail As MailItem
Set fwdMail = originalMail.Forward
fwdMail.Subject = "FW: " & originalMail.Subject

This code snippet forwards the originalMail and changes the subject by appending “FW:” at the beginning.

Altering the Body

In the body of the forwarded email, we can either retain the original content or modify it as desired.

The Body and HTMLBody properties of the MailItem object allow us to manipulate the plain text and HTML content, respectively.

To retain the original body while adding additional text, we can concatenate strings:

fwdMail.Body = "Additional text before the original content: " & vbCrLf & originalMail.Body

If the email body contains HTML content, we should use the HTMLBody property instead:

fwdMail.HTMLBody = "<p>Additional text before the original content:</p>" & originalMail.HTMLBody


Handling attachments when forwarding emails can be achieved through the Attachments property of the MailItem object, which allows us to add, remove, or modify the attachments.

To keep all original attachments when forwarding, we can use the following code:

Dim originalAttachment As Attachment
For Each originalAttachment In originalMail.Attachments
    fwdMail.Attachments.Add originalAttachment
Next originalAttachment

When working with email content, we should also be aware of the Importance property.

The olImportanceHigh enumeration value can be assigned to the Importance property to mark an email as high priority:

fwdMail.Importance = olImportanceHigh

By applying these techniques with the proper VBA code, we can confidently and accurately manipulate email content when forwarding messages using Outlook.

Applying Rules and Filters

In order to manage and organize our emails efficiently, we can utilize Outlook VBA code to forward emails by applying rules and filters.

This approach allows us to target specific emails based on certain criteria and take appropriate actions, such as forwarding them to a designated address.

To start, we can create a rule that interacts with our inbox by defining objInbox and objInboxItems, which represent our inbox folder and the collection of items within it, respectively.

By iterating through objInboxItems, we can inspect each email and determine if it meets our desired criteria.

For example, we might only want to forward emails that are marked as unread. In this case, we would check the Unread property of each email.

Next, we can incorporate a filter in our rule using a VBA script. This helps us narrow down the targeted emails even further based on details such as the subject or sender.

Using RegExp objects or string manipulation, we can extract and analyze specific information from each email to determine if it matches our filter.

Once we have identified the emails that meet our rule and filter criteria, the VBA code can be set up to automatically forward them.

This is done using the .Forward method, which creates a new, separate email item with the original content.

After modifying the forwarded email as needed (e.g., changing the subject or adding a note), we can use the .Send method to forward the message to the desired recipient.

Here’s a concise example that illustrates the use of these entities:

Dim objInbox As Outlook.MAPIFolder
Dim objInboxItems As Outlook.Items
Dim mail As Outlook.MailItem

Set objInbox = Application.GetNamespace("MAPI").GetDefaultFolder(olFolderInbox)
Set objInboxItems = objInbox.Items

For Each mail In objInboxItems
    If mail.Unread And mail.Subject = "Important Update" Then
        Dim forwardMail As Outlook.MailItem
        Set forwardMail = mail.Forward
        forwardMail.Subject = "Forwarded: Important Update"
        forwardMail.Recipients.Add "example@example.com"
    End If
Next mail

In this example, we first set up objInbox and objInboxItems, then iterate through each mail item to check if it’s unread and has the subject “Important Update”.

If both conditions are met, we create a new forwarded email, update the subject, add a recipient, and send the email.

By applying rules and filters using Outlook VBA code, we can automate the process of forwarding specific emails, making our inbox management more efficient and effortless.

Triggering and Automating Macros

When working with Outlook VBA to forward emails, we can create and set up macros to automatically trigger and execute certain tasks whenever specific events occur.

Let’s discuss how to do this in a clear and simple manner.

First, we need to create a macro that defines the basic functionality of forwarding an email.

While the macro may vary depending on the requirements, we can refer to this VBA Outlook example as a starting point for creating the forward email function.

Add or modify the code and test it to ensure it works as expected.

Once our macro is ready, we need to think about the triggering conditions. One way to trigger the macro is to monitor an Outlook folder, such as the Inbox, for the arrival of new emails.

For instance, the following sample code demonstrates how to set up event triggers that listen for new items added to the Inbox.

By adding an event listener in the Application_Startup method, our macro will automatically trigger when a new email arrives.

Another method for automating our macro is to import a file that contains specific instructions for when to execute the macro.

We can design the file format to include relevant information, such as email senders, recipients, subject lines, or forwarding conditions.

After importing the file, our macro will read and process the instructions, setting up custom triggers based on the file data.

This approach provides more flexibility and customization options for determining when to forward emails.

In any case, it’s crucial to take into consideration security measures while implementing macros in Outlook, as they can potentially access sensitive data like email content, attachments, or account credentials.

As such, we recommend following best practices for VBA coding and regularly reviewing and updating the macro as needed to ensure it remains secure and reliable.

With the right Outlook VBA code in place, we’ll be well-equipped to automate email forwarding based on specific events or conditions, streamlining our daily tasks and improving productivity.

Error Handling and Notifications

When working with Outlook VBA code to forward emails, it’s essential to implement error handling and notifications for a smooth user experience.

In this section, we’ll discuss some crucial aspects to consider, such as notice, resolveall, and recipients.resolveall.

To ensure proper error handling, we can use On Error statements in conjunction with appropriate error handling procedures.

This approach allows us to handle any errors that might arise during the execution of our code. For instance:

On Error GoTo ErrorHandler
'...code to forward email...
Exit Sub
'...code to handle the error...

An essential part of error handling is providing clear notifications to the user. To achieve this, we can use Outlook’s built-in MsgBox function.

The function displays a message box with customized text and buttons, making it easy to inform users about errors or required actions. For example:

'...error handling code...
MsgBox "An error occurred while forwarding the email. Please check the recipient's email address and try again.", vbExclamation, "Error"

Another critical aspect of an efficient fowarding process is ensuring the recipients of the forwarded email are resolved correctly.

The Recipients.ResolveAll method can help us in this regard, as it attempts to resolve all Recipients objects in a MailItem against the Address Book.

This step ensures the email addresses are valid and can receive the forwarded message.

Here’s an example of using Recipients.ResolveAll to check if the recipients are correctly resolved before sending the forwarded email:

Dim olRecipients As Outlook.Recipients
Set olRecipients = myForward.Recipients
If olRecipients.ResolveAll Then
    '...code to forward email...
    MsgBox "One or more recipients could not be resolved. Please check the email addresses and try again.", vbExclamation, "Error"
End If

By adhering to the practices mentioned above, we can create a robust and user-friendly VBA code for forwarding emails in Outlook.

Incorporating error handling and notifications plays a vital role in building a smooth user experience and ensuring email forwarding works efficiently and accurately.

Additional VBA Functions

In this section, we will briefly discuss a few additional VBA functions that can be helpful when working with Outlook to forward emails.

These functions include GetDefaultFolder, olFolderInbox, objForward, Len, and Left.

GetDefaultFolder is a useful function to access the default folder in Outlook, such as the Inbox or Sent Items.

It allows us to easily retrieve emails from these folders to perform various operations, like forwarding emails. To use GetDefaultFolder, call it on an Outlook Namespace object. For example:

Set objNamespace = Application.GetNamespace("MAPI")
Set objInbox = objNamespace.GetDefaultFolder(olFolderInbox)

olFolderInbox is an enumeration constant representing the Inbox folder in Outlook.

It is often used along with GetDefaultFolder function to get access to the inbox folder for processing mail items.

As shown in the previous example, GetDefaultFolder takes olFolderInbox as its argument to access the inbox folder.

Using the objForward function on a MailItem object is an essential part of forwarding emails in Outlook VBA.

This function creates a new MailItem object that is a forward of the original email. Here’s an example of how to create a forward message from a mail item:

Set objMsg = objInbox.Items(1) ' Assuming we want to forward the first mail item in the inbox
Set objForward = objMsg.Forward

The Len function is a built-in VBA function that returns the length of a given string.

This can be useful when working with subject lines of emails or any string manipulation.

For instance, if we want to check if a subject is longer than 10 characters, we can use:

subjectLength = Len(objMsg.Subject)
If subjectLength > 10 Then
  ' Perform actions on subject
End If

Finally, the Left function in VBA allows us to extract a specific number of characters from the left side of a string.

This can be handy when checking for specific prefixes in subject lines.

For example, to check if an email subject starts with a particular string, such as “Report:”, we can use:

subjectPrefix = Left(objMsg.Subject, 7)
If subjectPrefix = "Report:" Then
  ' Perform actions on emails with the desired subject prefix
End If

By using these VBA functions, we can create powerful and efficient Outlook VBA code to forward emails, filter messages based on certain conditions, and perform various email-related tasks.

We encourage you to explore these functions further and incorporate them into your projects as needed.

Customizing the Email Forwarding Process

When working with Outlook and VBA, we can customize the email forwarding process by integrating Visual Basic for Applications (VBA) code into Outlook.

This allows us to create a more efficient and personalized forwarding experience for our emails.

In this section, we will discuss some aspects of automated email forwarding using VBA code.

First, we need to focus on the sender and the recipient. In order to forward an email using VBA, we should identify the sender’s email address and the new recipient’s email address.

We can do this using Outlook’s MailItem object, which will help us process the email message for forwarding.

We can also utilize the MailItem’s Inspector to display the email in a new window, allowing us to review its content and make any necessary changes before forwarding.

Another aspect we can customize is the subject. By modifying the subject line, we can attach specific tags or prefixes to incoming messages.

This can be done using the MailItem’s Subjects property, allowing us to append or change the email’s original subject before forwarding it.

This can be particularly helpful in organizing our inbox or highlighting priority emails.

The message body is another element we can tailor to our needs. With VBA, we can add, modify, or delete content within the message body to fit the forwarding context.

For example, we can include a personalized message, incorporate additional details, or remove extra information that might not be relevant to the recipient.

To achieve this, we can use the MailItem’s Body or HTMLBody properties, depending on the email format.

It’s essential to consider the display format of the forwarded email. As we make changes to the message, we want to make sure the format remains clean and clear.

With VBA, we can work with different formats like plain text, HTML, and Rich Text Format (RTF) to cater to our preferences.

Lastly, to seamlessly forward the message, we need to instruct Outlook to send the new email using the Send method of the MailItem object.

We can even automate the process further by creating a macro that replies or forwards emails based on specific conditions, such as matching keywords, subjects, or sender addresses.

In conclusion, using VBA in Outlook, we can customize the email forwarding process by automating tasks and making necessary adjustments to the sender, subject, message body, format, and sending process.

This will enable us to create a more personalized and efficient email forwarding experience on our desktops.


In this article, we discussed the use of Outlook VBA code for forwarding emails. We explored some popular resources covering this topic, which can help address specific scenarios and requirements.

Using VBA in Outlook for forwarding emails can streamline and automate certain processes.

For instance, this may involve forwarding specific emails based on certain criteria or including additional information from other sources, such as Excel spreadsheets.

One useful method in Outlook VBA to forward an email is the MailItem.Forward method, which returns a copy of the email being forwarded as a MailItem object.

People interested in learning more can find numerous examples and guidance from sources such as StackOverflow and SuperUser.

As we delved deeper into this topic, it became clear that there are countless ways to customize and tailor VBA code for forwarding emails in Outlook to meet specific needs.

We hope that this information provides a solid foundation for anyone looking to explore VBA code for forwarding emails in Outlook.

By utilizing this knowledge and the resources shared, opportunities for increased efficiency and productivity in email management may arise.

Lastly, we remind our readers that whenever employing VBA code, it is crucial to ensure that code is reliable, secure, and properly tested.

By following careful practices, users can harness the power of VBA in Outlook to forward emails effectively and confidently.

Frequently Asked Questions (FAQs)

Q1: What is Outlook VBA?

A1: VBA (Visual Basic for Applications) is a programming language used in Microsoft Office applications to automate routine tasks.

In Outlook, you can use VBA to create custom scripts for tasks such as automatically forwarding emails, managing attachments, and organizing your inbox.

Q2: How can I automatically forward emails in Outlook using VBA?

A2: You can use the Application_NewMail event in VBA to trigger a script whenever a new email arrives in your inbox. This script can check the email’s sender or subject, for instance, and then forward the email to a specified address if it matches certain criteria.

Q3: Is it safe to use VBA to forward emails?

A3: VBA is generally safe to use, but it should be used responsibly. Be careful not to create infinite loops with your forwarding rules, and make sure you don’t inadvertently forward sensitive information to the wrong recipients.

Always test your scripts thoroughly before deploying them.

Q4: Can I use VBA to forward emails to multiple recipients?

A4: Yes, you can add multiple recipients in the VBA code by using the Recipients.Add method for each recipient.

Q5: Can I use VBA to forward emails with attachments?

A5: Yes, when an email is forwarded using VBA, all its contents, including attachments, are included in the forwarded message by default.

Q6: Do I need to have programming skills to use VBA in Outlook?

A6: Basic understanding of programming concepts can be beneficial when working with VBA.

However, there are many resources and code snippets available online, which you can use and adapt to your needs even without deep programming knowledge.

Always ensure you understand what the code does before implementing it.

Related Articles

Amit Bansal

Hello, my name is Amit Kumar Bansal, and I am the founder of MailSmartly.com. Through this blog, I focus on Microsoft Outlook, offering insightful and informative content. Additionally, I produce educational videos on YouTube to further enhance the understanding of my audience. visit my YouTube Channel

View all posts

Leave a Comment