nodemailer

constructor

constructor(
    transporter: Transport<T>,
    options?: TransportOptions,
    defaults?: SendMailOptions
);

property close

close: () => void;

• Closes the transport, the pooled SMTP transport closes its connections

property dkim

dkim: false | DKIM;

property getSocket

getSocket?: false | GetSocketHandler;

• Socket handler for a proxied connection, set by setupProxy and handed to the transport on the next send

property isIdle

isIdle: () => boolean;

• Tells whether the transport can take a message right away

property logger

logger: shared.Logger;

property meta

meta: Map<string, any>;

property options

options: TransportOptions;

property transporter

transporter: Transport<T>;

property verify

verify: { (callback: VerifyCallback): void; (): Promise<true> };

• Checks the configuration, the SMTP transports connect and authenticate for it

method get

get: <K extends string>(key: K) => MailMeta[K] | undefined;

method getVersionString

getVersionString: () => string;

method sendMail

sendMail: {
    (data: SendMailOptions): Promise<T>;
    (data: SendMailOptions, callback: SendMailCallback<T>): void;
};

• Sends an email using the preselected transport object

  Parameter data

  E-data description

  Parameter callback

  Callback to run once the sending succeeded or failed

method set

set: <K extends string>(key: K, value: MailMeta[K]) => Map<string, any>;

method setupProxy

setupProxy: (proxyUrl: string) => void;

• Sets up proxy handler for a Nodemailer object

  Parameter proxyUrl

  Proxy configuration url

method use

use: (step: string, plugin: PluginFunction<T>) => this;

constructor

constructor(mailer: Mail<T>, data?: SendMailOptions);

property data

data: MailMessageData;

property mailer

mailer: Mail<T>;

property message

message: MimeNode;

method normalize

normalize: (callback: MailMessageDataCallback) => void;

method resolveAll

resolveAll: (callback: MailMessageDataCallback) => void;

method resolveContent

resolveContent: {
    (
        data: { [key: string]: any },
        key: string | number,
        callback: MailMessageContentCallback
    ): void;
    (
        data: { [key: string]: any },
        key: string | number,
        options: false | ResolveContentOptions,
        callback: MailMessageContentCallback
    ): void;
    (
        data: { [key: string]: any },
        key: string | number,
        options?: false | ResolveContentOptions
    ): Promise<any>;
};

method setListHeaders

setListHeaders: () => void;

method setMailerHeader

setMailerHeader: () => void;

method setPriorityHeaders

setPriorityHeaders: () => void;

property address

address?: string | undefined;

property group

group?: MimeNodeAddress[] | undefined;

property name

name?: string | undefined;

property cid

cid?: string | undefined;

• Content-Id for an embedded image, moves the attachment into the multipart/related node beside the html

property contentDisposition

contentDisposition?: string | undefined;

• Content-Disposition for the node, 'attachment' by default and 'inline' for a message node or an image with a cid

property content

content?: MimeNodeContent | undefined;

• The content itself: a string, a Buffer, a readable stream or a content descriptor

property contentTransferEncoding

contentTransferEncoding?: string | false | undefined;

• Content-Transfer-Encoding for the node, false leaves the choice to the node

property contentType

contentType?: string | undefined;

• Content type, detected from the filename, path or URL when not set

property encoding

encoding?: string | undefined;

• Encoding of a string content, decoded into a Buffer unless it is utf8 or ascii

property filename

filename?: string | false | undefined;

• Filename for the node, false suppresses the generated one

property headers

headers?: MimeNodeHeaders | undefined;

• Additional headers for the node

property href

href?: string | false | undefined;

• URL or data URI to fetch the content from

property httpHeaders

httpHeaders?: OutgoingHttpHeaders | undefined;

• Request headers for a URL fetch

property path

path?: string | false | undefined;

• File path, data URI or http(s) URL to read the content from

property raw

raw?: MimeNodeContent | undefined;

• Pregenerated MIME part, used as is instead of building the node

property tls

tls?:
    | {
          [key: string]: any;
      }
    | undefined;

• TLS settings for a URL fetch, see nmfetch

property cacheDir

cacheDir?: string | false | undefined;

• Directory for buffering large message bodies to disk, no buffering when not set

property cacheTreshold

cacheTreshold?: number | undefined;

• Body size in bytes from which the body is buffered to cacheDir, defaults to 10 MB

property hashAlgo

hashAlgo?: string | undefined;

• Hash algorithm for the body hash and the signature, defaults to sha256

property keys

keys?: DKIMKey | DKIMKey[] | undefined;

• One or more signing keys, used instead of the domainName, keySelector and privateKey options

property method

method?: string | undefined;

• iCalendar method, PUBLISH by default

property envelope

envelope: MimeNodeEnvelope;

• The envelope the message was generated with

property message

message: string | MailMessageData;

• The normalized message as a JSON string, or as the object itself when skipEncoding is set

property messageId

messageId: string;

• Message-ID value of the message

property jsonTransport

jsonTransport?: boolean | undefined;

• Selects this transport in createTransport

property skipEncoding

skipEncoding?: boolean | undefined;

• If true, the message is returned as an object instead of a JSON string

index signature

[key: string]:
    | MailComposerListHeaderEntry
    | (MailComposerListHeaderEntry | MailComposerListHeaderEntry[])[];

property alternatives

alternatives?: MailComposerAlternative[] | undefined;

• Further alternatives for the multipart/alternative node, after text, watchHtml, amp, html and the calendar event

property amp

amp?: string | Buffer | Readable | MailComposerAlternative | undefined;

• AMP4EMAIL version of the message

property attachDataUrls

attachDataUrls?: boolean | undefined;

• Convert data: images in the html into embedded attachments, read by the mailer

property attachments

attachments?: MailComposerAttachment[] | undefined;

property baseBoundary

baseBoundary?: string | undefined;

• Shared part of the unique multipart boundary

property bcc

bcc?: MimeNodeAddressInput | undefined;

property boundaryPrefix

boundaryPrefix?: string | undefined;

• Prefix for the generated multipart boundaries

property cc

cc?: MimeNodeAddressInput | undefined;

property date

date?: Date | string | undefined;

• Date header value, the current time when missing

property disableFileAccess

disableFileAccess?: boolean | undefined;

• Reject content that points to a file path

property disableUrlAccess

disableUrlAccess?: boolean | undefined;

• Reject content that points to a URL

property encoding

encoding?: string | undefined;

• Content-Transfer-Encoding to force for the text/* nodes that do not set their own

property envelope

envelope?: MimeNodeEnvelopeInput | undefined;

• SMTP envelope to use instead of the one generated from the headers

property from

from?: MimeNodeAddressInput | undefined;

property headers

headers?: MimeNodeHeaders | undefined;

• Custom headers for the root node, the standard headers above override them

property html

html?: string | Buffer | Readable | MailComposerAlternative | undefined;

• HTML version of the message

property icalEvent

icalEvent?: string | Buffer | Readable | MailComposerIcalEvent | undefined;

• iCalendar event, included both as a text/calendar alternative and as an application/ics attachment

property inReplyTo

inReplyTo?: string | undefined;

property keepBcc

keepBcc?: boolean | undefined;

• Keep the Bcc header in the generated message, listed for completeness, the transports set it on the message directly

property list

list?: MailComposerListHeaders | undefined;

• List-* headers, read by the mailer

property messageId

messageId?: string | undefined;

• Message-ID header value, generated when missing

property newline

newline?: string | undefined;

• 'win' for CRLF and 'linux' for LF line breaks in the generated message, kept as is when not set

property normalizeHeaderKey

normalizeHeaderKey?: MimeNodeOptions['normalizeHeaderKey'] | undefined;

• Method to normalize header keys for custom caseing

property priority

priority?: string | undefined;

• 'high', 'normal' or 'low', sets the priority headers, read by the mailer

property raw

raw?: MimeNodeContent | undefined;

• Pregenerated rfc822 message, used as is instead of building one

property references

references?: string | string[] | undefined;

property replyTo

replyTo?: MimeNodeAddressInput | undefined;

property sender

sender?: MimeNodeAddressInput | undefined;

property subject

subject?: string | undefined;

property text

text?: string | Buffer | Readable | MailComposerAlternative | undefined;

• Plaintext version of the message

property textEncoding

textEncoding?: string | undefined;

• Header string encoding, 'Q' (the default) or 'B', 'quoted-printable' and 'base64' are accepted as well

property to

to?: MimeNodeAddressInput | undefined;

property watchHtml

watchHtml?: string | Buffer | Readable | MailComposerAlternative | undefined;

• Apple Watch specific HTML version of the message

property xMailer

xMailer?: string | false | undefined;

• X-Mailer header value, false leaves the header out, read by the mailer

property normalizedHeaders

normalizedHeaders?:
    | {
          [key: string]: string;
      }
    | undefined;

• Header values flattened to strings and keyed by lowercase header name, set by normalize

property code

code?: string | undefined;

• Nodemailer error code, see ERROR_CODES

property command

command?: string | undefined;

• SMTP command that was in flight when the server replied with an error

property recipient

recipient?: string | undefined;

• Recipient address the error applies to

property rejected

rejected?: string[] | undefined;

• Recipient addresses rejected by the server

property rejectedErrors

rejectedErrors?: NodemailerError[] | undefined;

• Per-recipient errors for the rejected addresses

property response

response?: string | undefined;

• Raw SMTP server response

property responseCode

responseCode?: number | undefined;

• Numeric SMTP response code

property sourceUrl

sourceUrl?: string | undefined;

• URL of the resource that could not be fetched

property auth

auth?: SMTPTransportAuthOptions | undefined;

• SMTP transports: per-message authentication settings, used instead of the transport level auth

property dkim

dkim?: DKIMOptions | undefined;

• DKIM signing options for this message, used instead of the ones of the transporter

property dsn

dsn?: SMTPEnvelopeDsn | undefined;

• SMTP transports: DSN parameters for the envelope, sent when the server supports the DSN extension

property maxRecipients

maxRecipients?: number | undefined;

• Recipients allowed on this message, 0 disables the limit, defaults to 100000

property requireTLSExtensionEnabled

requireTLSExtensionEnabled?: boolean | undefined;

• SMTP transports: RFC 8689, send the REQUIRETLS parameter with MAIL FROM

property ses

ses?:
    | {
          [key: string]: unknown;
      }
    | undefined;

• SES transport: extra SendEmailCommand parameters merged into the API call

property envelope

envelope: MimeNodeEnvelope;

• The envelope the message was sent with

property messageId

messageId: string;

• Message-ID value of the message

property response

response: string;

• Always 'Messages queued for delivery'

property args

args?: string[] | undefined;

• Arguments for the sendmail binary, replaces the default '-f '

property newline

newline?: string | undefined;

• Either 'windows' or 'unix', the line ending of the message piped to sendmail

property path

path?: string | undefined;

• Path to the sendmail binary, defaults to 'sendmail'

property sendmail

sendmail?: boolean | string | undefined;

• Selects this transport in createTransport, the binary itself is set with path

property accepted

accepted?: string[] | undefined;

• Recipient addresses the transport accepted

property envelope

envelope: MimeNodeEnvelope;

• The envelope the message was sent with

property message

message?: unknown;

• The generated message, for the transports that hand it back instead of sending it

property messageId

messageId: string;

• Message-ID of the sent message

property pending

pending?: string[] | undefined;

• Recipient addresses left pending, LMTP reports these

property rejected

rejected?: string[] | undefined;

• Recipient addresses the transport rejected

property response

response?: string | undefined;

• Last response from the server

index signature

[key: string]: unknown;

• Transport specific fields

property envelope

envelope: MimeNodeEnvelope;

• The envelope the message was sent with

property messageId

messageId: string;

• Message-ID built from the MessageId SES returned

property raw

raw: Buffer;

• The raw RFC822 message that was sent

property response

response: string;

• The MessageId SES returned

property SES

SES: {
    /** SESv2Client instance. Its config.region provider is resolved for the domain of the returned Message-ID */
    sesClient: {
        config?:
            | {
                  region?: (() => Promise<string>) | undefined;
                  [key: string]: any;
              }
            | undefined;
        send(command: unknown): Promise<any>;
    };
    /** SendEmailCommand class, constructed with the SendEmailCommandInput of every message */
    SendEmailCommand: new (input: any) => unknown;
};

• The AWS SDK v3 objects to send with, { sesClient, SendEmailCommand } from @aws-sdk/client-sesv2

property credentials

credentials?: SMTPConnectionCredentials | undefined;

• Credentials for the SASL mechanism, filled in from user and pass when missing

property method

method?: string | false | undefined;

• SASL method to use, false or unset picks the first supported one (PLAIN if none is advertised)

property oauth2

oauth2?: XOAuth2 | undefined;

• XOAuth2 token generator, selects XOAUTH2 when no method is set

property options

options?:
    | {
          [key: string]: any;
      }
    | undefined;

• Extra options for the authentication method

property pass

pass?: string | undefined;

property type

type?: string | undefined;

• Authentication type, informational

property user

user?: string | undefined;

index signature

[key: string]: any;

• Custom authentication handlers receive the auth object as is, so it may carry any other value

property allowInternalNetworkInterfaces

allowInternalNetworkInterfaces?: boolean | undefined;

• Count loopback interfaces when checking which address families are usable

property component

component?: string | undefined;

• Logger component name, defaults to 'smtp-connection'

property connection

connection?: net.Socket | undefined;

• Already opened connection to use instead of creating a new one

property connectionTimeout

connectionTimeout?: number | undefined;

• Time to wait in ms for the connection to establish, defaults to 2 minutes

property customAuth

customAuth?: SMTPConnectionCustomAuthHandlers | undefined;

• Custom authentication handlers keyed by method name

property debug

debug?: boolean | undefined;

• Pass SMTP traffic, including the message data, to the logger

property dnsTimeout

dnsTimeout?: number | undefined;

• Time to wait in ms for the DNS requests to be resolved, defaults to 30 seconds

property greetingTimeout

greetingTimeout?: number | undefined;

• Time to wait in ms until the greeting is received, defaults to 30 seconds

property host

host?: string | undefined;

• Hostname or IP address to connect to, defaults to 'localhost'

property ignoreTLS

ignoreTLS?: boolean | undefined;

• Ignore STARTTLS even when the server advertises it

property lmtp

lmtp?: boolean | undefined;

• Use LMTP instead of SMTP

property localAddress

localAddress?: string | undefined;

• Outbound address to bind to

property logger

logger?: shared.ExternalLogger | boolean | undefined;

• Bunyan compatible logger interface, true for the default console logger

property name

name?: string | undefined;

• Name of the client server, sent with EHLO/HELO, CRLF is stripped

property opportunisticTLS

opportunisticTLS?: boolean | undefined;

• Continue unencrypted when the STARTTLS upgrade fails

property port

port?: number | string | undefined;

• Port to connect to, defaults to 587, or to 465 when secure is set

property requireTLS

requireTLS?: boolean | undefined;

• Force STARTTLS, fail when the server does not support it

property secure

secure?: boolean | undefined;

• Use TLS from the start

property secured

secured?: boolean | undefined;

• Marks the provided socket as already upgraded to TLS

property servername

servername?: string | undefined;

• Server name for SNI, defaults to host when that is not an IP address

property socket

socket?: net.Socket | undefined;

• Existing socket to use instead of creating a new one, not connected yet

property socketTimeout

socketTimeout?: number | undefined;

• Time of inactivity in ms until the connection is closed, defaults to 10 minutes

property tls

tls?: tls.ConnectionOptions | undefined;

• Options for tls.connect

property transactionLog

transactionLog?: boolean | undefined;

• Pass SMTP commands and responses to the logger

property dsn

dsn?: SMTPEnvelopeDsn | undefined;

• DSN parameters, sent when the server supports the DSN extension

property from

from?: string | SMTPEnvelopeAddress | undefined;

• Sender address

property requireTLSExtensionEnabled

requireTLSExtensionEnabled?: boolean | undefined;

• RFC 8689: send the REQUIRETLS parameter, requires a TLS connection and server support

property size

size?: number | string | undefined;

• Message size in bytes, sent as the SIZE parameter when the server supports it

property to

to?:
    | string
    | SMTPEnvelopeAddress
    | Array<string | SMTPEnvelopeAddress>
    | undefined;

• Recipient address or addresses

property use8BitMime

use8BitMime?: boolean | undefined;

• Declare BODY=8BITMIME when the server supports it

property envid

envid?: string | null | undefined;

• Envelope identifier, sent as ENVID

property id

id?: string | undefined;

• Alias of envid

property notify

notify?: string | string[] | null | undefined;

• When to notify: 'NEVER', or any combination of 'SUCCESS', 'FAILURE' and 'DELAY'

property orcpt

orcpt?: string | null | undefined;

• Alias of recipient, in the 'rfc822;address' form

property recipient

recipient?: string | undefined;

• Original recipient, sent as ORCPT

property ret

ret?: string | null | undefined;

• Return either 'HDRS' (headers) or 'FULL' (body) with the notification

property return

return?: string | undefined;

• Alias of ret

property maxConnections

maxConnections?: number | undefined;

• Maximum number of open connections, defaults to 5

property maxMessages

maxMessages?: number | undefined;

• Number of messages a connection sends before it is closed and replaced, defaults to 100

property maxRequeues

maxRequeues?: number | undefined;

• How many times a message is requeued when its connection closes while sending, unlimited when not set or negative

property pool

pool?: boolean | undefined;

• Set to true to get this pooled transport from createTransport

property rateDelta

rateDelta?: number | undefined;

• Time window for rateLimit in milliseconds, defaults to 1000

property rateLimit

rateLimit?: number | undefined;

• Maximum number of messages to send in rateDelta milliseconds, unlimited when not set

property accepted

accepted: string[];

• Recipients the server accepted

property envelope

envelope: MimeNodeEnvelope;

• Envelope the message was sent with

property messageId

messageId: string;

• Message-ID value of the sent message

property rejected

rejected: string[];

• Recipients the server rejected

property auth

auth?: SMTPTransportAuthOptions | undefined;

• Authentication settings, no authentication when not set

property authMethod

authMethod?: string | undefined;

• Default SASL method for the password logins when the auth settings do not name one

property component

component?: string | undefined;

• Logger component name, defaults to 'smtp-transport'

property forceAuth

forceAuth?: boolean | undefined;

• Authenticate even when the server does not advertise AUTH, and fail verify() when it does but no credentials were given

property getSocket

getSocket?: SMTPTransportGetSocket | undefined;

• Custom socket provider, e.g. for connecting through a proxy, replaces the getSocket method

property pool

pool?: boolean | undefined;

• Set to true to get a pooled transport from createTransport, this transport does not read it

property service

service?: string | undefined;

• Well-known service name, e.g. 'Gmail', fills in host, port and secure

property url

url?: string | undefined;

• Connection url, e.g. 'smtps://user:pass@smtp.example.com', parsed into options

property envelope

envelope: MimeNodeEnvelope;

• The envelope the message was generated with

property message

message: Readable | Buffer;

• The generated message, a Buffer when the buffer option is set, a readable stream otherwise

property messageId

messageId: string;

• Message-ID value of the message

property buffer

buffer?: boolean | undefined;

• If true, the message is returned as a Buffer object instead of a stream

property newline

newline?: string | undefined;

• Either 'windows' or 'unix', the line ending of the generated message

property streamTransport

streamTransport?: boolean | undefined;

• Selects this transport in createTransport

property imap

imap: TestAccountService;

property mxEnabled

mxEnabled?: boolean | undefined;

• true if the account can also receive external mail

property pass

pass: string;

property pop3

pop3: TestAccountService;

property smtp

smtp: TestAccountService;

property user

user: string;

property web

web: string;

index signature

[key: string]: unknown;

property host

host: string;

property port

port: number;

property secure

secure: boolean;

property getSocket

getSocket?: GetSocketHandler | undefined;

• Socket handler for a proxied connection, set by Mail when a proxy is configured

property mailer

mailer?: Mail<T> | undefined;

• The Mail object the transport belongs to, set by Mail

property name

name: string;

• Transport name, used for logging

property version