# Emails API

> Envía emails, consulta los mensajes y su contenido, y prográmalos, cancélalos, reinténtalos o reenvíalos.

URL base: `https://api.emailit.com/v2`. Autentícate con `Authorization: Bearer <API key>`.

## Enviar un email — POST /emails

> Envía un email a uno o varios destinatarios con HTML o texto, una plantilla, adjuntos, cabeceras personalizadas, metadatos, programación y seguimiento.

# Enviar un email

Envía un email desde un dominio de envío verificado. Cada destinatario recibe una copia independiente con su propio ID de email, y cada destinatario cuesta un crédito.

`POST /emails`

Funciona con claves de API `sending` y `full`. Los envíos cuentan para los [límites de envío](/es/docs/api-reference/rate-limits/) del espacio de trabajo, y una respuesta correcta significa que el email se ha aceptado y puesto en cola, no que se haya entregado. Sigue la entrega con [webhooks](/es/docs/webhooks/) o con [Obtener un email](/es/docs/api-reference/emails/get/). Los espacios de trabajo sin verificar solo pueden enviar a las direcciones de email de las cuentas de sus miembros.

## Cabeceras

- `Idempotency-Key` (string): Una clave única de hasta 256 letras, dígitos, `-` y `_`. Un reintento con la misma clave en un plazo de 24 horas devuelve la primera respuesta en lugar de volver a enviar el email. Consulta [Idempotencia](/es/docs/api-reference/idempotency/).

## Parámetros del cuerpo

- `from` (string, obligatorio): El remitente, como `hello@acme.com` o `Acme <hello@acme.com>`. La dirección debe pertenecer a un dominio de envío verificado del espacio de trabajo, y al dominio de la clave si la clave está [limitada a un dominio](/es/docs/api-reference/authentication/#restrict-a-key-to-one-domain).

- `to` (string | string[], obligatorio): Los destinatarios, como array o como cadena separada por comas. Cada entrada puede ser `ada@example.com` o `Ada Lovelace <ada@example.com>`. Hasta 50.

- `cc` (string | string[]): Los destinatarios en copia. Hasta 50.

- `bcc` (string | string[]): Los destinatarios en copia oculta. Hasta 50. No aparecen en las cabeceras del mensaje.

- `reply_to` (string | string[]): Las direcciones para las respuestas. Si envías con una plantilla y omites este campo, se usa la dirección de respuesta de la plantilla.

- `subject` (string): La línea de asunto. Obligatorio, salvo que lo aporte `template`.

- `html` (string): El cuerpo HTML. Necesitas `html`, `text` o ambos, salvo que `template` aporte el contenido.

- `text` (string): El cuerpo en texto plano. Si envías `html` y `text`, los destinatarios reciben un mensaje multiparte.

- `template` (string): Una plantilla que enviar. Pasa un ID de plantilla (`tem_…`) para usar exactamente esa versión, o un alias para usar su versión publicada. `subject`, `html` y `text` en la petición sustituyen a los de la plantilla. Consulta [Plantillas](/es/docs/templates/).

- `variables` (object): Los valores de los marcadores de [Temple](/es/docs/templates/temple/), como `{{first_name}}`, que se renderizan en el asunto, el HTML y el texto. Funciona con plantillas y con contenido en línea.

- `attachments` (object[]): Los archivos que se adjuntan. Consulta [Objeto de adjunto](#attachment-object) más abajo.

- `headers` (object): Cabeceras MIME adicionales como pares nombre–valor, por ejemplo `{"List-Unsubscribe": "<https://acme.com/unsubscribe>"}`. Emailit asigna `Message-ID` por su cuenta.

- `meta` (object): Tus propios datos clave–valor, por ejemplo `{"order_id": "1042"}`. Los valores deben ser cadenas. Se guardan con el email y se incluyen en las lecturas y en los payloads de los webhooks.

- `scheduled_at` (string): Cuándo enviar, como fecha y hora ISO 8601, por ejemplo `2026-10-02T09:00:00Z`, o en inglés, como `tomorrow at 9am`. Incluye una zona horaria en los valores ISO 8601. Una hora en el pasado, o un valor que no se puede interpretar (incluida una marca de tiempo Unix), envía el email de inmediato. Los emails programados tienen el estado `scheduled` hasta que se envían.

- `tracking` (boolean | object): Activa o desactiva el seguimiento de aperturas y de clics de este email: `true`, `false` o `{"loads": true, "clicks": false}`. Por defecto, se usa la configuración del dominio de envío. El seguimiento solo funciona si el [CNAME de seguimiento](/es/docs/tracking/custom-tracking-domain/) del dominio está verificado; si no, está desactivado y la respuesta muestra `false`.

### Objeto de adjunto

- `filename` (string, obligatorio): El nombre del archivo, con una extensión permitida (consulta más abajo).

- `content` (string): El archivo, codificado en Base64. Envía `content` o `url`, no ambos.

- `url` (string): Una URL pública `http` o `https` desde la que descargar el archivo. Emailit la descarga al enviar: la descarga debe terminar en 30 segundos, ocupar como máximo 25 MB y no puede redirigir.

- `content_type` (string): El tipo MIME, como `application/pdf`. Obligatorio con `content`. Con `url`, por defecto se usa el tipo que devuelve el servidor.

- `content_id` (string): Convierte el adjunto en un adjunto en línea. Haz referencia a él en el HTML como `<img src="cid:logo">` cuando `content_id` es `logo`.

- `encoding` (string): La codificación de `content`, como `base64` o `hex`.

El mensaje completo, adjuntos incluidos, puede ocupar hasta 40 MB. Se permiten estos tipos de archivo:

| Categoría | Extensiones |
| --- | --- |
| Texto | `.txt`, `.csv`, `.log`, `.css`, `.ics`, `.xml` |
| Imágenes | `.jpg`, `.jpe`, `.jpeg`, `.gif`, `.png`, `.bmp`, `.psd`, `.tif`, `.tiff`, `.svg`, `.indd`, `.ai`, `.eps` |
| Documentos | `.doc`, `.docx`, `.rtf`, `.odt`, `.ott`, `.pdf`, `.pub`, `.pages`, `.mobi`, `.epub` |
| Audio | `.mp3`, `.m4a`, `.m4v`, `.wma`, `.ogg`, `.flac`, `.wav`, `.aif`, `.aifc`, `.aiff` |
| Vídeo | `.mp4`, `.mov`, `.avi`, `.mkv`, `.mpeg`, `.mpg`, `.wmv` |
| Hojas de cálculo | `.xls`, `.xlsx`, `.ods`, `.numbers` |
| Presentaciones | `.odp`, `.ppt`, `.pptx`, `.pps`, `.key` |
| Archivos comprimidos | `.zip`, `.vcf` |
| Email | `.eml` |
| Criptografía | `.p7c`, `.p7m`, `.p7s`, `.pgp`, `.asc`, `.sig` |

## Devuelve

Devuelve `200` con el objeto de email del primer destinatario. Si el mensaje tiene más de un destinatario entre `to`, `cc` y `bcc`, `ids` relaciona cada destinatario con el ID de su copia. Cada copia dispara un evento [`email.accepted`](/es/docs/webhooks/events/email/accepted/) o [`email.scheduled`](/es/docs/webhooks/events/email/scheduled/).

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

- `id` (string): El ID del email del primer destinatario.

- `ids` (object): La dirección de cada destinatario asociada al ID de su email. Solo aparece con más de un destinatario.

- `token` (string): El token interno del primer email.

- `message_id` (string): La cabecera `Message-ID` del primer email, como `<token@acme.com>`.

- `from` (string): El remitente, tal como lo enviaste.

- `to` (string[]): Las direcciones de `to`, sin nombres visibles ni duplicados.

- `cc` (string[]): Los destinatarios de `cc`. Solo aparece si los enviaste.

- `bcc` (string[]): Los destinatarios de `bcc`. Solo aparece si los enviaste.

- `subject` (string): El asunto, después de renderizar la plantilla y las variables.

- `status` (string): `accepted`, o `scheduled` si `scheduled_at` es una fecha futura.

- `scheduled_at` (string | null): Cuándo se enviará el email, o `null`.

- `created_at` (string): Cuándo se aceptó el email.

- `tracking` (object): El seguimiento que se aplica: los booleanos `loads` y `clicks`.

**Petición** `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 Programado**

```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 Sin verificar**

```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 Dominio**

```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
}
```

---
Fuente: https://emailit.com/es/docs/api-reference/emails/send/

## Listar emails — GET /emails

> Lista los emails salientes o entrantes de un espacio de trabajo, del más reciente al más antiguo, con búsqueda, filtros, ordenación y una ventana por defecto de 14 días.

# Listar emails

Devuelve una página de emails, del más reciente al más antiguo. Por defecto, la lista muestra los emails salientes de los últimos 14 días.

`GET /emails`

Requiere una clave de API `full`. Cada destinatario de un envío es un email independiente en esta lista.

## Parámetros de consulta

- `page` (integer): La página que se devuelve.

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

- `type` (string): `outbound` para los emails que enviaste, o `inbound` para los emails que [recibiste](/es/docs/inbound/).

- `date_from` (string): Solo los emails creados en esta fecha o después, como `2026-08-01` (desde las 00:00 UTC). Sin este parámetro, la lista empieza hace 14 días. Los filtros `created_at` no cambian esta ventana.

- `date_to` (string): Solo los emails creados en esta fecha o antes, hasta las 23:59:59 UTC.

- `search` (string): Búsqueda en el destinatario, el remitente o el asunto, sin distinguir mayúsculas y minúsculas.

- `match` (string): `all` u `or`. Cómo se combinan los filtros que se indican abajo.

- `order` (string): Una clave de ordenación de la tabla de abajo.

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

## Filtros

Añade filtros con el formato `key.condition=value`, por ejemplo `status.exact=bounced` o `created_at.after=2026-09-01`. Para conocer las condiciones de cada tipo, consulta [Filtrado](/es/docs/api-reference/filtering/).

| Clave | Tipo | Valores y notas |
| --- | --- | --- |
| `to` | cadena | Dirección del destinatario. |
| `from` | cadena | Remitente tal como se envió, incluido el nombre visible, si lo hay. |
| `subject` | cadena | |
| `status` | enumeración | `accepted`, `scheduled`, `delivered`, `loaded`, `clicked`, `attempted`, `bounced`, `failed`, `rejected`, `suppressed`, `received`, `complained`, `canceled`, `held` |
| `tag` | cadena | La etiqueta del email. Por ahora, los envíos por la API o por SMTP no asignan ninguna etiqueta. |
| `spam_score` | número | |
| `created_at` | fecha | |
| `updated_at` | fecha | |
| `api_key_id` | cadena | El ID de la clave de API que envió el email (`key_…`). |
| `sending_domain_id` | cadena | El ID del dominio de envío (`dom_…`). |

Todas las claves de filtro son también claves de ordenación. Los parámetros de consulta antiguos `status`, `rcpt_to`, `mail_from`, `subject`, `api_key_id` y `sending_domain_id` siguen funcionando: `status` busca coincidencias exactas, y los parámetros de dirección y de asunto, coincidencias parciales.

## Devuelve

Devuelve un array `data` de objetos de email con `next_page_url` y `previous_page_url`. Consulta [Paginación](/es/docs/api-reference/pagination/). Las URL de página no incluyen tus filtros, así que pide la página siguiente con tus propios parámetros y `page` aumentado en uno.

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

- `id` (string): El ID del email.

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

- `from` (string): El remitente tal como se envió.

- `to` (string): El destinatario de esta copia.

- `subject` (string): El asunto.

- `status` (string): El [estado](/es/docs/logs/email-statuses/) actual.

- `size` (integer): El tamaño del mensaje, en bytes.

- `scheduled_at` (string | null): Cuándo toca enviar un email programado, o `null`.

- `created_at` (string): Cuándo se aceptó o se recibió el email.

- `updated_at` (string): Cuándo cambió el estado por última vez.

- `meta` (object | null): Los `meta` que enviaste.

**Petición** `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"
    }
  ]
}
```

---
Fuente: https://emailit.com/es/docs/api-reference/emails/list/

## Obtener un email — GET /emails/{id}

> Obtén un email saliente o entrante por su ID con su estado, sus cabeceras, el cuerpo HTML y de texto ya analizado, los metadatos y los adjuntos.

# Obtener un email

Obtiene un email con su estado, las cabeceras analizadas, el cuerpo HTML y de texto, y los adjuntos.

`GET /emails/{id}`

Requiere una clave de API `full`. El contenido del mensaje se conserva durante el [periodo de retención](/es/docs/data-retention/) de contenido de tu plan. Después, `headers`, `body` y `attachments` quedan vacíos, y se conservan el estado y los metadatos. Para obtener solo una parte de un email, usa [Obtener el cuerpo](/es/docs/api-reference/emails/body/), [Obtener los metadatos](/es/docs/api-reference/emails/meta/), [Listar adjuntos](/es/docs/api-reference/emails/attachments/) u [Obtener el MIME en bruto](/es/docs/api-reference/emails/raw/).

## Parámetros de ruta

- `id` (string, obligatorio): El ID del email, como `em_4KYof1ZzXndZE2VPi0DgULiekG8`.

## Devuelve

Devuelve el objeto de email.

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

- `id` (string): El ID del email.

- `type` (string): `outbound` para los emails que enviaste, `inbound` para los emails que recibiste.

- `token` (string): El token interno del email.

- `message_id` (string): La cabecera `Message-ID`.

- `from` (string): El remitente tal como se envió, como `Acme <hello@acme.com>`.

- `to` (string): El destinatario de esta copia.

- `subject` (string): El asunto.

- `status` (string): El estado actual: `accepted`, `scheduled`, `delivered`, `loaded`, `clicked`, `attempted`, `bounced`, `failed`, `rejected`, `suppressed`, `received`, `complained`, `canceled` o `held`. Consulta [Estados de los emails](/es/docs/logs/email-statuses/).

- `size` (integer): El tamaño del mensaje, en bytes.

- `scheduled_at` (string | null): Cuándo toca enviar un email programado, o `null`.

- `created_at` (string): Cuándo se aceptó o se recibió el email.

- `updated_at` (string): Cuándo cambió el email por última vez.

- `tracking` (object): Solo en los salientes. Si el seguimiento de aperturas (`loads`) y de clics (`clicks`) está activado.

- `meta` (object | null): Los `meta` que enviaste, o `null`.

- `headers` (object | null): Las cabeceras del mensaje como pares nombre–valor, o `null` una vez purgado el contenido.

- `body` (object): `text` y `html`, cada uno una cadena o `null`.

- `attachments` (object[]): Los adjuntos, cada uno con `filename`, `content_type`, `size` en bytes, `content_id` (en los archivos en línea), `content_disposition` (`attachment` o `inline`) y `content` (Base64).

**Petición** `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 Saliente**

```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 Entrante**

```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"
}
```

---
Fuente: https://emailit.com/es/docs/api-reference/emails/get/

## Obtener el MIME en bruto — GET /emails/{id}/raw

> Obtén el código fuente MIME completo y en bruto de un email, con sus cabeceras, junto con el estado y los metadatos del email.

# Obtener el MIME en bruto

Obtiene el código fuente MIME completo de un email tal como lo almacena Emailit, junto con sus metadatos.

`GET /emails/{id}/raw`

Requiere una clave de API `full`. Úsalo para archivar un mensaje, depurar su estructura o analizarlo con tu propia biblioteca MIME. Cuando termina el [periodo de retención](/es/docs/data-retention/) del contenido, `raw` y `headers` son `null`.

## Parámetros de ruta

- `id` (string, obligatorio): El ID del email.

## Devuelve

Devuelve los metadatos del email, como en [Obtener los metadatos](/es/docs/api-reference/emails/meta/) pero sin `attachments`, además del mensaje en bruto.

- `raw` (string | null): El mensaje MIME completo: las cabeceras, una línea en blanco y el cuerpo. `null` una vez purgado el contenido.

- `headers` (object | null): Las cabeceras de nivel superior como pares nombre–valor.

Los demás campos (`object`, `id`, `type`, `token`, `message_id`, `from`, `to`, `subject`, `status`, `size`, `scheduled_at`, `created_at`, `updated_at`, `tracking` y `meta`) son los mismos que en [Obtener un email](/es/docs/api-reference/emails/get/).

**Petición** `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"
}
```

---
Fuente: https://emailit.com/es/docs/api-reference/emails/raw/

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

> Lista los adjuntos de un email con sus nombres de archivo, tipos MIME, tamaños, ID de contenido en línea y contenido codificado en Base64.

# Listar adjuntos

Devuelve los adjuntos de un email, incluido su contenido.

`GET /emails/{id}/attachments`

Requiere una clave de API `full`. Funciona con emails salientes y entrantes. Incluye las imágenes en línea (partes con un `Content-ID`). Para obtener la lista sin el contenido de los archivos, usa [Obtener los metadatos](/es/docs/api-reference/emails/meta/). Cuando termina el [periodo de retención](/es/docs/data-retention/) del contenido, la lista está vacía.

## Parámetros de ruta

- `id` (string, obligatorio): El ID del email.

## Devuelve

Devuelve un objeto de lista con todos los adjuntos. La lista no está paginada.

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

- `data` (object[]): Los adjuntos.

- `data[].filename` (string): El nombre del archivo.

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

- `data[].size` (integer): El tamaño del archivo decodificado, en bytes.

- `data[].content_id` (string | null): El `Content-ID` de un adjunto en línea, o `null`.

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

- `data[].content` (string): El archivo, codificado en Base64.

**Petición** `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"
}
```

---
Fuente: https://emailit.com/es/docs/api-reference/emails/attachments/

## Obtener el cuerpo — GET /emails/{id}/body

> Obtén solo el cuerpo HTML y de texto plano ya analizado de un email, sin cabeceras, metadatos ni adjuntos.

# Obtener el cuerpo

Devuelve el cuerpo HTML y de texto plano de un email, decodificado a partir de sus partes MIME.

`GET /emails/{id}/body`

Requiere una clave de API `full`. Funciona con emails salientes y entrantes. En los emails salientes, el cuerpo es lo que se envió, después de renderizar la plantilla y las variables. Cuando termina el [periodo de retención](/es/docs/data-retention/) del contenido, los dos campos son `null`.

## Parámetros de ruta

- `id` (string, obligatorio): El ID del email.

## Devuelve

- `text` (string | null): La parte de texto plano, o `null` si el email no tiene.

- `html` (string | null): La parte HTML, o `null` si el email no tiene.

**Petición** `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"
}
```

---
Fuente: https://emailit.com/es/docs/api-reference/emails/body/

## Obtener los metadatos — GET /emails/{id}/meta

> Obtén el estado, las cabeceras, los metadatos y la lista de adjuntos de un email sin descargar el cuerpo del mensaje ni el contenido de los adjuntos.

# Obtener los metadatos

Obtiene un email sin su cuerpo: el estado, las cabeceras, tus datos `meta` y la lista de adjuntos sin su contenido.

`GET /emails/{id}/meta`

Requiere una clave de API `full`. Es la forma más ligera de consultar los detalles de un email cuando no necesitas el contenido.

## Parámetros de ruta

- `id` (string, obligatorio): El ID del email.

## Devuelve

Devuelve los mismos campos que [Obtener un email](/es/docs/api-reference/emails/get/), sin `body`, y con `attachments` descritos pero sin su contenido:

- `attachments` (object[]): El `filename`, `content_type`, `size`, `content_id` y `content_disposition` de cada adjunto. Sin `content`.

- `headers` (object | null): Las cabeceras del mensaje como pares nombre–valor, o `null` una vez purgado el contenido.

- `meta` (object | null): Los `meta` que enviaste con el email.

**Petición** `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"
}
```

---
Fuente: https://emailit.com/es/docs/api-reference/emails/meta/

## Actualizar un email programado — POST /emails/{id}

> Cambia la hora de envío de un email programado. Funciona hasta tres minutos antes de la hora prevista, y la hora nueva debe ser al menos tres minutos posterior a la actual.

# Actualizar un email programado

Traslada un email programado a una nueva hora de envío.

`POST /emails/{id}`

Funciona con claves de API `sending` y `full`. Solo puedes reprogramar un email cuyo estado sea `scheduled` y cuya hora de envío actual quede a más de 3 minutos. Solo se puede cambiar la hora de envío; para cambiar el contenido, [cancela](/es/docs/api-reference/emails/cancel/) el email y envía uno nuevo.

Un envío programado a varios destinatarios crea un email por destinatario. Reprograma cada ID del mapa `ids` de la [respuesta del envío](/es/docs/api-reference/emails/send/).

## Parámetros de ruta

- `id` (string, obligatorio): El ID del email programado.

## Parámetros del cuerpo

- `scheduled_at` (string, obligatorio): La nueva hora de envío, como fecha y hora ISO 8601, por ejemplo `2026-10-03T09:00:00Z`, o en inglés, como `tomorrow at 3pm`. Debe quedar a más de 3 minutos en el futuro.

## Devuelve

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

- `id` (string): El ID del email.

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

- `scheduled_at` (string): La nueva hora de envío.

- `updated_at` (string): Cuándo se actualizó el email.

- `message` (string): Un mensaje de confirmación.

Devuelve `422` si el email no está programado, si faltan menos de 3 minutos para su envío, o si la hora nueva no se puede interpretar o está demasiado próxima.

**Petición** `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 No programado**

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

**422 Demasiado tarde**

```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 Hora no válida**

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

---
Fuente: https://emailit.com/es/docs/api-reference/emails/update/

## Cancelar un email — POST /emails/{id}/cancel

> Cancela un email programado, aceptado o con un fallo temporal y quítalo de la cola de envío. Sin garantía: una entrega que ya esté en curso puede completarse.

# Cancelar un email

Quita un email de la cola de envío y cambia su estado a `canceled`.

`POST /emails/{id}/cancel`

Funciona con claves de API `sending` y `full`. La cancelación se hace sin garantía: saca el email de la cola, pero si ya ha empezado un intento de entrega, ese intento puede completarse y solo se detienen los reintentos restantes. La respuesta indica en `in_flight` cuál es el caso. Al cancelar se dispara un [evento](/es/docs/webhooks/event-types/) `email.canceled`, y el crédito no se reembolsa. La acción **Cancel delivery** del panel hace lo mismo.

| Estado | Se puede cancelar | Notas |
| --- | --- | --- |
| `scheduled` | Sí | Hasta 3 minutos antes de la hora programada. |
| `accepted` | Sí | En cola y aún sin entregar. |
| `attempted` | Sí | Detiene los reintentos restantes tras un fallo temporal. |
| Cualquier otro | No | El email ya se entregó, falló o se canceló. |

Para cancelar un envío con varios destinatarios, cancela cada ID del mapa `ids` de la [respuesta del envío](/es/docs/api-reference/emails/send/).

## Parámetros de ruta

- `id` (string, obligatorio): El ID del email.

## Devuelve

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

- `id` (string): El ID del email.

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

- `in_flight` (boolean): `true` si puede que ya haya un intento de entrega en marcha y que aún se complete. `false` si el email se quitó de la cola antes de cualquier intento.

- `message` (string): Una descripción del resultado.

**Petición** `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 En curso**

```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 Estado**

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

**422 Demasiado tarde**

```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)."
}
```

---
Fuente: https://emailit.com/es/docs/api-reference/emails/cancel/

## Reintentar un email — POST /emails/{id}/retry

> Vuelve a enviar un email rebotado, fallido, bloqueado o retenido como un email nuevo con un ID nuevo. El original no cambia.

# Reintentar un email

Pone en cola una copia de un email que no llegó a su destino. La copia es un email nuevo con su propio ID, y el original conserva su estado.

`POST /emails/{id}/retry`

Funciona con claves de API `sending` y `full`. La copia tiene el mismo remitente, destinatario, asunto, contenido, cabeceras, `meta` y configuración de seguimiento, con un `Message-ID` nuevo. Cuesta créditos como un envío nuevo: un crédito, o dos si es un email de campaña.

Puedes reintentar un email cuando:

- Su estado es `bounced`, `failed`, `suppressed` o `held`.
- Se creó en los últimos 30 días.
- Tu [periodo de retención](/es/docs/data-retention/) no ha purgado su contenido y su dominio de envío sigue existiendo.

Soluciona antes la causa. Una dirección bloqueada que sigue en tu [lista de direcciones bloqueadas](/es/docs/suppressions/) se vuelve a bloquear, y un email [retenido](/es/docs/logs/email-statuses/) se vuelve a retener hasta que se resuelva el motivo por el que se retuvo.

## Parámetros de ruta

- `id` (string, obligatorio): El ID del email que quieres reintentar.

## Devuelve

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

- `id` (string): El ID del email nuevo.

- `original_id` (string): El ID del email que has reintentado.

- `token` (string): El token interno del email nuevo.

- `message_id` (string): El `Message-ID` del email nuevo.

- `from` (string): El remitente.

- `to` (string): El destinatario.

- `subject` (string): El asunto.

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

- `created_at` (string): Cuándo se creó el email nuevo.

- `message` (string): Un mensaje de confirmación.

**Petición** `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 Estado**

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

**422 Demasiado antiguo**

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

**422 Purgado**

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

---
Fuente: https://emailit.com/es/docs/api-reference/emails/retry/

## Reenviar un email — POST /emails/{id}/forward

> Vuelve a enviar un email saliente a nuevos destinatarios, como un simple nuevo envío o con una cabecera de mensaje reenviado y una nota opcional. Limitado a 3 por hora.

# Reenviar un email

Envía el contenido de un email saliente a nuevos destinatarios como un email nuevo. El email original no cambia.

`POST /emails/{id}/forward`

Funciona con claves de API `sending` y `full`. Por defecto, el reenvío es un simple nuevo envío del HTML, el texto y los adjuntos originales. Activa `include_headers` para añadir un bloque «Forwarded message» y una nota opcional encima del contenido original.

Un reenvío es un envío nuevo, así que se aplican las reglas de [Enviar un email](/es/docs/api-reference/emails/send/): la dirección `from` debe pertenecer a un dominio de envío verificado, cada destinatario cuesta un crédito y cuenta para los [límites de envío](/es/docs/api-reference/rate-limits/), el seguimiento sigue la configuración del dominio y se admite la cabecera `Idempotency-Key`. Además, un espacio de trabajo puede reenviar como máximo 3 emails por hora.

Solo se pueden reenviar los emails salientes, y solo mientras tu [periodo de retención](/es/docs/data-retention/) conserve su contenido. Para reenviar el correo recibido, usa una [automatización](/es/docs/inbound/forward-with-automations/).

## Parámetros de ruta

- `id` (string, obligatorio): El ID del email saliente que quieres reenviar.

## Cabeceras

- `Idempotency-Key` (string): Permite reintentar el reenvío de forma segura. Consulta [Idempotencia](/es/docs/api-reference/idempotency/).

## Parámetros del cuerpo

- `to` (string | string[], obligatorio): Los nuevos destinatarios, como array o como cadena separada por comas. Hasta 50.

- `include_headers` (boolean): Si es `true`, añade un bloque «Forwarded message» con el remitente, la fecha, el asunto y el destinatario originales, y tu nota encima. Si es `false`, vuelve a enviar el contenido original sin cambios.

- `comment` (string): Una nota en texto plano que se coloca encima del mensaje reenviado. Solo se usa con `include_headers`. También se acepta `body` como alias.

- `html` (string): Una nota HTML que se usa en la parte HTML en lugar del `comment` escapado. Solo se usa con `include_headers`.

- `text` (string): Una nota en texto plano que se usa en la parte de texto en lugar de `comment`. Solo se usa con `include_headers`.

- `from` (string): El remitente. Por defecto, el `from` del email original.

- `subject` (string): El asunto. Por defecto, el asunto original o, con `include_headers`, `Fwd: ` seguido del asunto original.

Los adjuntos originales se incluyen si su tipo de archivo está [permitido](/es/docs/api-reference/emails/send/#attachment-object).

## Devuelve

Devuelve el mismo objeto que [Enviar un email](/es/docs/api-reference/emails/send/), con dos campos adicionales:

- `original_id` (string): El ID del email que has reenviado.

- `message` (string): Un mensaje de confirmación.

Si se supera el límite de reenvíos, la API devuelve `429` con una cabecera `retry-after`.

**Petición** `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 Entrante**

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

**422 Purgado**

```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
}
```

---
Fuente: https://emailit.com/es/docs/api-reference/emails/forward/

## Obtener solo el estado — GET /email/{id}

> Obtén solo el estado de entrega actual de un email por su ID, sin cabeceras, contenido ni metadatos, para comprobar el estado de forma ligera.

# Obtener solo el estado

Devuelve solo el estado actual de un email.

`GET /email/{id}`

Requiere una clave de API `full`. Fíjate en que la ruta usa `/email` en singular. La respuesta es pequeña, lo que hace que este endpoint sea práctico para comprobar rápidamente el estado. Para conocer los cambios de estado a medida que se producen, usa [webhooks](/es/docs/webhooks/) en lugar de consultar periódicamente.

## Parámetros de ruta

- `id` (string, obligatorio): El ID del email.

## Devuelve

- `status` (string): El estado actual: `accepted`, `scheduled`, `delivered`, `loaded`, `clicked`, `attempted`, `bounced`, `failed`, `rejected`, `suppressed`, `received`, `complained`, `canceled` o `held`. Consulta [Estados de los emails](/es/docs/logs/email-statuses/).

**Petición** `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"
}
```

---
Fuente: https://emailit.com/es/docs/api-reference/emails/status/