# E-mails API

> Envie e-mails, consulte as mensagens e o conteúdo delas, e agende, cancele, tente de novo ou encaminhe envios.

URL base: `https://api.emailit.com/v2`. Autentique-se com `Authorization: Bearer <API key>`.

## Enviar um e-mail — POST /emails

> Envie um e-mail para um ou mais destinatários com HTML ou texto, um template, anexos, cabeçalhos personalizados, metadados, agendamento e rastreamento.

# Enviar um e-mail

Envia um e-mail de um domínio de envio verificado. Cada destinatário recebe uma cópia separada com o próprio ID de e-mail, e cada destinatário custa um crédito.

`POST /emails`

Funciona com chaves de API `sending` e `full`. Os envios contam para os [limites de envio](/pt/docs/api-reference/rate-limits/) do workspace, e uma resposta bem-sucedida significa que o e-mail foi aceito e colocado na fila, não que já foi entregue. Acompanhe a entrega com [webhooks](/pt/docs/webhooks/) ou com [Obter um e-mail](/pt/docs/api-reference/emails/get/). Workspaces não verificados só podem enviar para os e-mails das contas dos membros deles.

## Cabeçalhos

- `Idempotency-Key` (string): Uma chave única, com até 256 letras, dígitos, `-` e `_`. Uma nova tentativa com a mesma chave em até 24 horas retorna a primeira resposta em vez de enviar de novo. Consulte [Idempotência](/pt/docs/api-reference/idempotency/).

## Parâmetros do corpo

- `from` (string, obrigatório): O remetente, como `hello@acme.com` ou `Acme <hello@acme.com>`. O endereço deve estar em um domínio de envio verificado do workspace, e no domínio da chave se a chave for [restrita a um domínio](/pt/docs/api-reference/authentication/#restrict-a-key-to-one-domain).

- `to` (string | string[], obrigatório): Os destinatários, como um array ou uma string separada por vírgulas. Cada entrada pode ser `ada@example.com` ou `Ada Lovelace <ada@example.com>`. Até 50.

- `cc` (string | string[]): Destinatários em cópia. Até 50.

- `bcc` (string | string[]): Destinatários em cópia oculta. Até 50. Eles não aparecem nos cabeçalhos da mensagem.

- `reply_to` (string | string[]): Endereços para as respostas. Se você enviar com um template e omitir este campo, o endereço de resposta (Reply-To) do template é usado.

- `subject` (string): A linha de assunto. Obrigatório, a menos que `template` forneça um.

- `html` (string): O corpo HTML. Você precisa de `html`, `text` ou ambos, a menos que `template` forneça o conteúdo.

- `text` (string): O corpo em texto simples. Quando você envia `html` e `text`, os destinatários recebem uma mensagem multipart.

- `template` (string): Um template a enviar. Passe um ID de template (`tem_…`) para usar exatamente essa versão, ou um alias para usar a versão publicada dele. `subject`, `html` e `text` na requisição substituem os do template. Consulte [Templates](/pt/docs/templates/).

- `variables` (object): Valores para placeholders do [Temple](/pt/docs/templates/temple/), como `{{first_name}}`, renderizados no assunto, no HTML e no texto. Funciona com templates e com conteúdo inline.

- `attachments` (object[]): Arquivos a anexar. Consulte [Objeto de anexo](#attachment-object) abaixo.

- `headers` (object): Cabeçalhos MIME extras como pares nome–valor, por exemplo `{"List-Unsubscribe": "<https://acme.com/unsubscribe>"}`. O próprio Emailit define o `Message-ID`.

- `meta` (object): Os seus próprios dados de chave–valor, por exemplo `{"order_id": "1042"}`. Os valores devem ser strings. Armazenados com o e-mail e incluídos nas leituras e nos payloads de webhook.

- `scheduled_at` (string): Quando enviar, como uma data e hora ISO 8601, por exemplo `2026-10-02T09:00:00Z`, ou em inglês, por exemplo `tomorrow at 9am`. Inclua um fuso horário nos valores ISO 8601. Um horário no passado, ou um valor que não possa ser interpretado (incluindo um timestamp Unix), envia o e-mail imediatamente. Os e-mails agendados têm o status `scheduled` até serem enviados.

- `tracking` (boolean | object): Ativa ou desativa o rastreamento de aberturas e cliques deste e-mail: `true`, `false` ou `{"loads": true, "clicks": false}`. Por padrão, usa as configurações do domínio de envio. O rastreamento só funciona quando o [CNAME de rastreamento](/pt/docs/tracking/custom-tracking-domain/) do domínio está verificado; caso contrário, ele fica desativado e a resposta mostra `false`.

### Objeto de anexo

- `filename` (string, obrigatório): O nome do arquivo, incluindo uma extensão permitida (veja abaixo).

- `content` (string): O arquivo, codificado em Base64. Envie `content` ou `url`, não os dois.

- `url` (string): Uma URL pública `http` ou `https` de onde baixar o arquivo. O Emailit o baixa quando você envia: o download deve terminar em até 30 segundos, ter no máximo 25 MB e não pode redirecionar.

- `content_type` (string): O tipo MIME, como `application/pdf`. Obrigatório com `content`. Com `url`, o padrão é o tipo que o servidor retorna.

- `content_id` (string): Torna o anexo inline. Faça referência a ele no HTML como `<img src="cid:logo">` quando `content_id` for `logo`.

- `encoding` (string): A codificação de `content`, como `base64` ou `hex`.

A mensagem inteira, incluindo os anexos, pode ter até 40 MB. Estes tipos de arquivo são permitidos:

| Categoria | Extensões |
| --- | --- |
| Texto | `.txt`, `.csv`, `.log`, `.css`, `.ics`, `.xml` |
| Imagens | `.jpg`, `.jpe`, `.jpeg`, `.gif`, `.png`, `.bmp`, `.psd`, `.tif`, `.tiff`, `.svg`, `.indd`, `.ai`, `.eps` |
| Documentos | `.doc`, `.docx`, `.rtf`, `.odt`, `.ott`, `.pdf`, `.pub`, `.pages`, `.mobi`, `.epub` |
| Áudio | `.mp3`, `.m4a`, `.m4v`, `.wma`, `.ogg`, `.flac`, `.wav`, `.aif`, `.aifc`, `.aiff` |
| Vídeo | `.mp4`, `.mov`, `.avi`, `.mkv`, `.mpeg`, `.mpg`, `.wmv` |
| Planilhas | `.xls`, `.xlsx`, `.ods`, `.numbers` |
| Apresentações | `.odp`, `.ppt`, `.pptx`, `.pps`, `.key` |
| Arquivos compactados | `.zip`, `.vcf` |
| E-mail | `.eml` |
| Criptografia | `.p7c`, `.p7m`, `.p7s`, `.pgp`, `.asc`, `.sig` |

## Retorno

Retorna `200` com o objeto de e-mail do primeiro destinatário. Quando a mensagem tem mais de um destinatário entre `to`, `cc` e `bcc`, `ids` associa cada destinatário ao ID da cópia dele. Cada cópia dispara um evento [`email.accepted`](/pt/docs/webhooks/events/email/accepted/) ou [`email.scheduled`](/pt/docs/webhooks/events/email/scheduled/).

- `object` (string): Sempre `email`.

- `id` (string): O ID do e-mail do primeiro destinatário.

- `ids` (object): Endereço do destinatário associado ao ID do e-mail, para cada destinatário. Presente apenas quando há mais de um destinatário.

- `token` (string): O token interno do primeiro e-mail.

- `message_id` (string): O cabeçalho `Message-ID` do primeiro e-mail, como `<token@acme.com>`.

- `from` (string): O remetente, como você o enviou.

- `to` (string[]): Os endereços `to`, sem nomes de exibição nem duplicados.

- `cc` (string[]): Os destinatários `cc`. Presente apenas quando você enviou algum.

- `bcc` (string[]): Os destinatários `bcc`. Presente apenas quando você enviou algum.

- `subject` (string): O assunto, depois da renderização do template e das variáveis.

- `status` (string): `accepted`, ou `scheduled` para um `scheduled_at` no futuro.

- `scheduled_at` (string | null): Quando o e-mail será enviado, ou `null`.

- `created_at` (string): Quando o e-mail foi aceito.

- `tracking` (object): O rastreamento que se aplica: booleanos `loads` e `clicks`.

**Requisição** `POST /emails`

**Node.js**

```javascript
import { Emailit } from '@emailit/node';
const emailit = new Emailit('your_api_key');

const email = await emailit.emails.send({
  from: 'Acme <hello@acme.com>',
  to: ['ada@example.com', 'grace@example.com'],
  subject: 'Welcome to Acme',
  html: '<h1>Welcome!</h1><p>Thanks for signing up.</p>',
  tracking: {
    loads: true,
    clicks: true,
  },
});
```

**Python**

```python
from emailit import EmailitClient
client = EmailitClient("your_api_key")

email = client.emails.send({
  "from": "Acme <hello@acme.com>",
  "to": ["ada@example.com", "grace@example.com"],
  "subject": "Welcome to Acme",
  "html": "<h1>Welcome!</h1><p>Thanks for signing up.</p>",
  "tracking": {
    "loads": True,
    "clicks": True
  }
})
```

**PHP**

```php
$emailit = Emailit::client('your_api_key');

$email = $emailit->emails()->send([
  'from' => 'Acme <hello@acme.com>',
  'to' => ['ada@example.com', 'grace@example.com'],
  'subject' => 'Welcome to Acme',
  'html' => '<h1>Welcome!</h1><p>Thanks for signing up.</p>',
  'tracking' => [
    'loads' => true,
    'clicks' => true,
  ],
]);
```

**Ruby**

```ruby
require "emailit"
client = Emailit::EmailitClient.new("your_api_key")

email = client.emails.send(
  from: "Acme <hello@acme.com>",
  to: ["ada@example.com", "grace@example.com"],
  subject: "Welcome to Acme",
  html: "<h1>Welcome!</h1><p>Thanks for signing up.</p>",
  tracking: { loads: true, clicks: true }
)
```

**Go**

```go
import "github.com/emailit/emailit-go/v2"
client := emailit.NewClient("your_api_key")

email, err := client.Emails.Send(&emailit.SendEmailRequest{
  From:    "Acme <hello@acme.com>",
  To:      []string{"ada@example.com", "grace@example.com"},
  Subject: "Welcome to Acme",
  Html:    "<h1>Welcome!</h1><p>Thanks for signing up.</p>",
  Tracking: &emailit.TrackingOptions{
    Loads:  true,
    Clicks: true,
  },
})
```

**Rust**

```rust
use emailit::Emailit;
use emailit::types::CreateEmailBaseOptions;

let emailit = Emailit::new("your_api_key");

let opts = CreateEmailBaseOptions::new(
    "Acme <hello@acme.com>",
    ["ada@example.com", "grace@example.com"],
    "Welcome to Acme",
)
.with_html("<h1>Welcome!</h1><p>Thanks for signing up.</p>")
.with_tracking(true, true);

let email = emailit.emails.send(opts).await?;
```

**Java**

```java
import com.emailit.*;
import com.emailit.params.*;

EmailitClient emailit = new EmailitClient("your_api_key");

EmailitObject email = emailit.emails().send(
  EmailSendParams.builder()
    .setFrom("Acme <hello@acme.com>")
    .setTo(Arrays.asList("ada@example.com", "grace@example.com"))
    .setSubject("Welcome to Acme")
    .setHtml("<h1>Welcome!</h1><p>Thanks for signing up.</p>")
    .setTracking(new TrackingOptions(true, true))
    .build()
);
```

**.NET**

```csharp
using Emailit;

var emailit = new EmailitClient("your_api_key");

var email = emailit.Emails.Send(new EmailSendOptions {
  From = "Acme <hello@acme.com>",
  To = new[] { "ada@example.com", "grace@example.com" },
  Subject = "Welcome to Acme",
  Html = "<h1>Welcome!</h1><p>Thanks for signing up.</p>",
  Tracking = new TrackingOptions { Loads = true, Clicks = true },
});
```

**Laravel**

```php
use Emailit\Laravel\Facades\Emailit;

$email = Emailit::emails()->send([
  'from' => 'Acme <hello@acme.com>',
  'to' => ['ada@example.com', 'grace@example.com'],
  'subject' => 'Welcome to Acme',
  'html' => '<h1>Welcome!</h1><p>Thanks for signing up.</p>',
  'tracking' => [
    'loads' => true,
    'clicks' => true,
  ],
]);
```

**cURL**

```bash
curl -X POST https://api.emailit.com/v2/emails \
  -H "Authorization: Bearer $EMAILIT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "from": "Acme <hello@acme.com>",
    "to": ["ada@example.com", "grace@example.com"],
    "subject": "Welcome to Acme",
    "html": "<h1>Welcome!</h1><p>Thanks for signing up.</p>",
    "tracking": {
      "loads": true,
      "clicks": true
    }
  }'
```

**cURL**

```bash
curl -X POST https://api.emailit.com/v2/emails \
  -H "Authorization: Bearer $EMAILIT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "from": "Acme <hello@acme.com>",
    "to": "ada@example.com",
    "template": "welcome",
    "variables": {
      "first_name": "Ada",
      "activation_url": "https://acme.com/activate?token=8f2c1e"
    }
  }'
```

**Node.js**

```javascript
const email = await emailit.emails.send({
  from: 'Acme <hello@acme.com>',
  to: 'ada@example.com',
  template: 'welcome',
  variables: {
    first_name: 'Ada',
    activation_url: 'https://acme.com/activate?token=8f2c1e',
  },
});
```

**Python**

```python
email = client.emails.send({
  "from": "Acme <hello@acme.com>",
  "to": "ada@example.com",
  "template": "welcome",
  "variables": {
    "first_name": "Ada",
    "activation_url": "https://acme.com/activate?token=8f2c1e"
  }
})
```

**cURL**

```bash
curl -X POST https://api.emailit.com/v2/emails \
  -H "Authorization: Bearer $EMAILIT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "from": "Acme Billing <billing@acme.com>",
    "to": "ada@example.com",
    "subject": "Your invoice INV-1042",
    "html": "<img src=\"cid:logo\"><p>Your invoice is attached.</p>",
    "attachments": [
      {
        "filename": "INV-1042.pdf",
        "content": "JVBERi0xLjQKJcOkw7zDqc...",
        "content_type": "application/pdf"
      },
      {
        "filename": "logo.png",
        "url": "https://acme.com/assets/logo.png",
        "content_id": "logo"
      }
    ]
  }'
```

**Node.js**

```javascript
import { readFile } from 'node:fs/promises';

const pdf = await readFile('INV-1042.pdf');

const email = await emailit.emails.send({
  from: 'Acme Billing <billing@acme.com>',
  to: 'ada@example.com',
  subject: 'Your invoice INV-1042',
  html: '<img src="cid:logo"><p>Your invoice is attached.</p>',
  attachments: [
    {
      filename: 'INV-1042.pdf',
      content: pdf.toString('base64'),
      content_type: 'application/pdf',
    },
    {
      filename: 'logo.png',
      url: 'https://acme.com/assets/logo.png',
      content_id: 'logo',
    },
  ],
});
```

**Python**

```python
import base64

with open("INV-1042.pdf", "rb") as f:
    pdf = base64.b64encode(f.read()).decode()

email = client.emails.send({
  "from": "Acme Billing <billing@acme.com>",
  "to": "ada@example.com",
  "subject": "Your invoice INV-1042",
  "html": '<img src="cid:logo"><p>Your invoice is attached.</p>',
  "attachments": [
    {"filename": "INV-1042.pdf", "content": pdf, "content_type": "application/pdf"},
    {"filename": "logo.png", "url": "https://acme.com/assets/logo.png", "content_id": "logo"}
  ]
})
```

**cURL**

```bash
curl -X POST https://api.emailit.com/v2/emails \
  -H "Authorization: Bearer $EMAILIT_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: reminder-appt-5531" \
  -d '{
    "from": "Acme <reminders@acme.com>",
    "to": "ada@example.com",
    "subject": "Your appointment tomorrow",
    "text": "See you tomorrow at 2 PM.",
    "scheduled_at": "2026-10-02T09:00:00Z",
    "meta": { "appointment_id": "5531" }
  }'
```

**Node.js**

```javascript
const email = await emailit.emails.send({
  from: 'Acme <reminders@acme.com>',
  to: 'ada@example.com',
  subject: 'Your appointment tomorrow',
  text: 'See you tomorrow at 2 PM.',
  scheduled_at: '2026-10-02T09:00:00Z',
  meta: { appointment_id: '5531' },
});
```

**Python**

```python
email = client.emails.send({
  "from": "Acme <reminders@acme.com>",
  "to": "ada@example.com",
  "subject": "Your appointment tomorrow",
  "text": "See you tomorrow at 2 PM.",
  "scheduled_at": "2026-10-02T09:00:00Z",
  "meta": {"appointment_id": "5531"}
})
```

**200**

```json
{
  "object": "email",
  "id": "em_4KYof1ZzXndZE2VPi0DgULiekG8",
  "ids": {
    "ada@example.com": "em_4KYof1ZzXndZE2VPi0DgULiekG8",
    "grace@example.com": "em_4KfIXZSV8v8L1k0Mg2YDR3rytvj"
  },
  "token": "4KDY1iIpQSSW5pAoiz3JEfqcsO0",
  "message_id": "<4KDY1iIpQSSW5pAoiz3JEfqcsO0@acme.com>",
  "from": "Acme <hello@acme.com>",
  "to": ["ada@example.com", "grace@example.com"],
  "subject": "Welcome to Acme",
  "status": "accepted",
  "scheduled_at": null,
  "created_at": "2026-10-01T09:30:12.482913Z",
  "tracking": {
    "loads": true,
    "clicks": true
  }
}
```

**200 Agendado**

```json
{
  "object": "email",
  "id": "em_4K76IA5sFNIsLXW9QC2ro8cDbOj",
  "token": "4KWzEED2cnej6UMjF4v508VqQIp",
  "message_id": "<4KWzEED2cnej6UMjF4v508VqQIp@acme.com>",
  "from": "Acme <reminders@acme.com>",
  "to": ["ada@example.com"],
  "subject": "Your appointment tomorrow",
  "status": "scheduled",
  "scheduled_at": "2026-10-02T09:00:00.000Z",
  "created_at": "2026-10-01T09:30:12.482913Z",
  "tracking": {
    "loads": false,
    "clicks": false
  }
}
```

**400**

```json
{
  "error": "Validation failed",
  "validation_errors": [
    "Missing required field: subject",
    "Invalid to email address at index 1: grace@example"
  ]
}
```

**402**

```json
{
  "error": "Insufficient credits",
  "message": "Insufficient credits to send this email. Required: 2, available: 0."
}
```

**403 Não verificado**

```json
{
  "code": "unverified_workspace_recipient",
  "error": "Workspace not verified",
  "message": "Unverified workspaces can only send to workspace members' account emails. Blocked recipient: grace@example.com.",
  "blocked_recipients": ["grace@example.com"]
}
```

**403 Domínio**

```json
{
  "error": "Domain not authorized",
  "message": "API key is not authorized to send from this domain"
}
```

**404**

```json
{
  "error": "Template not found",
  "message": "Template 'welcome' not found or not published"
}
```

**413**

```json
{
  "error": "Message too large",
  "message": "Message size (41.27MB) exceeds maximum allowed size of 40MB"
}
```

**422**

```json
{
  "error": "Domain not verified"
}
```

**429**

```json
{
  "error": "Rate limit exceeded",
  "message": "Too many requests. Maximum 2 messages per second allowed.",
  "limit": 2,
  "current": 2,
  "retry_after": 1
}
```

---
Fonte: https://emailit.com/pt/docs/api-reference/emails/send/

## Listar e-mails — GET /emails

> Liste os e-mails enviados ou recebidos de um workspace, dos mais recentes para os mais antigos, com busca, filtros, ordenação e uma janela padrão de 14 dias.

# Listar e-mails

Retorna uma página de e-mails, dos mais recentes para os mais antigos. Por padrão, a lista mostra os e-mails enviados nos últimos 14 dias.

`GET /emails`

Requer uma chave de API com escopo `full`. Cada destinatário de um envio é um e-mail separado nesta lista.

## Parâmetros de consulta

- `page` (integer): A página a retornar.

- `limit` (integer): E-mails por página, de 1 a 100.

- `type` (string): `outbound` para os e-mails que você enviou, ou `inbound` para os e-mails que você [recebeu](/pt/docs/inbound/).

- `date_from` (string): Apenas e-mails criados nesta data ou depois dela, como `2026-08-01` (a partir de 00:00 UTC). Sem este parâmetro, a lista começa 14 dias atrás. Os filtros `created_at` não alteram essa janela.

- `date_to` (string): Apenas e-mails criados nesta data ou antes dela, até 23:59:59 UTC.

- `search` (string): Busca sem diferenciar maiúsculas de minúsculas no destinatário, no remetente ou no assunto.

- `match` (string): `all` ou `or`. Como os filtros abaixo se combinam.

- `order` (string): Uma chave de ordenação da tabela abaixo.

- `direction` (string): `asc` ou `desc`.

## Filtros

Adicione filtros no formato `key.condition=value`, por exemplo `status.exact=bounced` ou `created_at.after=2026-09-01`. Consulte [Filtragem](/pt/docs/api-reference/filtering/) para ver as condições de cada tipo.

| Chave | Tipo | Valores e observações |
| --- | --- | --- |
| `to` | string | Endereço do destinatário. |
| `from` | string | Remetente como foi enviado, incluindo o nome de exibição, se houver. |
| `subject` | string | |
| `status` | enum | `accepted`, `scheduled`, `delivered`, `loaded`, `clicked`, `attempted`, `bounced`, `failed`, `rejected`, `suppressed`, `received`, `complained`, `canceled`, `held` |
| `tag` | string | A tag do e-mail. No momento, enviar pela API ou por SMTP não define uma tag. |
| `spam_score` | number | |
| `created_at` | date | |
| `updated_at` | date | |
| `api_key_id` | string | ID da chave de API que enviou o e-mail (`key_…`). |
| `sending_domain_id` | string | ID do domínio de envio (`dom_…`). |

Todas as chaves também são chaves de ordenação. Os parâmetros de consulta mais antigos `status`, `rcpt_to`, `mail_from`, `subject`, `api_key_id` e `sending_domain_id` continuam funcionando: `status` busca a correspondência exata, e os parâmetros de endereço e de assunto buscam correspondências parciais.

## Retorno

Retorna um array `data` de objetos de e-mail, com `next_page_url` e `previous_page_url`. Consulte [Paginação](/pt/docs/api-reference/pagination/). As URLs de página não levam os seus filtros, então solicite a próxima página com os seus próprios parâmetros e `page` aumentado em um.

- `object` (string): Sempre `email`.

- `id` (string): O ID do e-mail.

- `type` (string): `outbound` ou `inbound`.

- `from` (string): O remetente como foi enviado.

- `to` (string): O destinatário desta cópia.

- `subject` (string): O assunto.

- `status` (string): O [status](/pt/docs/logs/email-statuses/) atual.

- `size` (integer): Tamanho da mensagem, em bytes.

- `scheduled_at` (string | null): Quando um e-mail agendado está previsto, ou `null`.

- `created_at` (string): Quando o e-mail foi aceito ou recebido.

- `updated_at` (string): Quando o status mudou pela última vez.

- `meta` (object | null): O `meta` que você enviou.

**Requisição** `GET /emails`

**Node.js**

```javascript
import { Emailit } from '@emailit/node';
const emailit = new Emailit('your_api_key');

const emails = await emailit.emails.list({ page: 1, limit: 25 });
```

**Python**

```python
from emailit import EmailitClient
client = EmailitClient("your_api_key")

emails = client.emails.list({ "page": 1, "limit": 25 })
```

**PHP**

```php
$emailit = Emailit::client('your_api_key');

$emails = $emailit->emails()->list(['page' => 1, 'limit' => 25]);
```

**Ruby**

```ruby
require "emailit"
client = Emailit::EmailitClient.new("your_api_key")

emails = client.emails.list(page: 1, limit: 25)
```

**Go**

```go
import "github.com/emailit/emailit-go/v2"
client := emailit.NewClient("your_api_key")

emails, err := client.Emails.List(&emailit.ListEmailsRequest{
  Page:  1,
  Limit: 25,
})
```

**Rust**

```rust
use emailit::Emailit;

let emailit = Emailit::new("your_api_key");

let emails = emailit.emails.list(Some(emailit::types::ListEmailsParams {
  page: Some(1),
  limit: Some(25),
})).await?;
```

**Java**

```java
import com.emailit.*;
import com.emailit.params.*;

EmailitClient emailit = new EmailitClient("your_api_key");

EmailitObject emails = emailit.emails().list(
  EmailListParams.builder()
    .setPage(1)
    .setLimit(25)
    .build()
);
```

**.NET**

```csharp
using Emailit;

var emailit = new EmailitClient("your_api_key");

var emails = emailit.Emails.List(new EmailListOptions {
  Page = 1,
  Limit = 25,
});
```

**Laravel**

```php
use Emailit\Laravel\Facades\Emailit;

$emails = Emailit::emails()->list(['page' => 1, 'limit' => 25]);
```

**cURL**

```bash
curl -G https://api.emailit.com/v2/emails \
  -H "Authorization: Bearer $EMAILIT_API_KEY" \
  -d page=1 \
  -d limit=25
```

**cURL**

```bash
curl -G https://api.emailit.com/v2/emails \
  -H "Authorization: Bearer $EMAILIT_API_KEY" \
  -d status.exact=bounced \
  -d status.exact=failed \
  -d match=or \
  -d date_from=2026-09-01 \
  -d order=created_at \
  -d direction=desc
```

**200**

```json
{
  "data": [
    {
      "object": "email",
      "id": "em_4KYof1ZzXndZE2VPi0DgULiekG8",
      "type": "outbound",
      "from": "Acme <hello@acme.com>",
      "to": "ada@example.com",
      "subject": "Welcome to Acme",
      "status": "delivered",
      "size": 4523,
      "scheduled_at": null,
      "created_at": "2026-10-01T09:30:12.482913Z",
      "updated_at": "2026-10-01T09:30:14.118204Z",
      "meta": null
    },
    {
      "object": "email",
      "id": "em_4KfIXZSV8v8L1k0Mg2YDR3rytvj",
      "type": "outbound",
      "from": "Acme <hello@acme.com>",
      "to": "grace@example.com",
      "subject": "Welcome to Acme",
      "status": "loaded",
      "size": 4527,
      "scheduled_at": null,
      "created_at": "2026-10-01T09:30:12.482913Z",
      "updated_at": "2026-10-01T09:41:03.770521Z",
      "meta": null
    }
  ],
  "next_page_url": "/app/v2/emails?page=2&limit=25",
  "previous_page_url": null
}
```

**400**

```json
{
  "statusCode": 400,
  "error": "Bad Request",
  "message": "Validation error",
  "details": [
    {
      "instancePath": "/limit",
      "schemaPath": "#/properties/limit/maximum",
      "keyword": "maximum",
      "params": { "comparison": "<=", "limit": 100 },
      "message": "must be <= 100"
    }
  ]
}
```

---
Fonte: https://emailit.com/pt/docs/api-reference/emails/list/

## Obter um e-mail — GET /emails/{id}

> Obtenha um e-mail enviado ou recebido pelo ID, com o status, os cabeçalhos, o corpo HTML e em texto já interpretado, os metadados e os anexos.

# Obter um e-mail

Obtém um e-mail com o status, os cabeçalhos interpretados, o corpo HTML e em texto e os anexos.

`GET /emails/{id}`

Requer uma chave de API com escopo `full`. O conteúdo das mensagens é mantido durante o [período de retenção](/pt/docs/data-retention/) de conteúdo do seu plano. Depois disso, `headers`, `body` e `attachments` ficam vazios, e o status e os metadados permanecem. Para buscar apenas parte de um e-mail, use [Obter o corpo](/pt/docs/api-reference/emails/body/), [Obter os metadados](/pt/docs/api-reference/emails/meta/), [Listar anexos](/pt/docs/api-reference/emails/attachments/) ou [Obter o MIME bruto](/pt/docs/api-reference/emails/raw/).

## Parâmetros de caminho

- `id` (string, obrigatório): O ID do e-mail, como `em_4KYof1ZzXndZE2VPi0DgULiekG8`.

## Retorno

Retorna o objeto de e-mail.

- `object` (string): Sempre `email`.

- `id` (string): O ID do e-mail.

- `type` (string): `outbound` para os e-mails que você enviou, `inbound` para os e-mails que você recebeu.

- `token` (string): O token interno do e-mail.

- `message_id` (string): O cabeçalho `Message-ID`.

- `from` (string): O remetente como foi enviado, como `Acme <hello@acme.com>`.

- `to` (string): O destinatário desta cópia.

- `subject` (string): O assunto.

- `status` (string): O status atual: `accepted`, `scheduled`, `delivered`, `loaded`, `clicked`, `attempted`, `bounced`, `failed`, `rejected`, `suppressed`, `received`, `complained`, `canceled` ou `held`. Consulte [Status de e-mail](/pt/docs/logs/email-statuses/).

- `size` (integer): Tamanho da mensagem, em bytes.

- `scheduled_at` (string | null): Quando um e-mail agendado está previsto, ou `null`.

- `created_at` (string): Quando o e-mail foi aceito ou recebido.

- `updated_at` (string): Quando o e-mail mudou pela última vez.

- `tracking` (object): Apenas para e-mails enviados. Se o rastreamento de aberturas (`loads`) e de cliques (`clicks`) está ativado.

- `meta` (object | null): O `meta` que você enviou, ou `null`.

- `headers` (object | null): Os cabeçalhos da mensagem como pares nome–valor, ou `null` depois que o conteúdo é apagado.

- `body` (object): `text` e `html`, cada um uma string ou `null`.

- `attachments` (object[]): Os anexos, cada um com `filename`, `content_type`, `size` em bytes, `content_id` (para arquivos inline), `content_disposition` (`attachment` ou `inline`) e `content` (Base64).

**Requisição** `GET /emails/{id}`

**Node.js**

```javascript
import { Emailit } from '@emailit/node';
const emailit = new Emailit('your_api_key');

const email = await emailit.emails.get('em_4KYof1ZzXndZE2VPi0DgULiekG8');
```

**Python**

```python
from emailit import EmailitClient
client = EmailitClient("your_api_key")

email = client.emails.get("em_4KYof1ZzXndZE2VPi0DgULiekG8")
```

**PHP**

```php
$emailit = Emailit::client('your_api_key');

$email = $emailit->emails()->get('em_4KYof1ZzXndZE2VPi0DgULiekG8');
```

**Ruby**

```ruby
require "emailit"
client = Emailit::EmailitClient.new("your_api_key")

email = client.emails.get("em_4KYof1ZzXndZE2VPi0DgULiekG8")
```

**Go**

```go
import "github.com/emailit/emailit-go/v2"
client := emailit.NewClient("your_api_key")

email, err := client.Emails.Get("em_4KYof1ZzXndZE2VPi0DgULiekG8")
```

**Rust**

```rust
use emailit::Emailit;

let emailit = Emailit::new("your_api_key");

let email = emailit.emails.get("em_4KYof1ZzXndZE2VPi0DgULiekG8").await?;
```

**Java**

```java
import com.emailit.*;

EmailitClient emailit = new EmailitClient("your_api_key");

EmailitObject email = emailit.emails().get("em_4KYof1ZzXndZE2VPi0DgULiekG8");
```

**.NET**

```csharp
using Emailit;

var emailit = new EmailitClient("your_api_key");

var email = emailit.Emails.Get("em_4KYof1ZzXndZE2VPi0DgULiekG8");
```

**Laravel**

```php
use Emailit\Laravel\Facades\Emailit;

$email = Emailit::emails()->get('em_4KYof1ZzXndZE2VPi0DgULiekG8');
```

**cURL**

```bash
curl https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8 \
  -H "Authorization: Bearer $EMAILIT_API_KEY"
```

**200 Enviado**

```json
{
  "object": "email",
  "id": "em_4KYof1ZzXndZE2VPi0DgULiekG8",
  "type": "outbound",
  "token": "4KDY1iIpQSSW5pAoiz3JEfqcsO0",
  "message_id": "<4KDY1iIpQSSW5pAoiz3JEfqcsO0@acme.com>",
  "from": "Acme Billing <billing@acme.com>",
  "to": "ada@example.com",
  "subject": "Your invoice INV-1042",
  "status": "delivered",
  "size": 48213,
  "scheduled_at": null,
  "created_at": "2026-10-01T09:30:12.482913Z",
  "updated_at": "2026-10-01T09:30:14.118204Z",
  "tracking": {
    "loads": true,
    "clicks": true
  },
  "meta": {
    "invoice_id": "INV-1042"
  },
  "headers": {
    "From": "Acme Billing <billing@acme.com>",
    "To": "ada@example.com",
    "Subject": "Your invoice INV-1042",
    "Message-ID": "<4KDY1iIpQSSW5pAoiz3JEfqcsO0@acme.com>",
    "MIME-Version": "1.0",
    "Content-Type": "multipart/mixed; boundary=\"--_NmP-4f1c2a9e7b3d0e5f-Part_1\""
  },
  "body": {
    "text": "Your invoice is attached.",
    "html": "<p>Your invoice is attached.</p>"
  },
  "attachments": [
    {
      "filename": "INV-1042.pdf",
      "content_type": "application/pdf",
      "size": 40960,
      "content_id": null,
      "content_disposition": "attachment",
      "content": "JVBERi0xLjQKJcOkw7zDqc..."
    }
  ]
}
```

**200 Recebido**

```json
{
  "object": "email",
  "id": "em_4KbeG9poqTmjvQZeN8pMoJkCVNd",
  "type": "inbound",
  "token": "4KTnDU5PzzqDqp8UWb9qVhPVFOT",
  "message_id": "<CAH7x2k9@mail.example.com>",
  "from": "Ada Lovelace <ada@example.com>",
  "to": "support@inbound.acme.com",
  "subject": "Re: Your invoice INV-1042",
  "status": "received",
  "size": 8234,
  "scheduled_at": null,
  "created_at": "2026-10-01T11:02:45.031877Z",
  "updated_at": "2026-10-01T11:02:45.031877Z",
  "meta": null,
  "headers": {
    "From": "Ada Lovelace <ada@example.com>",
    "To": "support@inbound.acme.com",
    "Subject": "Re: Your invoice INV-1042",
    "Content-Type": "text/plain; charset=utf-8"
  },
  "body": {
    "text": "Thanks, received.",
    "html": null
  },
  "attachments": []
}
```

**404**

```json
{
  "error": "Email not found",
  "message": "Email with ID 'em_4KYof1ZzXndZE2VPi0DgULiekG8' not found in your workspace"
}
```

---
Fonte: https://emailit.com/pt/docs/api-reference/emails/get/

## Obter o MIME bruto — GET /emails/{id}/raw

> Obtenha o código-fonte MIME bruto completo de um e-mail, com os cabeçalhos, junto com o status e os metadados do e-mail.

# Obter o MIME bruto

Obtém o código-fonte MIME completo de um e-mail como o Emailit o armazenou, junto com os metadados dele.

`GET /emails/{id}/raw`

Requer uma chave de API com escopo `full`. Use-o para arquivar uma mensagem, depurar a estrutura dela ou interpretá-la com a sua própria biblioteca MIME. Depois que o [período de retenção](/pt/docs/data-retention/) do conteúdo termina, `raw` e `headers` são `null`.

## Parâmetros de caminho

- `id` (string, obrigatório): O ID do e-mail.

## Retorno

Retorna os metadados do e-mail, como em [Obter os metadados](/pt/docs/api-reference/emails/meta/), mas sem `attachments`, além da mensagem bruta.

- `raw` (string | null): A mensagem MIME completa: os cabeçalhos, uma linha em branco e o corpo. `null` depois que o conteúdo é apagado.

- `headers` (object | null): Os cabeçalhos de nível superior como pares nome–valor.

Os outros campos (`object`, `id`, `type`, `token`, `message_id`, `from`, `to`, `subject`, `status`, `size`, `scheduled_at`, `created_at`, `updated_at`, `tracking` e `meta`) são os mesmos de [Obter um e-mail](/pt/docs/api-reference/emails/get/).

**Requisição** `GET /emails/{id}/raw`

**Node.js**

```javascript
const response = await fetch('https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8/raw', {
  headers: { Authorization: 'Bearer your_api_key' },
});
const raw = await response.json();
```

**Python**

```python
import requests

response = requests.get(
  "https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8/raw",
  headers={"Authorization": "Bearer your_api_key"}
)
raw = response.json()
```

**PHP**

```php
$ch = curl_init('https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8/raw');
curl_setopt_array($ch, [
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_HTTPHEADER => [
    'Authorization: Bearer your_api_key',
  ],
]);
$raw = json_decode(curl_exec($ch), true);
curl_close($ch);
```

**Ruby**

```ruby
require "net/http"
require "json"

uri = URI("https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8/raw")
req = Net::HTTP::Get.new(uri)
req["Authorization"] = "Bearer your_api_key"
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
raw = JSON.parse(http.request(req).body)
```

**Go**

```go
import "github.com/emailit/emailit-go/v2"
client := emailit.NewClient("your_api_key")

raw, err := client.Emails.GetRaw("em_4KYof1ZzXndZE2VPi0DgULiekG8")
```

**Rust**

```rust
use emailit::Emailit;

let emailit = Emailit::new("your_api_key");

let raw = emailit.emails.get_raw("em_4KYof1ZzXndZE2VPi0DgULiekG8").await?;
```

**Java**

```java
import java.net.http.*;
import java.net.URI;

HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
  .uri(URI.create("https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8/raw"))
  .header("Authorization", "Bearer your_api_key")
  .GET()
  .build();
HttpResponse<String> response = client.send(request,
  HttpResponse.BodyHandlers.ofString());
```

**.NET**

```csharp
using Emailit;

var emailit = new EmailitClient("your_api_key");

var raw = emailit.Emails.GetRaw("em_4KYof1ZzXndZE2VPi0DgULiekG8");
```

**Laravel**

```php
use Illuminate\Support\Facades\Http;

$raw = Http::withToken('your_api_key')
  ->get('https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8/raw')
  ->json();
```

**cURL**

```bash
curl https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8/raw \
  -H "Authorization: Bearer $EMAILIT_API_KEY"
```

**200**

```json
{
  "object": "email",
  "id": "em_4KYof1ZzXndZE2VPi0DgULiekG8",
  "type": "outbound",
  "token": "4KDY1iIpQSSW5pAoiz3JEfqcsO0",
  "message_id": "<4KDY1iIpQSSW5pAoiz3JEfqcsO0@acme.com>",
  "from": "Acme <hello@acme.com>",
  "to": "ada@example.com",
  "subject": "Welcome to Acme",
  "status": "delivered",
  "size": 1342,
  "scheduled_at": null,
  "created_at": "2026-10-01T09:30:12.482913Z",
  "updated_at": "2026-10-01T09:30:14.118204Z",
  "tracking": {
    "loads": false,
    "clicks": false
  },
  "meta": null,
  "headers": {
    "From": "Acme <hello@acme.com>",
    "To": "ada@example.com",
    "Subject": "Welcome to Acme",
    "Message-ID": "<4KDY1iIpQSSW5pAoiz3JEfqcsO0@acme.com>",
    "MIME-Version": "1.0",
    "Content-Type": "text/html; charset=utf-8"
  },
  "raw": "From: Acme <hello@acme.com>\r\nTo: ada@example.com\r\nSubject: Welcome to Acme\r\nMessage-ID: <4KDY1iIpQSSW5pAoiz3JEfqcsO0@acme.com>\r\nMIME-Version: 1.0\r\nContent-Type: text/html; charset=utf-8\r\nContent-Transfer-Encoding: quoted-printable\r\n\r\n<h1>Welcome!</h1><p>Thanks for signing up.</p>"
}
```

**404**

```json
{
  "error": "Email not found",
  "message": "Email with ID 'em_4KYof1ZzXndZE2VPi0DgULiekG8' not found in your workspace"
}
```

---
Fonte: https://emailit.com/pt/docs/api-reference/emails/raw/

## Listar anexos — GET /emails/{id}/attachments

> Liste os anexos de um e-mail com os nomes de arquivo, os tipos MIME, os tamanhos, os Content-IDs inline e o conteúdo codificado em Base64.

# Listar anexos

Retorna os anexos de um e-mail, incluindo o conteúdo deles.

`GET /emails/{id}/attachments`

Requer uma chave de API com escopo `full`. Funciona com e-mails enviados e recebidos. Imagens inline (partes com um `Content-ID`) são incluídas. Para obter a lista sem o conteúdo dos arquivos, use [Obter os metadados](/pt/docs/api-reference/emails/meta/). Depois que o [período de retenção](/pt/docs/data-retention/) do conteúdo termina, a lista fica vazia.

## Parâmetros de caminho

- `id` (string, obrigatório): O ID do e-mail.

## Retorno

Retorna um objeto de lista com todos os anexos. A lista não é paginada.

- `object` (string): Sempre `list`.

- `data` (object[]): Os anexos.

- `data[].filename` (string): O nome do arquivo.

- `data[].content_type` (string): O tipo MIME, como `application/pdf`.

- `data[].size` (integer): Tamanho do arquivo decodificado, em bytes.

- `data[].content_id` (string | null): O `Content-ID` de um anexo inline, ou `null`.

- `data[].content_disposition` (string | null): `attachment` ou `inline`.

- `data[].content` (string): O arquivo, codificado em Base64.

**Requisição** `GET /emails/{id}/attachments`

**Node.js**

```javascript
const response = await fetch('https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8/attachments', {
  headers: { Authorization: 'Bearer your_api_key' },
});
const attachments = await response.json();
```

**Python**

```python
import requests

response = requests.get(
  "https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8/attachments",
  headers={"Authorization": "Bearer your_api_key"}
)
attachments = response.json()
```

**PHP**

```php
$ch = curl_init('https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8/attachments');
curl_setopt_array($ch, [
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_HTTPHEADER => [
    'Authorization: Bearer your_api_key',
  ],
]);
$attachments = json_decode(curl_exec($ch), true);
curl_close($ch);
```

**Ruby**

```ruby
require "net/http"
require "json"

uri = URI("https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8/attachments")
req = Net::HTTP::Get.new(uri)
req["Authorization"] = "Bearer your_api_key"
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
attachments = JSON.parse(http.request(req).body)
```

**Go**

```go
import "github.com/emailit/emailit-go/v2"
client := emailit.NewClient("your_api_key")

attachments, err := client.Emails.GetAttachments("em_4KYof1ZzXndZE2VPi0DgULiekG8")
```

**Rust**

```rust
use emailit::Emailit;

let emailit = Emailit::new("your_api_key");

let attachments = emailit.emails.get_attachments("em_4KYof1ZzXndZE2VPi0DgULiekG8").await?;
```

**Java**

```java
import java.net.http.*;
import java.net.URI;

HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
  .uri(URI.create("https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8/attachments"))
  .header("Authorization", "Bearer your_api_key")
  .GET()
  .build();
HttpResponse<String> response = client.send(request,
  HttpResponse.BodyHandlers.ofString());
```

**.NET**

```csharp
using Emailit;

var emailit = new EmailitClient("your_api_key");

var attachments = emailit.Emails.GetAttachments("em_4KYof1ZzXndZE2VPi0DgULiekG8");
```

**Laravel**

```php
use Illuminate\Support\Facades\Http;

$attachments = Http::withToken('your_api_key')
  ->get('https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8/attachments')
  ->json();
```

**cURL**

```bash
curl https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8/attachments \
  -H "Authorization: Bearer $EMAILIT_API_KEY"
```

**200**

```json
{
  "object": "list",
  "data": [
    {
      "filename": "INV-1042.pdf",
      "content_type": "application/pdf",
      "size": 40960,
      "content_id": null,
      "content_disposition": "attachment",
      "content": "JVBERi0xLjQKJcOkw7zDqc..."
    },
    {
      "filename": "logo.png",
      "content_type": "image/png",
      "size": 5120,
      "content_id": "logo",
      "content_disposition": "inline",
      "content": "iVBORw0KGgoAAAANSUhEUgAA..."
    }
  ]
}
```

**404**

```json
{
  "error": "Email not found",
  "message": "Email with ID 'em_4KYof1ZzXndZE2VPi0DgULiekG8' not found in your workspace"
}
```

---
Fonte: https://emailit.com/pt/docs/api-reference/emails/attachments/

## Obter o corpo — GET /emails/{id}/body

> Obtenha apenas o corpo HTML e em texto simples já interpretado de um e-mail, sem cabeçalhos, metadados nem anexos.

# Obter o corpo

Retorna o corpo HTML e em texto simples de um e-mail, decodificado das partes MIME dele.

`GET /emails/{id}/body`

Requer uma chave de API com escopo `full`. Funciona com e-mails enviados e recebidos. Nos e-mails enviados, o corpo é o que foi enviado, depois da renderização do template e das variáveis. Depois que o [período de retenção](/pt/docs/data-retention/) do conteúdo termina, os dois campos são `null`.

## Parâmetros de caminho

- `id` (string, obrigatório): O ID do e-mail.

## Retorno

- `text` (string | null): A parte em texto simples, ou `null` se o e-mail não tiver uma.

- `html` (string | null): A parte HTML, ou `null` se o e-mail não tiver uma.

**Requisição** `GET /emails/{id}/body`

**Node.js**

```javascript
const response = await fetch('https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8/body', {
  headers: { Authorization: 'Bearer your_api_key' },
});
const body = await response.json();
```

**Python**

```python
import requests

response = requests.get(
  "https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8/body",
  headers={"Authorization": "Bearer your_api_key"}
)
body = response.json()
```

**PHP**

```php
$ch = curl_init('https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8/body');
curl_setopt_array($ch, [
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_HTTPHEADER => [
    'Authorization: Bearer your_api_key',
  ],
]);
$body = json_decode(curl_exec($ch), true);
curl_close($ch);
```

**Ruby**

```ruby
require "net/http"
require "json"

uri = URI("https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8/body")
req = Net::HTTP::Get.new(uri)
req["Authorization"] = "Bearer your_api_key"
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
body = JSON.parse(http.request(req).body)
```

**Go**

```go
import "github.com/emailit/emailit-go/v2"
client := emailit.NewClient("your_api_key")

body, err := client.Emails.GetBody("em_4KYof1ZzXndZE2VPi0DgULiekG8")
```

**Rust**

```rust
use emailit::Emailit;

let emailit = Emailit::new("your_api_key");

let body = emailit.emails.get_body("em_4KYof1ZzXndZE2VPi0DgULiekG8").await?;
```

**Java**

```java
import java.net.http.*;
import java.net.URI;

HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
  .uri(URI.create("https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8/body"))
  .header("Authorization", "Bearer your_api_key")
  .GET()
  .build();
HttpResponse<String> response = client.send(request,
  HttpResponse.BodyHandlers.ofString());
```

**.NET**

```csharp
using Emailit;

var emailit = new EmailitClient("your_api_key");

var body = emailit.Emails.GetBody("em_4KYof1ZzXndZE2VPi0DgULiekG8");
```

**Laravel**

```php
use Illuminate\Support\Facades\Http;

$body = Http::withToken('your_api_key')
  ->get('https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8/body')
  ->json();
```

**cURL**

```bash
curl https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8/body \
  -H "Authorization: Bearer $EMAILIT_API_KEY"
```

**200**

```json
{
  "text": "Welcome!\n\nThanks for signing up.",
  "html": "<h1>Welcome!</h1><p>Thanks for signing up.</p>"
}
```

**404**

```json
{
  "error": "Email not found",
  "message": "Email with ID 'em_4KYof1ZzXndZE2VPi0DgULiekG8' not found in your workspace"
}
```

---
Fonte: https://emailit.com/pt/docs/api-reference/emails/body/

## Obter os metadados — GET /emails/{id}/meta

> Obtenha o status, os cabeçalhos, os metadados e a lista de anexos de um e-mail sem baixar o corpo da mensagem nem o conteúdo dos anexos.

# Obter os metadados

Obtém um e-mail sem o corpo: o status, os cabeçalhos, os seus dados `meta` e a lista de anexos sem o conteúdo deles.

`GET /emails/{id}/meta`

Requer uma chave de API com escopo `full`. É a forma mais leve de ler os detalhes de um e-mail quando você não precisa do conteúdo.

## Parâmetros de caminho

- `id` (string, obrigatório): O ID do e-mail.

## Retorno

Retorna os mesmos campos de [Obter um e-mail](/pt/docs/api-reference/emails/get/), sem `body` e com os `attachments` descritos, mas sem o conteúdo:

- `attachments` (object[]): O `filename`, o `content_type`, o `size`, o `content_id` e o `content_disposition` de cada anexo. Sem `content`.

- `headers` (object | null): Os cabeçalhos da mensagem como pares nome–valor, ou `null` depois que o conteúdo é apagado.

- `meta` (object | null): O `meta` que você enviou com o e-mail.

**Requisição** `GET /emails/{id}/meta`

**Node.js**

```javascript
const response = await fetch('https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8/meta', {
  headers: { Authorization: 'Bearer your_api_key' },
});
const meta = await response.json();
```

**Python**

```python
import requests

response = requests.get(
  "https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8/meta",
  headers={"Authorization": "Bearer your_api_key"}
)
meta = response.json()
```

**PHP**

```php
$ch = curl_init('https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8/meta');
curl_setopt_array($ch, [
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_HTTPHEADER => [
    'Authorization: Bearer your_api_key',
  ],
]);
$meta = json_decode(curl_exec($ch), true);
curl_close($ch);
```

**Ruby**

```ruby
require "net/http"
require "json"

uri = URI("https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8/meta")
req = Net::HTTP::Get.new(uri)
req["Authorization"] = "Bearer your_api_key"
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
meta = JSON.parse(http.request(req).body)
```

**Go**

```go
import "github.com/emailit/emailit-go/v2"
client := emailit.NewClient("your_api_key")

meta, err := client.Emails.GetMeta("em_4KYof1ZzXndZE2VPi0DgULiekG8")
```

**Rust**

```rust
use emailit::Emailit;

let emailit = Emailit::new("your_api_key");

let meta = emailit.emails.get_meta("em_4KYof1ZzXndZE2VPi0DgULiekG8").await?;
```

**Java**

```java
import java.net.http.*;
import java.net.URI;

HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
  .uri(URI.create("https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8/meta"))
  .header("Authorization", "Bearer your_api_key")
  .GET()
  .build();
HttpResponse<String> response = client.send(request,
  HttpResponse.BodyHandlers.ofString());
```

**.NET**

```csharp
using Emailit;

var emailit = new EmailitClient("your_api_key");

var meta = emailit.Emails.GetMeta("em_4KYof1ZzXndZE2VPi0DgULiekG8");
```

**Laravel**

```php
use Illuminate\Support\Facades\Http;

$meta = Http::withToken('your_api_key')
  ->get('https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8/meta')
  ->json();
```

**cURL**

```bash
curl https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8/meta \
  -H "Authorization: Bearer $EMAILIT_API_KEY"
```

**200**

```json
{
  "object": "email",
  "id": "em_4KYof1ZzXndZE2VPi0DgULiekG8",
  "type": "outbound",
  "token": "4KDY1iIpQSSW5pAoiz3JEfqcsO0",
  "message_id": "<4KDY1iIpQSSW5pAoiz3JEfqcsO0@acme.com>",
  "from": "Acme Billing <billing@acme.com>",
  "to": "ada@example.com",
  "subject": "Your invoice INV-1042",
  "status": "delivered",
  "size": 48213,
  "scheduled_at": null,
  "created_at": "2026-10-01T09:30:12.482913Z",
  "updated_at": "2026-10-01T09:30:14.118204Z",
  "tracking": {
    "loads": true,
    "clicks": true
  },
  "meta": {
    "invoice_id": "INV-1042"
  },
  "headers": {
    "From": "Acme Billing <billing@acme.com>",
    "To": "ada@example.com",
    "Subject": "Your invoice INV-1042",
    "Message-ID": "<4KDY1iIpQSSW5pAoiz3JEfqcsO0@acme.com>",
    "MIME-Version": "1.0",
    "Content-Type": "multipart/mixed; boundary=\"--_NmP-4f1c2a9e7b3d0e5f-Part_1\""
  },
  "attachments": [
    {
      "filename": "INV-1042.pdf",
      "content_type": "application/pdf",
      "size": 40960,
      "content_id": null,
      "content_disposition": "attachment"
    }
  ]
}
```

**404**

```json
{
  "error": "Email not found",
  "message": "Email with ID 'em_4KYof1ZzXndZE2VPi0DgULiekG8' not found in your workspace"
}
```

---
Fonte: https://emailit.com/pt/docs/api-reference/emails/meta/

## Atualizar um e-mail agendado — POST /emails/{id}

> Altere o horário de envio de um e-mail agendado. Funciona até três minutos antes do horário previsto, e o novo horário deve estar pelo menos três minutos à frente.

# Atualizar um e-mail agendado

Muda um e-mail agendado para um novo horário de envio.

`POST /emails/{id}`

Funciona com chaves de API `sending` e `full`. Você só pode reagendar um e-mail cujo status seja `scheduled` e cujo horário de envio atual esteja a mais de 3 minutos. Apenas o horário de envio pode mudar; para alterar o conteúdo, [cancele](/pt/docs/api-reference/emails/cancel/) o e-mail e envie um novo.

Um envio agendado para vários destinatários cria um e-mail por destinatário. Reagende cada ID do mapa `ids` da [resposta do envio](/pt/docs/api-reference/emails/send/).

## Parâmetros de caminho

- `id` (string, obrigatório): O ID do e-mail agendado.

## Parâmetros do corpo

- `scheduled_at` (string, obrigatório): O novo horário de envio, como uma data e hora ISO 8601, por exemplo `2026-10-03T09:00:00Z`, ou em inglês, por exemplo `tomorrow at 3pm`. Ele deve estar a mais de 3 minutos no futuro.

## Retorno

- `object` (string): Sempre `email`.

- `id` (string): O ID do e-mail.

- `status` (string): Sempre `scheduled`.

- `scheduled_at` (string): O novo horário de envio.

- `updated_at` (string): Quando o e-mail foi atualizado.

- `message` (string): Uma mensagem de confirmação.

Retorna `422` se o e-mail não estiver agendado, se faltarem menos de 3 minutos para o horário previsto ou se o novo horário não puder ser interpretado ou for próximo demais.

**Requisição** `POST /emails/{id}`

**Node.js**

```javascript
import { Emailit } from '@emailit/node';
const emailit = new Emailit('your_api_key');

const email = await emailit.emails.update('em_4K76IA5sFNIsLXW9QC2ro8cDbOj', {
  scheduled_at: '2026-10-03T09:00:00Z',
});
```

**Python**

```python
from emailit import EmailitClient
client = EmailitClient("your_api_key")

email = client.emails.update("em_4K76IA5sFNIsLXW9QC2ro8cDbOj", {
  "scheduled_at": "2026-10-03T09:00:00Z"
})
```

**PHP**

```php
$emailit = Emailit::client('your_api_key');

$email = $emailit->emails()->update('em_4K76IA5sFNIsLXW9QC2ro8cDbOj', [
  'scheduled_at' => '2026-10-03T09:00:00Z',
]);
```

**Ruby**

```ruby
require "emailit"
client = Emailit::EmailitClient.new("your_api_key")

email = client.emails.update("em_4K76IA5sFNIsLXW9QC2ro8cDbOj",
  scheduled_at: "2026-10-03T09:00:00Z"
)
```

**Go**

```go
import "github.com/emailit/emailit-go/v2"
client := emailit.NewClient("your_api_key")

email, err := client.Emails.Update("em_4K76IA5sFNIsLXW9QC2ro8cDbOj", &emailit.UpdateEmailRequest{
  ScheduledAt: "2026-10-03T09:00:00Z",
})
```

**Rust**

```rust
use emailit::Emailit;

let emailit = Emailit::new("your_api_key");

let email = emailit.emails.update("em_4K76IA5sFNIsLXW9QC2ro8cDbOj", emailit::types::UpdateEmailParams {
  scheduled_at: "2026-10-03T09:00:00Z".to_string(),
}).await?;
```

**Java**

```java
import com.emailit.*;
import com.emailit.params.*;

EmailitClient emailit = new EmailitClient("your_api_key");

EmailitObject email = emailit.emails().update("em_4K76IA5sFNIsLXW9QC2ro8cDbOj",
  EmailUpdateParams.builder()
    .setScheduledAt("2026-10-03T09:00:00Z")
    .build()
);
```

**.NET**

```csharp
using Emailit;

var emailit = new EmailitClient("your_api_key");

var email = emailit.Emails.Update("em_4K76IA5sFNIsLXW9QC2ro8cDbOj", new EmailUpdateOptions {
  ScheduledAt = "2026-10-03T09:00:00Z",
});
```

**Laravel**

```php
use Emailit\Laravel\Facades\Emailit;

$email = Emailit::emails()->update('em_4K76IA5sFNIsLXW9QC2ro8cDbOj', [
  'scheduled_at' => '2026-10-03T09:00:00Z',
]);
```

**cURL**

```bash
curl -X POST https://api.emailit.com/v2/emails/em_4K76IA5sFNIsLXW9QC2ro8cDbOj \
  -H "Authorization: Bearer $EMAILIT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"scheduled_at": "2026-10-03T09:00:00Z"}'
```

**cURL**

```bash
curl -X POST https://api.emailit.com/v2/emails/em_4K76IA5sFNIsLXW9QC2ro8cDbOj \
  -H "Authorization: Bearer $EMAILIT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"scheduled_at": "tomorrow at 3pm"}'
```

**200**

```json
{
  "object": "email",
  "id": "em_4K76IA5sFNIsLXW9QC2ro8cDbOj",
  "status": "scheduled",
  "scheduled_at": "2026-10-03T09:00:00.000Z",
  "updated_at": "2026-10-01T10:15:40.207316Z",
  "message": "Email schedule has been updated successfully"
}
```

**404**

```json
{
  "error": "Email not found",
  "message": "Email with ID 'em_4K76IA5sFNIsLXW9QC2ro8cDbOj' not found in your workspace"
}
```

**422 Não agendado**

```json
{
  "error": "Cannot update email",
  "message": "Email cannot be updated. Current status: 'delivered'. Only 'scheduled' emails can be updated."
}
```

**422 Tarde demais**

```json
{
  "error": "Cannot update email",
  "message": "Scheduled emails can only be updated at least 3 minutes before the scheduled time. This email is scheduled to send in 2 minute(s)."
}
```

**422 Horário inválido**

```json
{
  "error": "Invalid scheduled_at",
  "message": "The new scheduled time must be at least 3 minutes in the future."
}
```

---
Fonte: https://emailit.com/pt/docs/api-reference/emails/update/

## Cancelar um e-mail — POST /emails/{id}/cancel

> Cancele um e-mail agendado, aceito ou com falha temporária e remova-o da fila de envio. Em regime de melhor esforço: uma entrega já em andamento ainda pode ser concluída.

# Cancelar um e-mail

Remove um e-mail da fila de envio e define o status dele como `canceled`.

`POST /emails/{id}/cancel`

Funciona com chaves de API `sending` e `full`. O cancelamento é feito em regime de melhor esforço: ele tira o e-mail da fila, mas, se uma tentativa de entrega já tiver começado, essa tentativa ainda pode ser concluída, e só as novas tentativas restantes são interrompidas. A resposta indica qual é o caso em `in_flight`. Cancelar dispara um [evento](/pt/docs/webhooks/event-types/) `email.canceled`, e o crédito não é reembolsado. A ação **Cancel delivery** do painel faz a mesma coisa.

| Status | Pode cancelar | Observações |
| --- | --- | --- |
| `scheduled` | Sim | Até 3 minutos antes do horário agendado. |
| `accepted` | Sim | Na fila e ainda não entregue. |
| `attempted` | Sim | Interrompe as novas tentativas restantes depois de uma falha temporária. |
| Qualquer outro | Não | O e-mail já foi entregue, falhou ou foi cancelado. |

Para cancelar um envio com vários destinatários, cancele cada ID do mapa `ids` da [resposta do envio](/pt/docs/api-reference/emails/send/).

## Parâmetros de caminho

- `id` (string, obrigatório): O ID do e-mail.

## Retorno

- `object` (string): Sempre `email`.

- `id` (string): O ID do e-mail.

- `status` (string): Sempre `canceled`.

- `in_flight` (boolean): `true` se uma tentativa de entrega já pode estar em andamento e ainda pode ser concluída. `false` se o e-mail foi removido da fila antes de qualquer tentativa.

- `message` (string): Uma descrição do resultado.

**Requisição** `POST /emails/{id}/cancel`

**Node.js**

```javascript
import { Emailit } from '@emailit/node';
const emailit = new Emailit('your_api_key');

const email = await emailit.emails.cancel('em_4K76IA5sFNIsLXW9QC2ro8cDbOj');
```

**Python**

```python
from emailit import EmailitClient
client = EmailitClient("your_api_key")

email = client.emails.cancel("em_4K76IA5sFNIsLXW9QC2ro8cDbOj")
```

**PHP**

```php
$emailit = Emailit::client('your_api_key');

$email = $emailit->emails()->cancel('em_4K76IA5sFNIsLXW9QC2ro8cDbOj');
```

**Ruby**

```ruby
require "emailit"
client = Emailit::EmailitClient.new("your_api_key")

email = client.emails.cancel("em_4K76IA5sFNIsLXW9QC2ro8cDbOj")
```

**Go**

```go
import "github.com/emailit/emailit-go/v2"
client := emailit.NewClient("your_api_key")

email, err := client.Emails.Cancel("em_4K76IA5sFNIsLXW9QC2ro8cDbOj")
```

**Rust**

```rust
use emailit::Emailit;

let emailit = Emailit::new("your_api_key");

let email = emailit.emails.cancel("em_4K76IA5sFNIsLXW9QC2ro8cDbOj").await?;
```

**Java**

```java
import com.emailit.*;

EmailitClient emailit = new EmailitClient("your_api_key");

EmailitObject email = emailit.emails().cancel("em_4K76IA5sFNIsLXW9QC2ro8cDbOj");
```

**.NET**

```csharp
using Emailit;

var emailit = new EmailitClient("your_api_key");

var email = emailit.Emails.Cancel("em_4K76IA5sFNIsLXW9QC2ro8cDbOj");
```

**Laravel**

```php
use Emailit\Laravel\Facades\Emailit;

$email = Emailit::emails()->cancel('em_4K76IA5sFNIsLXW9QC2ro8cDbOj');
```

**cURL**

```bash
curl -X POST https://api.emailit.com/v2/emails/em_4K76IA5sFNIsLXW9QC2ro8cDbOj/cancel \
  -H "Authorization: Bearer $EMAILIT_API_KEY"
```

**200**

```json
{
  "object": "email",
  "id": "em_4K76IA5sFNIsLXW9QC2ro8cDbOj",
  "status": "canceled",
  "in_flight": false,
  "message": "Email has been canceled and removed from the send queue."
}
```

**200 Em andamento**

```json
{
  "object": "email",
  "id": "em_4K76IA5sFNIsLXW9QC2ro8cDbOj",
  "status": "canceled",
  "in_flight": true,
  "message": "Email was canceled. The current delivery attempt may still complete; remaining retries were stopped."
}
```

**404**

```json
{
  "error": "Email not found",
  "message": "Email with ID 'em_4K76IA5sFNIsLXW9QC2ro8cDbOj' not found in your workspace"
}
```

**422 Status**

```json
{
  "error": "Cannot cancel email",
  "message": "Email cannot be canceled. Current status: 'delivered'. Only 'scheduled', 'accepted', or 'attempted' emails can be canceled."
}
```

**422 Tarde demais**

```json
{
  "error": "Cannot cancel email",
  "message": "Scheduled emails can only be canceled at least 3 minutes before the scheduled time. This email is scheduled to send in 2 minute(s)."
}
```

---
Fonte: https://emailit.com/pt/docs/api-reference/emails/cancel/

## Tentar enviar um e-mail de novo — POST /emails/{id}/retry

> Envie de novo um e-mail com bounce, com falha, suprimido ou retido como um novo e-mail, com um novo ID. O original não é alterado.

# Tentar enviar um e-mail de novo

Coloca na fila uma cópia de um e-mail que não chegou ao destino. A cópia é um novo e-mail com o próprio ID, e o original mantém o status dele.

`POST /emails/{id}/retry`

Funciona com chaves de API `sending` e `full`. A cópia tem o mesmo remetente, destinatário, assunto, conteúdo, cabeçalhos, `meta` e configurações de rastreamento, com um novo `Message-ID`. Ela custa créditos como um novo envio: um crédito, ou dois para um e-mail de campanha.

Você pode tentar enviar um e-mail de novo quando:

- O status dele é `bounced`, `failed`, `suppressed` ou `held`.
- Ele foi criado nos últimos 30 dias.
- O conteúdo dele não foi apagado pelo seu [período de retenção](/pt/docs/data-retention/), e o domínio de envio dele ainda existe.

Corrija a causa antes. Um endereço suprimido que ainda está na sua [lista de supressão](/pt/docs/suppressions/) é suprimido de novo, e um e-mail [retido](/pt/docs/logs/email-statuses/) é retido de novo até que o motivo da retenção seja resolvido.

## Parâmetros de caminho

- `id` (string, obrigatório): O ID do e-mail a enviar de novo.

## Retorno

- `object` (string): Sempre `email`.

- `id` (string): O ID do novo e-mail.

- `original_id` (string): O ID do e-mail que você tentou enviar de novo.

- `token` (string): O token interno do novo e-mail.

- `message_id` (string): O `Message-ID` do novo e-mail.

- `from` (string): O remetente.

- `to` (string): O destinatário.

- `subject` (string): O assunto.

- `status` (string): Sempre `accepted`.

- `created_at` (string): Quando o novo e-mail foi criado.

- `message` (string): Uma mensagem de confirmação.

**Requisição** `POST /emails/{id}/retry`

**Node.js**

```javascript
import { Emailit } from '@emailit/node';
const emailit = new Emailit('your_api_key');

const email = await emailit.emails.retry('em_4KKrQ7TzsVtzsS8zG069B2aMtoK');
```

**Python**

```python
from emailit import EmailitClient
client = EmailitClient("your_api_key")

email = client.emails.retry("em_4KKrQ7TzsVtzsS8zG069B2aMtoK")
```

**PHP**

```php
$emailit = Emailit::client('your_api_key');

$email = $emailit->emails()->retry('em_4KKrQ7TzsVtzsS8zG069B2aMtoK');
```

**Ruby**

```ruby
require "emailit"
client = Emailit::EmailitClient.new("your_api_key")

email = client.emails.retry("em_4KKrQ7TzsVtzsS8zG069B2aMtoK")
```

**Go**

```go
import "github.com/emailit/emailit-go/v2"
client := emailit.NewClient("your_api_key")

email, err := client.Emails.Retry("em_4KKrQ7TzsVtzsS8zG069B2aMtoK")
```

**Rust**

```rust
use emailit::Emailit;

let emailit = Emailit::new("your_api_key");

let email = emailit.emails.retry("em_4KKrQ7TzsVtzsS8zG069B2aMtoK").await?;
```

**Java**

```java
import com.emailit.*;

EmailitClient emailit = new EmailitClient("your_api_key");

EmailitObject email = emailit.emails().retry("em_4KKrQ7TzsVtzsS8zG069B2aMtoK");
```

**.NET**

```csharp
using Emailit;

var emailit = new EmailitClient("your_api_key");

var email = emailit.Emails.Retry("em_4KKrQ7TzsVtzsS8zG069B2aMtoK");
```

**Laravel**

```php
use Emailit\Laravel\Facades\Emailit;

$email = Emailit::emails()->retry('em_4KKrQ7TzsVtzsS8zG069B2aMtoK');
```

**cURL**

```bash
curl -X POST https://api.emailit.com/v2/emails/em_4KKrQ7TzsVtzsS8zG069B2aMtoK/retry \
  -H "Authorization: Bearer $EMAILIT_API_KEY"
```

**200**

```json
{
  "object": "email",
  "id": "em_4KbeG9poqTmjvQZeN8pMoJkCVNd",
  "original_id": "em_4KKrQ7TzsVtzsS8zG069B2aMtoK",
  "token": "4KTnDU5PzzqDqp8UWb9qVhPVFOT",
  "message_id": "<4KTnDU5PzzqDqp8UWb9qVhPVFOT@acme.com>",
  "from": "Acme <hello@acme.com>",
  "to": "ada@example.com",
  "subject": "Welcome to Acme",
  "status": "accepted",
  "created_at": "2026-10-01T12:04:51.330482Z",
  "message": "Email has been queued for retry"
}
```

**402**

```json
{
  "error": "Insufficient credits",
  "message": "Insufficient credits to retry this email. Required: 1, available: 0."
}
```

**404**

```json
{
  "error": "Email not found",
  "message": "Email with ID 'em_4KKrQ7TzsVtzsS8zG069B2aMtoK' not found in your workspace"
}
```

**422 Status**

```json
{
  "error": "Cannot retry email",
  "message": "Only bounced, failed, suppressed, or held emails can be retried. Current status: 'delivered'"
}
```

**422 Antigo demais**

```json
{
  "error": "Cannot retry email",
  "message": "Emails older than 30 days cannot be retried"
}
```

**422 Apagado**

```json
{
  "error": "Cannot retry email",
  "message": "Email raw content has been purged and can no longer be retried"
}
```

---
Fonte: https://emailit.com/pt/docs/api-reference/emails/retry/

## Encaminhar um e-mail — POST /emails/{id}/forward

> Envie de novo um e-mail enviado para novos destinatários, como um simples reenvio ou com um cabeçalho de mensagem encaminhada e uma observação opcional. Limitado a 3 por hora.

# Encaminhar um e-mail

Envia o conteúdo de um e-mail enviado para novos destinatários como um novo e-mail. O e-mail original não é alterado.

`POST /emails/{id}/forward`

Funciona com chaves de API `sending` e `full`. Por padrão, o encaminhamento é um simples reenvio do HTML, do texto e dos anexos originais. Defina `include_headers` para adicionar um bloco “Forwarded message” e uma observação opcional acima do conteúdo original.

Um encaminhamento é um novo envio, então as regras de [Enviar um e-mail](/pt/docs/api-reference/emails/send/) se aplicam: o endereço `from` deve estar em um domínio de envio verificado, cada destinatário custa um crédito e conta para os [limites de envio](/pt/docs/api-reference/rate-limits/), o rastreamento segue as configurações do domínio, e o cabeçalho `Idempotency-Key` é aceito. Além disso, um workspace pode encaminhar no máximo 3 e-mails por hora.

Apenas e-mails enviados podem ser encaminhados, e apenas enquanto o conteúdo deles é mantido pelo seu [período de retenção](/pt/docs/data-retention/). Para encaminhar e-mails recebidos, use uma [automação](/pt/docs/inbound/forward-with-automations/).

## Parâmetros de caminho

- `id` (string, obrigatório): O ID do e-mail enviado a encaminhar.

## Cabeçalhos

- `Idempotency-Key` (string): Torna seguro tentar o encaminhamento de novo. Consulte [Idempotência](/pt/docs/api-reference/idempotency/).

## Parâmetros do corpo

- `to` (string | string[], obrigatório): Os novos destinatários, como um array ou uma string separada por vírgulas. Até 50.

- `include_headers` (boolean): Quando `true`, adiciona um bloco “Forwarded message” com o remetente, a data, o assunto e o destinatário originais, e a sua observação acima dele. Quando `false`, reenvia o conteúdo original sem alterações.

- `comment` (string): Uma observação em texto simples a colocar acima da mensagem encaminhada. Usada apenas com `include_headers`. `body` é aceito como alias.

- `html` (string): Uma observação em HTML a usar na parte HTML no lugar do `comment` escapado. Usada apenas com `include_headers`.

- `text` (string): Uma observação em texto simples a usar na parte de texto no lugar de `comment`. Usada apenas com `include_headers`.

- `from` (string): O remetente. O padrão é o `from` do e-mail original.

- `subject` (string): O assunto. O padrão é o assunto original ou, com `include_headers`, `Fwd: ` seguido do assunto original.

Os anexos originais são incluídos quando o tipo de arquivo deles é [permitido](/pt/docs/api-reference/emails/send/#attachment-object).

## Retorno

Retorna o mesmo objeto de [Enviar um e-mail](/pt/docs/api-reference/emails/send/), com dois campos extras:

- `original_id` (string): O ID do e-mail que você encaminhou.

- `message` (string): Uma mensagem de confirmação.

Acima do limite de encaminhamentos, a API retorna `429` com um cabeçalho `retry-after`.

**Requisição** `POST /emails/{id}/forward`

**Node.js**

```javascript
import { Emailit } from '@emailit/node';
const emailit = new Emailit('your_api_key');

const email = await emailit.emails.forward('em_4KYof1ZzXndZE2VPi0DgULiekG8', {
  to: 'grace@example.com',
});
```

**Python**

```python
from emailit import EmailitClient
client = EmailitClient("your_api_key")

email = client.emails.forward("em_4KYof1ZzXndZE2VPi0DgULiekG8", {
  "to": "grace@example.com",
})
```

**PHP**

```php
$emailit = Emailit::client('your_api_key');

$email = $emailit->emails()->forward('em_4KYof1ZzXndZE2VPi0DgULiekG8', [
  'to' => 'grace@example.com',
]);
```

**Ruby**

```ruby
require "emailit"
client = Emailit::EmailitClient.new("your_api_key")

email = client.emails.forward("em_4KYof1ZzXndZE2VPi0DgULiekG8", {
  to: "grace@example.com"
})
```

**Go**

```go
import "github.com/emailit/emailit-go/v2"
client := emailit.NewClient("your_api_key")

email, err := client.Emails.Forward("em_4KYof1ZzXndZE2VPi0DgULiekG8", emailit.ForwardEmailRequest{
  To: "grace@example.com",
})
```

**Rust**

```rust
use emailit::Emailit;

let emailit = Emailit::new("your_api_key");

let email = emailit.emails.forward("em_4KYof1ZzXndZE2VPi0DgULiekG8", ForwardEmail {
    to: "grace@example.com".into(),
    ..Default::default()
}).await?;
```

**Java**

```java
import com.emailit.*;

EmailitClient emailit = new EmailitClient("your_api_key");

EmailitObject email = emailit.emails().forward("em_4KYof1ZzXndZE2VPi0DgULiekG8", Map.of(
  "to", "grace@example.com"
));
```

**.NET**

```csharp
using Emailit;

var emailit = new EmailitClient("your_api_key");

var email = emailit.Emails.Forward("em_4KYof1ZzXndZE2VPi0DgULiekG8", new ForwardEmailRequest {
  To = "grace@example.com"
});
```

**Laravel**

```php
use Emailit\Laravel\Facades\Emailit;

$email = Emailit::emails()->forward('em_4KYof1ZzXndZE2VPi0DgULiekG8', [
  'to' => 'grace@example.com',
]);
```

**cURL**

```bash
curl -X POST https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8/forward \
  -H "Authorization: Bearer $EMAILIT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "to": "grace@example.com"
  }'
```

**cURL**

```bash
curl -X POST https://api.emailit.com/v2/emails/em_4KYof1ZzXndZE2VPi0DgULiekG8/forward \
  -H "Authorization: Bearer $EMAILIT_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: fwd-inv-1042-grace" \
  -d '{
    "to": ["grace@example.com"],
    "include_headers": true,
    "comment": "Grace, here is the invoice Ada asked about."
  }'
```

**Node.js**

```javascript
const email = await emailit.emails.forward('em_4KYof1ZzXndZE2VPi0DgULiekG8', {
  to: ['grace@example.com'],
  include_headers: true,
  comment: 'Grace, here is the invoice Ada asked about.',
});
```

**Python**

```python
email = client.emails.forward("em_4KYof1ZzXndZE2VPi0DgULiekG8", {
  "to": ["grace@example.com"],
  "include_headers": True,
  "comment": "Grace, here is the invoice Ada asked about."
})
```

**200**

```json
{
  "object": "email",
  "id": "em_4K76IA5sFNIsLXW9QC2ro8cDbOj",
  "original_id": "em_4KYof1ZzXndZE2VPi0DgULiekG8",
  "token": "4KWzEED2cnej6UMjF4v508VqQIp",
  "message_id": "<4KWzEED2cnej6UMjF4v508VqQIp@acme.com>",
  "from": "Acme Billing <billing@acme.com>",
  "to": ["grace@example.com"],
  "subject": "Fwd: Your invoice INV-1042",
  "status": "accepted",
  "scheduled_at": null,
  "created_at": "2026-10-01T13:20:07.915203Z",
  "tracking": {
    "loads": true,
    "clicks": true
  },
  "message": "Email has been queued for forwarding"
}
```

**400**

```json
{
  "error": "Validation failed",
  "validation_errors": ["Invalid to email address at index 0: grace@example"]
}
```

**404**

```json
{
  "error": "Email not found",
  "message": "Email with ID 'em_4KYof1ZzXndZE2VPi0DgULiekG8' not found in your workspace"
}
```

**422 Recebido**

```json
{
  "error": "Cannot forward email",
  "message": "Only outgoing emails can be forwarded"
}
```

**422 Apagado**

```json
{
  "error": "Cannot forward email",
  "message": "Email raw content has been purged and can no longer be forwarded"
}
```

**429**

```json
{
  "error": "too_many_requests",
  "message": "Forwarding is limited to 3 emails per hour for this workspace. Try again later.",
  "limit": 3,
  "current": 4,
  "retry_after": 2711
}
```

---
Fonte: https://emailit.com/pt/docs/api-reference/emails/forward/

## Obter apenas o status — GET /email/{id}

> Obtenha apenas o status de entrega atual de um e-mail pelo ID, sem cabeçalhos, conteúdo nem metadados, para verificações de status leves.

# Obter apenas o status

Retorna apenas o status atual de um e-mail.

`GET /email/{id}`

Requer uma chave de API com escopo `full`. Observe o singular `/email` no caminho. A resposta é pequena, o que torna este endpoint prático para verificações rápidas de status. Para receber as mudanças de status à medida que acontecem, use [webhooks](/pt/docs/webhooks/) em vez de consultar periodicamente.

## Parâmetros de caminho

- `id` (string, obrigatório): O ID do e-mail.

## Retorno

- `status` (string): O status atual: `accepted`, `scheduled`, `delivered`, `loaded`, `clicked`, `attempted`, `bounced`, `failed`, `rejected`, `suppressed`, `received`, `complained`, `canceled` ou `held`. Consulte [Status de e-mail](/pt/docs/logs/email-statuses/).

**Requisição** `GET /email/{id}`

**Node.js**

```javascript
const response = await fetch('https://api.emailit.com/v2/email/em_4KYof1ZzXndZE2VPi0DgULiekG8', {
  headers: { Authorization: 'Bearer your_api_key' },
});
const { status } = await response.json();
```

**Python**

```python
import requests

response = requests.get(
  "https://api.emailit.com/v2/email/em_4KYof1ZzXndZE2VPi0DgULiekG8",
  headers={"Authorization": "Bearer your_api_key"}
)
status = response.json()["status"]
```

**PHP**

```php
$ch = curl_init('https://api.emailit.com/v2/email/em_4KYof1ZzXndZE2VPi0DgULiekG8');
curl_setopt_array($ch, [
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_HTTPHEADER => [
    'Authorization: Bearer your_api_key',
  ],
]);
$status = json_decode(curl_exec($ch), true)['status'];
curl_close($ch);
```

**Ruby**

```ruby
require "net/http"
require "json"

uri = URI("https://api.emailit.com/v2/email/em_4KYof1ZzXndZE2VPi0DgULiekG8")
req = Net::HTTP::Get.new(uri)
req["Authorization"] = "Bearer your_api_key"
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
status = JSON.parse(http.request(req).body)["status"]
```

**Go**

```go
req, _ := http.NewRequest("GET", "https://api.emailit.com/v2/email/em_4KYof1ZzXndZE2VPi0DgULiekG8", nil)
req.Header.Set("Authorization", "Bearer your_api_key")

resp, err := http.DefaultClient.Do(req)
if err != nil {
  return err
}
defer resp.Body.Close()

var result struct {
  Status string `json:"status"`
}
err = json.NewDecoder(resp.Body).Decode(&result)
```

**Rust**

```rust
let response: serde_json::Value = reqwest::Client::new()
    .get("https://api.emailit.com/v2/email/em_4KYof1ZzXndZE2VPi0DgULiekG8")
    .bearer_auth("your_api_key")
    .send()
    .await?
    .json()
    .await?;
let status = response["status"].as_str();
```

**Java**

```java
import java.net.http.*;
import java.net.URI;

HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
  .uri(URI.create("https://api.emailit.com/v2/email/em_4KYof1ZzXndZE2VPi0DgULiekG8"))
  .header("Authorization", "Bearer your_api_key")
  .GET()
  .build();
HttpResponse<String> response = client.send(request,
  HttpResponse.BodyHandlers.ofString());
```

**.NET**

```csharp
using System.Net.Http.Headers;
using System.Net.Http.Json;

var http = new HttpClient();
http.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", "your_api_key");

var result = await http.GetFromJsonAsync<Dictionary<string, string>>(
  "https://api.emailit.com/v2/email/em_4KYof1ZzXndZE2VPi0DgULiekG8");
var status = result["status"];
```

**Laravel**

```php
use Illuminate\Support\Facades\Http;

$status = Http::withToken('your_api_key')
  ->get('https://api.emailit.com/v2/email/em_4KYof1ZzXndZE2VPi0DgULiekG8')
  ->json('status');
```

**cURL**

```bash
curl https://api.emailit.com/v2/email/em_4KYof1ZzXndZE2VPi0DgULiekG8 \
  -H "Authorization: Bearer $EMAILIT_API_KEY"
```

**200**

```json
{
  "status": "delivered"
}
```

**404**

```json
{
  "error": "Email not found",
  "message": "Email with ID 'em_4KYof1ZzXndZE2VPi0DgULiekG8' not found in your workspace"
}
```

---
Fonte: https://emailit.com/pt/docs/api-reference/emails/status/