728x90

Description Description

A true return value does not automatically mean that the user received the email successfully. It just only means that the method used was able to process the request without any errors.

Using the two ‘wp_mail_from’ and ‘wp_mail_from_name’ hooks allow from creating a from address like ‘Name email@address.com‘ when both are set. If just ‘wp_mail_from’ is set, then just the email address will be used with no name.

The default content type is ‘text/plain’ which does not allow using HTML. However, you can set the content type of the email by using the ‘wp_mail_content_type’ filter.

The default charset is based on the charset used on the blog. The charset can be set using the ‘wp_mail_charset’ filter.


Parameters Parameters

$to

(string|array) (Required) Array or comma-separated list of email addresses to send message.

$subject

(string) (Required) Email subject

$message

(string) (Required) Message contents

$headers

(string|array) (Optional) Additional headers.

Default value: ''

$attachments

(string|array) (Optional) Files to attach.

Default value: array()


Top ↑

Return Return

(bool) Whether the email contents were sent successfully.


Top ↑

Source Source

File: wp-includes/pluggable.php

173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
function wp_mail( $to, $subject, $message, $headers = '', $attachments = array() ) {
    // Compact the input, apply the filters, and extract them back out
 
    /**
     * Filters the wp_mail() arguments.
     *
     * @since 2.2.0
     *
     * @param array $args A compacted array of wp_mail() arguments, including the "to" email,
     *                    subject, message, headers, and attachments values.
     */
    $atts = apply_filters( 'wp_mail', compact( 'to', 'subject', 'message', 'headers', 'attachments' ) );
 
    if ( isset( $atts['to'] ) ) {
        $to = $atts['to'];
    }
 
    if ( !is_array( $to ) ) {
        $to = explode( ',', $to );
    }
 
    if ( isset( $atts['subject'] ) ) {
        $subject = $atts['subject'];
    }
 
    if ( isset( $atts['message'] ) ) {
        $message = $atts['message'];
    }
 
    if ( isset( $atts['headers'] ) ) {
        $headers = $atts['headers'];
    }
 
    if ( isset( $atts['attachments'] ) ) {
        $attachments = $atts['attachments'];
    }
 
    if ( ! is_array( $attachments ) ) {
        $attachments = explode( "\n", str_replace( "\r\n", "\n", $attachments ) );
    }
    global $phpmailer;
 
    // (Re)create it, if it's gone missing
    if ( ! ( $phpmailer instanceof PHPMailer ) ) {
        require_once ABSPATH . WPINC . '/class-phpmailer.php';
        require_once ABSPATH . WPINC . '/class-smtp.php';
        $phpmailer = new PHPMailer( true );
    }
 
    // Headers
    $cc = $bcc = $reply_to = array();
 
    if ( empty( $headers ) ) {
        $headers = array();
    } else {
        if ( !is_array( $headers ) ) {
            // Explode the headers out, so this function can take both
            // string headers and an array of headers.
            $tempheaders = explode( "\n", str_replace( "\r\n", "\n", $headers ) );
        } else {
            $tempheaders = $headers;
        }
        $headers = array();
 
        // If it's actually got contents
        if ( !empty( $tempheaders ) ) {
            // Iterate through the raw headers
            foreach ( (array) $tempheaders as $header ) {
                if ( strpos($header, ':') === false ) {
                    if ( false !== stripos( $header, 'boundary=' ) ) {
                        $parts = preg_split('/boundary=/i', trim( $header ) );
                        $boundary = trim( str_replace( array( "'", '"' ), '', $parts[1] ) );
                    }
                    continue;
                }
                // Explode them out
                list( $name, $content ) = explode( ':', trim( $header ), 2 );
 
                // Cleanup crew
                $name    = trim( $name    );
                $content = trim( $content );
 
                switch ( strtolower( $name ) ) {
                    // Mainly for legacy -- process a From: header if it's there
                    case 'from':
                        $bracket_pos = strpos( $content, '<' );
                        if ( $bracket_pos !== false ) {
                            // Text before the bracketed email is the "From" name.
                            if ( $bracket_pos > 0 ) {
                                $from_name = substr( $content, 0, $bracket_pos - 1 );
                                $from_name = str_replace( '"', '', $from_name );
                                $from_name = trim( $from_name );
                            }
 
                            $from_email = substr( $content, $bracket_pos + 1 );
                            $from_email = str_replace( '>', '', $from_email );
                            $from_email = trim( $from_email );
 
                        // Avoid setting an empty $from_email.
                        } elseif ( '' !== trim( $content ) ) {
                            $from_email = trim( $content );
                        }
                        break;
                    case 'content-type':
                        if ( strpos( $content, ';' ) !== false ) {
                            list( $type, $charset_content ) = explode( ';', $content );
                            $content_type = trim( $type );
                            if ( false !== stripos( $charset_content, 'charset=' ) ) {
                                $charset = trim( str_replace( array( 'charset=', '"' ), '', $charset_content ) );
                            } elseif ( false !== stripos( $charset_content, 'boundary=' ) ) {
                                $boundary = trim( str_replace( array( 'BOUNDARY=', 'boundary=', '"' ), '', $charset_content ) );
                                $charset = '';
                            }
 
                        // Avoid setting an empty $content_type.
                        } elseif ( '' !== trim( $content ) ) {
                            $content_type = trim( $content );
                        }
                        break;
                    case 'cc':
                        $cc = array_merge( (array) $cc, explode( ',', $content ) );
                        break;
                    case 'bcc':
                        $bcc = array_merge( (array) $bcc, explode( ',', $content ) );
                        break;
                    case 'reply-to':
                        $reply_to = array_merge( (array) $reply_to, explode( ',', $content ) );
                        break;
                    default:
                        // Add it to our grand headers array
                        $headers[trim( $name )] = trim( $content );
                        break;
                }
            }
        }
    }
 
    // Empty out the values that may be set
    $phpmailer->clearAllRecipients();
    $phpmailer->clearAttachments();
    $phpmailer->clearCustomHeaders();
    $phpmailer->clearReplyTos();
 
    // From email and name
    // If we don't have a name from the input headers
    if ( !isset( $from_name ) )
        $from_name = 'WordPress';
 
    /* If we don't have an email from the input headers default to wordpress@$sitename
     * Some hosts will block outgoing mail from this address if it doesn't exist but
     * there's no easy alternative. Defaulting to admin_email might appear to be another
     * option but some hosts may refuse to relay mail from an unknown domain. See
     */
 
    if ( !isset( $from_email ) ) {
        // Get the site domain and get rid of www.
        $sitename = strtolower( $_SERVER['SERVER_NAME'] );
        if ( substr( $sitename, 0, 4 ) == 'www.' ) {
            $sitename = substr( $sitename, 4 );
        }
 
        $from_email = 'wordpress@' . $sitename;
    }
 
    /**
     * Filters the email address to send from.
     *
     * @since 2.2.0
     *
     * @param string $from_email Email address to send from.
     */
    $from_email = apply_filters( 'wp_mail_from', $from_email );
 
    /**
     * Filters the name to associate with the "from" email address.
     *
     * @since 2.3.0
     *
     * @param string $from_name Name associated with the "from" email address.
     */
    $from_name = apply_filters( 'wp_mail_from_name', $from_name );
 
    try {
        $phpmailer->setFrom( $from_email, $from_name, false );
    } catch ( phpmailerException $e ) {
        $mail_error_data = compact( 'to', 'subject', 'message', 'headers', 'attachments' );
        $mail_error_data['phpmailer_exception_code'] = $e->getCode();
 
        /** This filter is documented in wp-includes/pluggable.php */
        do_action( 'wp_mail_failed', new WP_Error( 'wp_mail_failed', $e->getMessage(), $mail_error_data ) );
 
        return false;
    }
 
    // Set mail's subject and body
    $phpmailer->Subject = $subject;
    $phpmailer->Body    = $message;
 
    // Set destination addresses, using appropriate methods for handling addresses
    $address_headers = compact( 'to', 'cc', 'bcc', 'reply_to' );
 
    foreach ( $address_headers as $address_header => $addresses ) {
        if ( empty( $addresses ) ) {
            continue;
        }
 
        foreach ( (array) $addresses as $address ) {
            try {
                // Break $recipient into name and address parts if in the format "Foo <bar@baz.com>"
                $recipient_name = '';
 
                if ( preg_match( '/(.*)<(.+)>/', $address, $matches ) ) {
                    if ( count( $matches ) == 3 ) {
                        $recipient_name = $matches[1];
                        $address        = $matches[2];
                    }
                }
 
                switch ( $address_header ) {
                    case 'to':
                        $phpmailer->addAddress( $address, $recipient_name );
                        break;
                    case 'cc':
                        $phpmailer->addCc( $address, $recipient_name );
                        break;
                    case 'bcc':
                        $phpmailer->addBcc( $address, $recipient_name );
                        break;
                    case 'reply_to':
                        $phpmailer->addReplyTo( $address, $recipient_name );
                        break;
                }
            } catch ( phpmailerException $e ) {
                continue;
            }
        }
    }
 
    // Set to use PHP's mail()
    $phpmailer->isMail();
 
    // Set Content-Type and charset
    // If we don't have a content-type from the input headers
    if ( !isset( $content_type ) )
        $content_type = 'text/plain';
 
    /**
     * Filters the wp_mail() content type.
     *
     * @since 2.3.0
     *
     * @param string $content_type Default wp_mail() content type.
     */
    $content_type = apply_filters( 'wp_mail_content_type', $content_type );
 
    $phpmailer->ContentType = $content_type;
 
    // Set whether it's plaintext, depending on $content_type
    if ( 'text/html' == $content_type )
        $phpmailer->isHTML( true );
 
    // If we don't have a charset from the input headers
    if ( !isset( $charset ) )
        $charset = get_bloginfo( 'charset' );
 
    // Set the content-type and charset
 
    /**
     * Filters the default wp_mail() charset.
     *
     * @since 2.3.0
     *
     * @param string $charset Default email charset.
     */
    $phpmailer->CharSet = apply_filters( 'wp_mail_charset', $charset );
 
    // Set custom headers
    if ( !empty( $headers ) ) {
        foreach ( (array) $headers as $name => $content ) {
            $phpmailer->addCustomHeader( sprintf( '%1$s: %2$s', $name, $content ) );
        }
 
        if ( false !== stripos( $content_type, 'multipart' ) && ! empty($boundary) )
            $phpmailer->addCustomHeader( sprintf( "Content-Type: %s;\n\t boundary=\"%s\"", $content_type, $boundary ) );
    }
 
    if ( !empty( $attachments ) ) {
        foreach ( $attachments as $attachment ) {
            try {
                $phpmailer->addAttachment($attachment);
            } catch ( phpmailerException $e ) {
                continue;
            }
        }
    }
 
    /**
     * Fires after PHPMailer is initialized.
     *
     * @since 2.2.0
     *
     * @param PHPMailer $phpmailer The PHPMailer instance (passed by reference).
     */
    do_action_ref_array( 'phpmailer_init', array( &$phpmailer ) );
 
    // Send!
    try {
        return $phpmailer->send();
    } catch ( phpmailerException $e ) {
 
        $mail_error_data = compact( 'to', 'subject', 'message', 'headers', 'attachments' );
        $mail_error_data['phpmailer_exception_code'] = $e->getCode();
 
        /**
         * Fires after a phpmailerException is caught.
         *
         * @since 4.4.0
         *
         * @param WP_Error $error A WP_Error object with the phpmailerException message, and an array
         *                        containing the mail recipient, subject, message, headers, and attachments.
         */
        do_action( 'wp_mail_failed', new WP_Error( 'wp_mail_failed', $e->getMessage(), $mail_error_data ) );
 
        return false;
    }
}

Top ↑

Changelog Changelog

Changelog
VersionDescription
1.2.1Introduced.

Top ↑

More Information More Information

Top ↑

Usage Usage

1
wp_mail( $to, $subject, $message, $headers, $attachments );

Optional filters ‘wp_mail_from‘ and ‘wp_mail_from_name‘ are run on the sender email address and name. The return values are reassembled into a ‘from’ address like ‘”Example User” ‘ If only ‘wp_mail_from‘ returns a value, then just the email address will be used with no name.

The default content type is ‘text/plain’ which does not allow using HTML. You can set the content type of the email either by using the ‘wp_mail_content_type‘ filter ( see example below), or by including a header like “Content-type: text/html”. Be careful to reset ‘wp_mail_content_type’ back to ‘text/plain’ after you send your message, though, because failing to do so could lead to unexpected problems with e-mails from WP or plugins/themes.

The default charset is based on the charset used on the blog. The charset can be set using the ‘wp_mail_charset‘ filter.

Top ↑

Notes Notes

  • true return value does not automatically mean that the user received the email successfully.
  • For this function to work, the settings SMTP and smtp_port (default: 25) need to be set in your php.ini file.
  • The function is available after the hook 'plugins_loaded'.
  • The filenames in the $attachments attribute have to be filesystem paths.

Top ↑

Valid Address Formats Valid Address Formats

All email addresses supplied to wp_mail() as the $to parameter must comply with RFC 2822. Some valid examples:

  • user@example.com
  • user@example.com, anotheruser@example.com
  • User <user@example.com>
  • User <user@example.com>, Another User <anotheruser@example.com>

The same applies to Cc: and Bcc: fields in $headers, but as noted in the next section, it’s better to push multiple addresses into an array instead of listing them on a single line. Either address format, with or without the user name, may be used.

Top ↑

Using $headers To Set “From:”, “Cc:” and “Bcc:” Parameters Using $headers To Set “From:”, “Cc:” and “Bcc:” Parameters

To set the “From:” email address to something other than the WordPress default sender, or to add “Cc:” and/or “Bcc:” recipients, you must use the $headers argument.

$headers can be a string or an array, but it may be easiest to use in the array form. To use it, push a string onto the array, starting with “From:”, “Bcc:” or “Cc:” (note the use of the “:”), followed by a valid email address.

When you are using the array form, you do not need to supply line breaks ("\n" or "\r\n"). Although the function can handle multiple emails per line, it may simply be easier to push each email address separately onto the $headers array. The function will figure it out and will build the proper Mime header automagically. Just don’t forget that each string you push must have the header type as the first part of the string (“From:”, “Cc:” or “Bcc:”)



Top ↑

User Contributed Notes User Contributed Notes

  1. Skip to note content
    Contributed by Codex — 

    To send HTML formatted mail, you also can specify the Content-Type HTTP header in the $headers parameter:

    1
    2
    3
    4
    5
    6
    $to = 'sendto@example.com';
    $subject = 'The subject';
    $body = 'The email body content';
    $headers = array('Content-Type: text/html; charset=UTF-8');
     
    wp_mail( $to, $subject, $body, $headers );
  2. Skip to note content
    Contributed by Codex — 

    Example using the array form of $headers:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    <?php
    // assumes $to, $subject, $message have already been defined earlier...
     
    $headers[] = 'From: Me Myself <me@example.net>';
    $headers[] = 'Cc: John Q Codex <jqc@wordpress.org>';
    $headers[] = 'Cc: iluvwp@wordpress.org'; // note you can just use a simple email address
     
    wp_mail( $to, $subject, $message, $headers );
    ?>
  3. Skip to note content
    Contributed by stratboy — 

    Here’s an example of a basic configuration for SMTP (so phpmailer will be used instead of php’s mail()):

    1
    2
    3
    4
    5
    6
    7
    8
    add_action( 'phpmailer_init', 'mailer_config', 10, 1);
    function mailer_config(PHPMailer $mailer){
      $mailer->IsSMTP();
      $mailer->Host = "mail.telemar.it"; // your SMTP server
      $mailer->Port = 25;
      $mailer->SMTPDebug = 2; // write 0 if you don't want to see client/server communication in page
      $mailer->CharSet  = "utf-8";
    }

    Here’s an example of a basic error logging:

    1
    2
    3
    4
    5
    6
    7
    add_action('wp_mail_failed', 'log_mailer_errors', 10, 1);
    function log_mailer_errors(){
      $fn = ABSPATH . '/mail.log'; // say you've got a mail.log file in your server root
      $fp = fopen($fn, 'a');
      fputs($fp, "Mailer Error: " . $mailer->ErrorInfo ."\n");
      fclose($fp);
    }

    Then use wp_mail() to send your mail.

    If you’re using it for sending a form and your form’s action is the page’s permalink, you can do some basic checking for $_POST lenght/count to see if the page comes from a form submission.

    1
    2
    3
    4
    if(count($_POST) != 0){ // on top of page
      // Then collect form data and try to send the form and write messages and so on...
      // Note: set $mailer-&gt;SMTPDebug to 0 to prevent it to write server messages on the page
    }

    NOTE: if you are using MAMP PRO to test from your local server, you should:

    – go to the Postfix panel
    – write your current virtual server as the ‘domain of outgoing email’
    – activate ‘use a smart host for routing’
    – write your provider’s smtp server (the same you are using in your mail client config)
    – Eventually add authentication (then you should also setup the credentials in the phpmailer_init action)

  4. Skip to note content
    Contributed by daniyalahmedk — 

    Combining Content-Type(HTML) and From (Site name and “from” email)

    1
    2
    3
    4
    5
    6
    $to = 'emailsendto@example.com';
    $subject = 'The subject';
    $body = 'The email body content';
    $headers = array('Content-Type: text/html; charset=UTF-8','From: My Site Name &lt;support@example.com');
     
    wp_mail( $to, $subject, $body, $headers );
  5. Skip to note content
    Contributed by Codex — 

    Switch to HTML formatted email (using the wp_mail_content_type filter):

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    <?php
    add_filter( 'wp_mail_content_type', 'wpdocs_set_html_mail_content_type' );
     
    $to = 'sendto@example.com';
    $subject = 'The subject';
    $body = 'The email body content';
     
    wp_mail( $to, $subject, $body );
     
    // Reset content-type to avoid conflicts -- https://core.trac.wordpress.org/ticket/23578
    remove_filter( 'wp_mail_content_type', 'wpdocs_set_html_mail_content_type' );
     
    function wpdocs_set_html_mail_content_type() {
        return 'text/html';
    }
    ?>
  6. Skip to note content
    Contributed by Mark Howells-Mead — 

    If you need to set the Reply-To address, note that the syntax which PHPMailer needs is pretty specific. The email address must be enclosed within <> characters. It’s also advisable to set the “reply to” name.

    1
    2
    3
    $headers = array(
      'Reply-To: Person Name <person.name@example.com>',
    );
  7. Skip to note content
    Contributed by drbobjr — 

    Having spent nearly a day banging my head against this one, I would strongly recommend that the doc for wp_mail() include the tip that many servers will require that a mail user account be created with the email address of wordpress@domain.com before this function will work. I would have NEVER figured that one out without many hours of google searches.

  8. Skip to note content
    Contributed by jmikewp — 

    As of 4.6 header from can’t be a post variable, need to be set before otherwise your site will show php error “Fatal error: Uncaught exception ‘phpmailerException’ with message ‘Invalid address: (setFrom)”

    This is due to ‘from email’ being set as variable and is not yet being passed by form submit.

    1
    $headers = "From: $name <$email>" . "\r\n";

    Fix by predefining a variable for both $name and $email that will be overwritten after submit(ex.1), or set hardcoded(ex.2).
    ex.1

    1
    2
    3
    4
    5
    6
    $name = "Site name";
    $email = "info@sitename.com";
    if(isset $_POST["name"]){
    $name = sanitize_text_field($_POST["name"]);
    $email = sanitize_email($_POST["email"]);
    }

    ex.2

    1
    $headers = "From: Site name <info@sitename.com>" . "\r\n";
  9. Skip to note content
    Contributed by Louis-Marie Matthews — 

    It’s important to know that this function might fail if you specify an empty body, even if using a SMTP.

    1
    wp_mail( 'email@provider.com', 'Subject', '' ); // returns false, the email was not sent
    1
    wp_mail( 'email@provider.com', 'Subject', 'Body' ); // returns true (if everything else is working)

You must log in before being able to contribute a note or feedback.


+ Recent posts