Email

CC & BCC

Send one email to To, Cc and Bcc recipients, with the API or with SMTP. Everyone gets their own copy, and Bcc recipients stay hidden.

POSThttps://mail.sendcorex.com/v3.0/send
i

Same endpoint and fields as Send Email, plus cc and bcc. Sending the same email to many people who should not see each other? Use Send Batch Emails.

How it works

Every address gets its own copy of the email. The To and Cc headers are the same in every copy, so the conversation looks the same for everyone.

to

Main recipients

Shown in the To header of every copy.

cc

Visible copies

Shown in the Cc header of every copy, so everyone sees who else got it.

bcc

Hidden copies

Get the same email but never appear in any header, not even in their own copy.

What each recipient sees

For the example on this page: one to, two cc and one bcc.

Copy sent toFieldTo headerCc header
ana@example.comtoana@example.combob@example.com, carol@example.com
bob@example.comccana@example.combob@example.com, carol@example.com
carol@example.comccana@example.combob@example.com, carol@example.com
dan@example.combccana@example.combob@example.com, carol@example.com
!

dan@example.com is not in any header. He gets the email, but no one can tell he got it, and his own copy does not show his address either.

Body parameters

All the other fields work the same as in Send Email.

  • tostring | string[]required

    Main recipients. Shown in the To header of every copy.

    e.g. "ana@example.com"

  • ccstring | string[]optional

    Visible copies. Shown in the Cc header of every copy.

    e.g. ["bob@example.com", "carol@example.com"]

  • bccstring | string[]optional

    Hidden copies. Each one gets the email, but no header shows them.

    e.g. "dan@example.com"

Each field takes one address as a string or several as an array. Field names are not case sensitive: cc, Cc and CC all work.

With the API

import axios from 'axios';

const response = await axios.post(
  'https://mail.sendcorex.com/v3.0/send',
  {
    to: 'ana@example.com',
    cc: ['bob@example.com', 'carol@example.com'],
    bcc: 'dan@example.com',
    from: 'noreply@yourdomain.com',
    senderName: 'My App',
    subject: 'Project kickoff',
    body: '<p>Hi all, see you on Monday.</p>',
  },
  {
    headers: { Authorization: process.env.SENDCOREX_API_KEY },
  }
);

// one id per recipient: ana, bob, carol and dan
const { ids, recipients } = response.data;

Response

ids has one id per recipient, cc and bcc included. Use it to match logs and webhooks to each copy.

{
  "success": true,
  "message": "Email queued successfully",
  "code": "EMAIL_QUEUED_SUCCESS",
  "id": "3f2a1b4c-8e9d-4f7a-b2c3-1a2b3c4d5e6f",
  "ids": [
    { "id": "3f2a1b4c-8e9d-4f7a-b2c3-1a2b3c4d5e6f", "recipient": "ana@example.com" },
    { "id": "8b1d4e2a-6c3f-4a9b-9e1d-2f3a4b5c6d7e", "recipient": "bob@example.com" },
    { "id": "c4e7a1b9-2d5f-4c8e-a3b6-7d8e9f0a1b2c", "recipient": "carol@example.com" },
    { "id": "e9f2c5d8-1a4b-4e7c-b0d3-6a7b8c9d0e1f", "recipient": "dan@example.com" }
  ],
  "recipients": 4,
  "scheduledAt": null
}

With SMTP

Use your library's cc and bcc options. Every address goes in the envelope (RCPT TO) and gets its own copy. The Cc header is kept as you sent it. A recipient in the envelope that is not in To or Cc is a Bcc recipient. Connection settings are on SMTP integration.

const nodemailer = require('nodemailer');

const transporter = nodemailer.createTransport({
  host: 'smtp.emailsbit.com',
  port: 588,
  secure: false, // STARTTLS: starts as plain text, upgrades to TLS
  requireTLS: true,
  auth: {
    user: process.env.SMTP_USER,
    pass: process.env.SMTP_PASS,
  },
});

async function main() {
  await transporter.sendMail({
    from: '"Support" <support@yourdomain.com>',
    to: 'ana@example.com',
    cc: ['bob@example.com', 'carol@example.com'],
    bcc: 'dan@example.com', // sent in the envelope only, never as a header
    subject: 'Project kickoff',
    html: '<p>Hi all, see you on Monday.</p>',
  });
}

main().catch(console.error);
!

Building the message by hand?Do not write a Bcc: header. Put the Bcc addresses only in the envelope, as in the Go example. The libraries above already do this for you.

Limits and credits

Up to 50 recipients

to, cc and bcc together can have up to 50 unique addresses. Above that the request fails with RECIPIENT_LIMIT_EXCEEDED and nothing is sent.

Duplicates get one copy

An address that appears in more than one field, in any letter case, gets a single copy. It counts in the first field where it appears: to, then cc, then bcc.

1 credit per copy

Each recipient is one email: 1 to, 2 cc and 1 bcc use 4 credits. If you have fewer credits than recipients, the request fails with NO_CREDITS_LEFT and nothing is sent.

One email per recipient

Each copy has its own id, log, webhooks, open and click tracking, and unsubscribe link. A bounce on one copy does not affect the others.

Hard bounces are checked for every address

A cc or bcc address that hard bounced in the last 90 days is not contacted, the same as a to address. You get a bounced event for that copy.

Without cc or bcc, nothing changes

If you send to as an array and leave cc and bcc out, every recipient still gets a separate email that shows only their own address.

Copies blocked by a known hard bounce come back as a bounced event for that recipient only.

The errors specific to recipients. Any of them rejects the whole request, so no copy is sent.

  • 401NO_CREDITS_LEFT

    Not enough email credits for every recipient. Each to, cc and bcc address uses 1 credit.

  • 400INVALID_TOADDRESS

    One or more recipient addresses are malformed.

  • 400TOADDRESS_LIMIT_EXCEEDED

    More than 50 recipients in the to array.

  • 400INVALID_CCADDRESS

    One or more cc addresses are malformed.

  • 400INVALID_BCCADDRESS

    One or more bcc addresses are malformed.

  • 400RECIPIENT_LIMIT_EXCEEDED

    to, cc and bcc together have more than 50 unique recipients.