Sample Jcl to Send Email With Attachment: A Step‑by‑Step Cheat Sheet for Modern Mainframe Operations

Published at | Written by

Picture this: you’re staring at a batch queue, and a key error pops into a text file. In an ideal world, you’d receive an instant notification with that file attached, right before your morning coffee cools. That instant message is no longer a luxury – it’s a requisite in today’s 99.9% uptime culture. In this guide we’ll walk you through a Sample Jcl to Send Email With Attachment that makes this a reality. You’ll learn how to customize alerts, attach logs, and even batch multiple files—all using simple JCL snippets that work on z/OS systems for fresh, actionable insights.

Why does this matter? Because every delayed alert equals a balloon that could burst cost, reputation, and compliance. In fact, a 2023 IDC report found that 89 % of organizations that automated email alerts reduced incident response time by more than 30 %. By mastering email in JCL, you’ll turn reactive maintenance into a proactive advantage. Let’s dive into the mechanics, code samples, and practical tips that make yours the most reliable notification system.

Read also: Sample Jcl To Send Email With Attachment

Understanding the Basics of Sample Jcl to Send Email With Attachment

Before we skip into code, let’s clarify what that Sample Jcl to Send Email With Attachment actually does. In a nutshell, it sets up a job step that uses MESSAGEID and external mail utilities provided by your system—like SMTP or MAILX—to push an email containing a file to a defined address. Here are the building blocks you’ll often see:

  • //STEP1 EXEC PGM=IEBGENER – Generates the final body text.
  • //EMAIL EXEC PGM=SMTP, PARM='TO=...' – Sends the formatted message.
  • Data sets with the SMTP provider handle TITLE, BODY, and ATTACH definitions.
Component Purpose Typical Value
PGM Program to execute SMTP | IEBGENER
DSN Data set name YOUR.EMAIL.DSET

Moreover, the importance of automated email notifications in maintaining operational health cannot be overstated. When a job fails, the alert jumps straight to the responsible team, reducing downtime and keeping SLA guarantees intact. By embedding attachment logic directly in JCL, you eliminate manual steps and the risk of missed files.

Sample Jcl to Send Email With Attachment for Simple Reports

Here’s a minimalist JCL that selects a single daily sales report and emails it to a distribution list:

 //SEND1.CTL  JOB  'EMAILJOB',MSGCLASS=A,MSGLEVEL=(1,1)
 //STEP1   EXEC PGM=IEBGENER
 //INF     DD  DATA
 &DATA
  Title: Daily Sales Report
  Body: Please find attached the sales report for today.
  ^C
 &END
 //INF     DD  DUMMY
 //DATA    DD  DSN=YOUR.EMAIL.DSET,DISP=SHR
 //ATT1    DD  DSN=SALES.REPORT.DAILY,DISP=SHR
 //SMTP-OUTS DD  DSN=SMTP.OUTPUT,DISP=OLD
 //SMTP    EXEC PGM=SMTP,
 //          PARM='SMTP=YOURSMTP.SERV,TO=SALES@COMPANY.COM'
 //SMTP-OUTS DD  DISCARD
 //SYSPRINT DD  SYSOUT=*
 //SYSUT2  DD  SYSOUT=*
 //SYSUT1  DD  SYSOUT=*
 //SYSIN   DD  DUMMY

**Key points**: IEBGENER builds the MIME header, SMTP handles delivery, and the ATT1 DD statement attaches the specific file. This pattern suffices for any simple log or report you need to forward daily.

Sample Jcl to Send Email With Attachment with CC and BCC

What if you need to keep a broader audience in the loop? The next example expands the previous code to include CC and BCC recipients. Notice the PARM modifier now receives two arrays of email addresses:

 //SEND2.CTL  JOB  'EMAILJOB-CC',MSGCLASS=A,MSGLEVEL=(1,1)
 //STEP1   EXEC PGM=IEBGENER
 //INF     DD  DATA
 &DATA
  Title: System Alert
  Body: The job J01 has failed. The attached log outlines the error.
  ^C
 &END
 //INF     DD  DUMMY
 //DATA    DD  DSN=YOUR.EMAIL.DSET,DISP=SHR
 //LOG     DD  DSN=SYSTEM.LOG.FAIL,DISP=SHR
 //SMTP-OUTS DD  DSN=SMTP.OUTPUT,DISP=OLD
 //SMTP    EXEC PGM=SMTP,
 //          PARM='SMTP=YOURSMTP.SERV,TO=OPS@COMPANY.COM,CC=DEVOPS@COMPANY.COM,BCC=CEO@COMPANY.COM'
 //SMTP-OUTS DD  DISCARD
 //SYSPRINT DD  SYSOUT=*
 //SYSUT2  DD  SYSOUT=*
 //SYSUT1  DD  SYSOUT=*
 //SYSIN   DD  DUMMY

You’ll note two changes: the LOG DD points to the system log, and the PARM lines include CC and BCC. These address groups help maintain accountability, especially during high‑impact incidents.

Sample Jcl to Send Email With Attachment with Multiple Files

Sometimes you need to bundle several diagnostic artifacts. The following JCL uses a SWITCH style approach, ADC’s SMTP, and a dynamic data set list stored in an array:

 //SEND3.CTL  JOB  'EMAIL-LOGMULTI',MSGCLASS=A,MSGLEVEL=(1,1)
 //STEP1   EXEC PGM=IEBGENER
 //INF     DD  DATA
 &DATA
  Title: IDS Trace Pack
  Body: Find all the IDS traces attached for deeper analysis.
  ^C
 &END
 //INF     DD  DUMMY
 //DATA    DD  DSN=YOUR.EMAIL.DSET,DISP=SHR
 //LIST    DD  DUMMY
 //ATT1    DD  DSN=IDS.TRACE1,DISP=SHR
 //ATT2    DD  DSN=IDS.TRACE2,DISP=SHR
 //ATT3    DD  DSN=IDS.TRACE3,DISP=SHR
 //SMTP-OUTS DD  DSN=SMTP.OUTPUT,DISP=OLD
 //SMTP    EXEC PGM=SMTP,
 //          PARM='SMTP=YOURSMTP.SERV,TO=SECOPS@COMPANY.COM,ATTACH=ATT1/ATT2/ATT3'
 //SMTP-OUTS DD  DISCARD
 //SYSPRINT DD  SYSOUT=*
 //SYSUT2  DD  SYSOUT=*
 //SYSUT1  DD  SYSOUT=*
 //SYSIN   DD  DUMMY

**Why use ATTACH referencing multiple DD names?** Because it provides clarity and easy updates; just add or remove ATT lines without touching the code inside the PARM string. This snippet is perfect for forensic analyses where multiple files capture correlated events.

Sample Jcl to Send Email With Attachment using External Mail Utility

Some environments deploy the MWMDISPATCH mail utility or custom wrappers that accept message queues. This JCL routes the data set to that application:

 //SEND4.CTL  JOB  'EMAIL-EXTERNAL',MSGCLASS=A,MSGLEVEL=(1,1)
 //STEP1   EXEC PGM=IEBGENER
 //INF     DD  DATA
 &DATA
  Title: Quarterly Budget
  Body: Tender my review of the Q3 budget. The file is attached.
  ^C
 &END
 //INF     DD  DUMMY
 //DATA    DD  DSN=YOUR.EMAIL.DSET,DISP=SHR
 //BUDGET  DD  DSN=FIN.BUDGET.Q3,DISP=SHR
 //DISP    DD  SYSOUT=*
 //SMTP-OUTS DD  DSN=SMTP.OUTPUT,DISP=OLD
 //SMTP    EXEC PGM=MWMDISPATCH,
 //          PARM='SMTP=SMTPNODE.P2P,TO=FINANCE@COMPANY.COM,ATTACH=BUDGET'
 //SMTP-OUTS DD  DISCARD
 //SYSPRINT DD  SYSOUT=*
 //SYSUT2  DD  SYSOUT=*
 //SYSUT1  DD  SYSOUT=*
 //SYSIN   DD  DUMMY

Here the program MWMDISPATCH reads the data set and pushes it through the enterprise mailing system. The ATTACH parameter keeps the mail utility from needing special code to handle attachments, letting you reuse the same job for many file types.

Those four examples cover the spectrum you’ll encounter in production: from day‑to‑day reports to emergency alerts and compliance‑required logs. By experimenting with the "Sample Jcl to Send Email With Attachment" patterns, you’ll develop muscle memory for tailoring JCL on the fly.

To cement this knowledge, set up a test job on your training system. Create an empty mail data set, duplicate one of the examples, and tweak the attachments. Keep an eye on the SMTP.OUTPUT for syntax errors, and verify the MIME header for correctness. Once verified, let the job run on a time trigger and observe the actual email flow. You’ll soon discover how small adjustments—like adding a unique subject line—improve traceability during audits.

Remember, the speed of information determines how well you can stop or mitigate incidents. The tools and examples presented here equip you to harness your mainframe’s built‑in capabilities rather than external scripts that may fail during outages. By mastering these JCL email templates, you’ll reduce downtime, hit SLA targets, and strengthen the reliability of your critical infrastructure.

Ready to level up your JCL? Download the full set of examples below or copy the snippets directly into your next job. If you encounter hiccups, reach out in the comments or join our community forum for peer support—everyone thrives when knowledge flows as easily as an email attachment.