> ## Documentation Index
> Fetch the complete documentation index at: https://docs.lettr.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Recipients

> Control email addressing in Lettr with To, CC, BCC, Reply-To, and sender display names for both single and multiple recipients

Every email needs a sender and at least one recipient, but transactional emails often involve more complex addressing — copying a manager on an order confirmation, blind-copying a compliance archive, or routing replies to a support team instead of a no-reply address. Lettr gives you full control over To, CC, BCC, Reply-To, and sender display names.

## To Recipients

Send to one or multiple recipients:

```javascript theme={null}
// Single recipient
await lettr.emails.send({
  from: 'you@example.com',
  to: ['recipient@example.com'],
  subject: 'Hello',
  html: '<p>Hello!</p>'
});

// Multiple recipients (up to 50)
await lettr.emails.send({
  from: 'you@example.com',
  to: ['alice@example.com', 'bob@example.com', 'carol@example.com'],
  subject: 'Team Update',
  html: '<p>Hello team!</p>'
});
```

## CC Recipients

CC recipients receive a copy of the email and are visible to all other recipients. Use CC when transparency matters — for example, copying a manager on a project update or keeping a team lead informed about client communications.

```javascript theme={null}
await lettr.emails.send({
  from: 'you@example.com',
  to: ['primary@example.com'],
  cc: ['manager@example.com', 'team-lead@example.com'],
  subject: 'Project Update',
  html: '<p>Here is the latest update...</p>'
});
```

## BCC Recipients

BCC recipients receive a copy of the email but are hidden from all other recipients. Common uses include compliance archiving (sending a copy to a records system), internal monitoring (copying a sales pipeline tool), or sending to multiple customers who shouldn't see each other's addresses.

```javascript theme={null}
await lettr.emails.send({
  from: 'you@example.com',
  to: ['customer@example.com'],
  bcc: ['sales-archive@example.com', 'compliance@example.com'],
  subject: 'Your Order Confirmation',
  html: '<p>Thank you for your order!</p>'
});
```

## Reply-To Address

Reply-To lets you send from one address (like `noreply@example.com`) while directing replies to another (like `support@example.com`). This is useful when your sending address is automated but you want replies to reach a real team.

```javascript theme={null}
await lettr.emails.send({
  from: 'noreply@example.com',
  from_name: 'Acme Support',
  to: ['customer@example.com'],
  reply_to: 'support@example.com',
  reply_to_name: 'Acme Support Team',
  subject: 'Your Support Ticket',
  html: '<p>We received your request...</p>'
});
```

## Sender Name

The `from_name` parameter sets the display name that appears alongside the sender's email address in the recipient's inbox. A clear, recognizable sender name improves open rates because recipients can identify who the email is from before reading the subject line:

```javascript theme={null}
await lettr.emails.send({
  from: 'notifications@example.com',
  from_name: 'Acme Inc',
  to: ['recipient@example.com'],
  subject: 'Welcome to Acme',
  html: '<p>Welcome aboard!</p>'
});
```

The recipient will see: `Acme Inc <notifications@example.com>`

## Recipient Limits

| Limit                      | Value                     |
| -------------------------- | ------------------------- |
| Max recipients per request | 50 (combined to, cc, bcc) |
| Max email address length   | 255 characters            |

<Warning>
  Sending to more than 50 recipients requires multiple API calls. For bulk sending, see [Batch Sending](/learn/sending/batch-sending).
</Warning>

## Email Address Validation

Lettr validates all email addresses before accepting a send request. Each address must pass three checks:

* **RFC 5322 format** — The address must conform to standard email format
* **Valid DNS records** — The domain must have DNS records that accept email
* **Not suppressed** — The address must not appear on your account's suppression list

If any address fails validation, the API rejects the request and the email is not sent to any recipient:

```json theme={null}
// Invalid email format
{
  "error_code": "validation_error",
  "message": "The given data was invalid.",
  "errors": {
    "to.0": ["The to.0 must be a valid email address."]
  }
}

// Too many recipients
{
  "error_code": "validation_error",
  "message": "The given data was invalid.",
  "errors": {
    "to": ["The to field must not have more than 50 items."]
  }
}
```

## Combined Example

Here's a realistic example that uses multiple recipient features together — an order confirmation sent to the customer, CC'd to their account manager, BCC'd to the order archive, with replies directed to the support team:

```javascript theme={null}
await lettr.emails.send({
  from: 'orders@yourstore.com',
  from_name: 'YourStore',
  to: ['customer@example.com'],
  cc: ['account-manager@yourstore.com'],
  bcc: ['order-archive@yourstore.com'],
  reply_to: 'support@yourstore.com',
  reply_to_name: 'YourStore Support',
  subject: 'Order #12345 Confirmed',
  html: '<p>Thank you for your order! Your items will ship within 2 business days.</p>'
});
```

## Recipient Parameters Reference

| Parameter       | Type      | Required | Description                                 |
| --------------- | --------- | -------- | ------------------------------------------- |
| `to`            | string\[] | Yes      | Primary recipient(s)                        |
| `cc`            | string\[] | No       | Carbon copy recipients                      |
| `bcc`           | string\[] | No       | Blind carbon copy recipients                |
| `from`          | string    | Yes      | Sender email (must be from verified domain) |
| `from_name`     | string    | No       | Sender display name                         |
| `reply_to`      | string    | No       | Reply-to email address                      |
| `reply_to_name` | string    | No       | Reply-to display name                       |