# Informes DMARC API

> Consulta los informes DMARC agregados y forenses de un dominio de envío, o sube los tuyos.

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

## Listar informes agregados — GET /domains/{id}/dmarc/reports

> Obtén los informes DMARC que Emailit ha recibido o que has subido para un dominio de envío, filtrados por tipo, estado, emisor del informe y fecha.

# Listar informes agregados

Devuelve los informes DMARC de un dominio de envío, del más reciente al más antiguo. Requiere una clave de API con el permiso `full`.

Emailit solo recopila informes de los dominios que tienen activados los informes DMARC (`dmarc_reports: true` en [Actualizar un dominio](/es/docs/api-reference/domains/update/)), lo que requiere el plan Pro o superior. Consulta [Informes DMARC](/es/docs/dmarc/reports/).

El listado también incluye los informes forenses. Pasa `type=aggregate` para listar solo los informes agregados, o usa [Listar informes forenses](/es/docs/api-reference/dmarc/forensic/) para ver los detalles forenses.

`GET /domains/{id}/dmarc/reports`

## Parámetros de ruta

- `id` (string, obligatorio): El ID (`dom_…`) o el nombre del dominio, por ejemplo `acme.com`.

## Parámetros de consulta

- `type` (string): `aggregate` o `forensic`.

- `status` (string): El estado de procesamiento: `pending`, `processed`, `failed` o `duplicate`.

- `org_name` (string): El nombre exacto de la organización emisora del informe, por ejemplo `google.com`.

- `from` (string): Solo los informes cuyo periodo empieza en esta fecha (o fecha y hora) o después, por ejemplo `2026-09-01`.

- `to` (string): Solo los informes cuyo periodo empieza en esta fecha (o fecha y hora) o antes. Una fecha sin hora incluye el día completo (UTC).

- `limit` (integer): Informes por página, hasta 100.

- `offset` (integer): El número de informes que se omiten.

- `match`, `order`, `direction`: consulta [Filtrado](https://emailit.com/es/docs/api-reference/filtering/).

Los filtros genéricos `key.condition=value` también funcionan con `type`, `status`, `org_name` y `created_at`, que son también las claves de ordenación de `order`. Consulta [Filtrado](/es/docs/api-reference/filtering/).

## Devuelve

Devuelve `data`, un array de objetos de informe, y `meta` con `total`, `limit` y `offset`.

- `id` (string): El ID del informe, con el prefijo `dmr_`.

- `type` (string | null): `aggregate` o `forensic`. `null` hasta que se procesa un informe subido.

- `source` (string): `smtp` para los informes que Emailit recibió en la dirección de informes del dominio, `upload` para los informes que [subiste](/es/docs/api-reference/dmarc/upload/).

- `status` (string): `pending`, `processed`, `failed` (consulta `error_message`) o `duplicate` (el mismo informe ya se había procesado).

- `org_name, org_email` (string | null): La organización que envió el informe y su dirección de contacto.

- `external_report_id` (string | null): El ID que el emisor asignó al informe.

- `date_range_begin, date_range_end` (string | null): El periodo que cubre el informe, en UTC.

- `policy_domain, adkim, aspf, p, sp, pct, fo` (string | integer | null): La política DMARC que encontró el emisor para tu dominio: los modos de alineación (`r` o `s`), la política y la política de subdominios (`none`, `quarantine`, `reject`), el porcentaje y las opciones de informes de fallos.

- `original_filename` (string | null): El nombre de archivo de un informe subido.

- `envelope_to` (string | null): La dirección de informes a la que se envió el informe.

- `created_at, updated_at, processed_at` (string | null): Marcas de tiempo en UTC.

Devuelve `404` si el dominio no existe en el espacio de trabajo.

**Petición** `GET /domains/{id}/dmarc/reports`

**cURL**

```bash
curl -G https://api.emailit.com/v2/domains/acme.com/dmarc/reports \
  -H "Authorization: Bearer $EMAILIT_API_KEY" \
  -d type=aggregate \
  -d from=2026-09-01 \
  -d limit=50
```

**Node.js**

```javascript
const params = new URLSearchParams({ type: 'aggregate', from: '2026-09-01', limit: '50' });
const res = await fetch(`https://api.emailit.com/v2/domains/acme.com/dmarc/reports?${params}`, {
  headers: { Authorization: `Bearer ${process.env.EMAILIT_API_KEY}` },
});
const { data: reports, meta } = await res.json();
```

**Python**

```python
import os, requests

r = requests.get(
    "https://api.emailit.com/v2/domains/acme.com/dmarc/reports",
    headers={"Authorization": f"Bearer {os.environ['EMAILIT_API_KEY']}"},
    params={"type": "aggregate", "from": "2026-09-01", "limit": 50},
)
reports = r.json()["data"]
```

**PHP**

```php
$client = new GuzzleHttp\Client(['base_uri' => 'https://api.emailit.com/v2/']);

$response = $client->get('domains/acme.com/dmarc/reports', [
    'headers' => ['Authorization' => 'Bearer ' . getenv('EMAILIT_API_KEY')],
    'query' => ['type' => 'aggregate', 'from' => '2026-09-01', 'limit' => 50],
]);
$reports = json_decode($response->getBody(), true)['data'];
```

**200**

```json
{
  "data": [
    {
      "object": "dmarc_report",
      "id": "dmr_3Xu63kEs8KCiyOZ1TDgnttppitx",
      "type": "aggregate",
      "source": "smtp",
      "status": "processed",
      "org_name": "google.com",
      "org_email": "noreply-dmarc-support@google.com",
      "external_report_id": "4129847120347812934",
      "date_range_begin": "2026-09-29 00:00:00+00",
      "date_range_end": "2026-09-29 23:59:59+00",
      "policy_domain": "acme.com",
      "adkim": "r",
      "aspf": "r",
      "p": "none",
      "sp": "none",
      "pct": 100,
      "fo": null,
      "original_filename": null,
      "error_message": null,
      "envelope_to": "k2v9x4qa7m@dmarc.emailitmail.com",
      "created_at": "2026-09-30 04:12:09.214377+00",
      "updated_at": "2026-09-30 04:12:11.902154+00",
      "processed_at": "2026-09-30 04:12:11.902154+00"
    }
  ],
  "meta": { "total": 1, "limit": 50, "offset": 0 }
}
```

**404**

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

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

## Obtener un informe — GET /domains/{id}/dmarc/reports/{report_id}

> Obtén un informe DMARC de un dominio. Los informes agregados incluyen sus registros: IP de origen, volúmenes y resultados de SPF y DKIM.

# Obtener un informe

Obtiene un informe DMARC. En un informe agregado, la respuesta incluye sus registros, uno por cada origen de envío, ordenados por número de mensajes. En un informe forense, incluye la muestra del fallo en `forensic`. Requiere una clave de API con el permiso `full`.

Solo llegan informes de los dominios que tienen activados los informes DMARC, lo que requiere el plan Pro o superior.

`GET /domains/{id}/dmarc/reports/{report_id}`

## Parámetros de ruta

- `id` (string, obligatorio): El ID (`dom_…`) o el nombre del dominio.

- `report_id` (string, obligatorio): El ID del informe (`dmr_…`).

## Parámetros de consulta

- `limit` (integer): Los registros que se devuelven, hasta 500. Solo para informes agregados.

- `offset` (integer): Los registros que se omiten. Solo para informes agregados.

## Devuelve

Devuelve el objeto de informe (consulta [Listar informes agregados](/es/docs/api-reference/dmarc/list/)), además de:

- `records` (object[]): Solo en informes agregados. Una entrada por cada combinación de IP de origen y resultado. Consulta los campos más abajo.

- `meta` (object): Solo en informes agregados. `total` (el número de registros), `limit` y `offset`.

- `forensic` (object | null): Solo en informes forenses. Los mismos campos que [Obtener un informe forense](/es/docs/api-reference/dmarc/forensic-get/).

Cada registro tiene:

- `source_ip` (string): La dirección IP que envió los mensajes.

- `count` (integer): El número de mensajes de este origen con estos resultados.

- `country_code, country_name, continent_code, asn, as_org, latitude, longitude` (string | integer | number | null): La ubicación y la red de la IP de origen. `null` si no se ha podido localizar la IP.

- `disposition` (string): Qué hizo el servidor receptor: `none`, `quarantine` o `reject`.

- `dkim, spf` (string): Los resultados con alineación DMARC según la evaluación del servidor receptor: `pass` o `fail`.

- `header_from, envelope_from, envelope_to` (string | null): Los identificadores que figuran en el informe.

- `dkim_domain, dkim_selector, dkim_result` (string | null): La firma DKIM que comprobó el servidor receptor y su resultado en bruto.

- `spf_domain, spf_result` (string | null): El dominio SPF que comprobó el servidor receptor y su resultado en bruto.

- `reason_type, reason_comment` (string | null): El motivo por el que no se aplicó la política, por ejemplo `forwarded` o `mailing_list`.

Devuelve `404` si el dominio o el informe no existen.

**Petición** `GET /domains/{id}/dmarc/reports/{report_id}`

**cURL**

```bash
curl https://api.emailit.com/v2/domains/acme.com/dmarc/reports/dmr_3Xu63kEs8KCiyOZ1TDgnttppitx \
  -H "Authorization: Bearer $EMAILIT_API_KEY"
```

**Node.js**

```javascript
const res = await fetch(
  'https://api.emailit.com/v2/domains/acme.com/dmarc/reports/dmr_3Xu63kEs8KCiyOZ1TDgnttppitx',
  { headers: { Authorization: `Bearer ${process.env.EMAILIT_API_KEY}` } },
);
const report = await res.json();
```

**Python**

```python
import os, requests

r = requests.get(
    "https://api.emailit.com/v2/domains/acme.com/dmarc/reports/dmr_3Xu63kEs8KCiyOZ1TDgnttppitx",
    headers={"Authorization": f"Bearer {os.environ['EMAILIT_API_KEY']}"},
)
report = r.json()
```

**PHP**

```php
$client = new GuzzleHttp\Client(['base_uri' => 'https://api.emailit.com/v2/']);

$response = $client->get('domains/acme.com/dmarc/reports/dmr_3Xu63kEs8KCiyOZ1TDgnttppitx', [
    'headers' => ['Authorization' => 'Bearer ' . getenv('EMAILIT_API_KEY')],
]);
$report = json_decode($response->getBody(), true);
```

**200**

```json
{
  "object": "dmarc_report",
  "id": "dmr_3Xu63kEs8KCiyOZ1TDgnttppitx",
  "type": "aggregate",
  "source": "smtp",
  "status": "processed",
  "org_name": "google.com",
  "org_email": "noreply-dmarc-support@google.com",
  "external_report_id": "4129847120347812934",
  "date_range_begin": "2026-09-29 00:00:00+00",
  "date_range_end": "2026-09-29 23:59:59+00",
  "policy_domain": "acme.com",
  "adkim": "r",
  "aspf": "r",
  "p": "none",
  "sp": "none",
  "pct": 100,
  "fo": null,
  "original_filename": null,
  "error_message": null,
  "envelope_to": "k2v9x4qa7m@dmarc.emailitmail.com",
  "created_at": "2026-09-30 04:12:09.214377+00",
  "updated_at": "2026-09-30 04:12:11.902154+00",
  "processed_at": "2026-09-30 04:12:11.902154+00",
  "records": [
    {
      "object": "dmarc_report_record",
      "source_ip": "198.51.100.24",
      "count": 1840,
      "country_code": "US",
      "country_name": "United States",
      "continent_code": "NA",
      "asn": 64500,
      "as_org": "Example Hosting",
      "latitude": 37.751,
      "longitude": -97.822,
      "disposition": "none",
      "dkim": "pass",
      "spf": "pass",
      "header_from": "acme.com",
      "envelope_from": "emailit.acme.com",
      "envelope_to": null,
      "dkim_domain": "acme.com",
      "dkim_selector": "emailit",
      "dkim_result": "pass",
      "spf_domain": "emailit.acme.com",
      "spf_result": "pass",
      "reason_type": null,
      "reason_comment": null
    },
    {
      "object": "dmarc_report_record",
      "source_ip": "203.0.113.77",
      "count": 12,
      "country_code": "NL",
      "country_name": "Netherlands",
      "continent_code": "EU",
      "asn": 64511,
      "as_org": "Example Networks",
      "latitude": 52.3824,
      "longitude": 4.8995,
      "disposition": "none",
      "dkim": "fail",
      "spf": "fail",
      "header_from": "acme.com",
      "envelope_from": "acme.com",
      "envelope_to": null,
      "dkim_domain": null,
      "dkim_selector": null,
      "dkim_result": null,
      "spf_domain": "acme.com",
      "spf_result": "softfail",
      "reason_type": null,
      "reason_comment": null
    }
  ],
  "meta": { "total": 2, "limit": 100, "offset": 0 }
}
```

**404**

```json
{
  "error": "Report not found"
}
```

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

## Subir un informe — POST /domains/{id}/dmarc/reports

> Sube un informe DMARC agregado (XML, gzip o zip) o forense (EML) de un dominio. El procesamiento se hace en segundo plano.

# Subir un informe

Sube un informe DMARC que recibiste por otra vía, por ejemplo en un buzón que usabas antes de Emailit. Requiere una clave de API con el permiso `full`.

Emailit guarda el archivo y lo procesa en segundo plano: la respuesta tiene el estado `pending`, y poco después el informe pasa a `processed`, `failed` o `duplicate` (ya importado). Compruébalo con [Obtener un informe](/es/docs/api-reference/dmarc/get/). Los informes que Emailit recibe por email requieren que el dominio tenga activados los informes DMARC (plan Pro o superior); los informes subidos se procesan en cualquier caso.

`POST /domains/{id}/dmarc/reports`

## Parámetros de ruta

- `id` (string, obligatorio): El ID (`dom_…`) o el nombre del dominio.

## Parámetros del cuerpo

Envía exactamente uno de estos dos campos: `content_base64` o `content`. El informe decodificado puede ocupar hasta 10 MB.

- `content_base64` (string): El archivo, codificado en Base64. Úsalo para los formatos binarios: informes agregados en `.xml`, `.xml.gz` o `.zip`, e informes forenses en `.eml` (AFRF).

- `content` (string): El informe como texto UTF-8, por ejemplo el XML agregado en bruto.

- `filename` (string): El nombre de archivo original, que se guarda como `original_filename`.

## Devuelve

Devuelve `202 Accepted` con el nuevo objeto de informe. `type` es `null` hasta que el procesamiento lo detecta.

| Código | Cuándo |
| --- | --- |
| `400` | No se ha indicado `content_base64` ni `content`, o el valor está vacío. |
| `404` | El dominio no existe en el espacio de trabajo. |
| `413` | El informe decodificado ocupa más de 10 MB. |

**Petición** `POST /domains/{id}/dmarc/reports`

**cURL**

```bash
curl -X POST https://api.emailit.com/v2/domains/acme.com/dmarc/reports \
  -H "Authorization: Bearer $EMAILIT_API_KEY" \
  -H "Content-Type: application/json" \
  -d "{
    \"filename\": \"google-acme.com-2026-09-29.xml.gz\",
    \"content_base64\": \"$(base64 < 'google-acme.com-2026-09-29.xml.gz' | tr -d '\n')\"
  }"
```

**Node.js**

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

const filename = 'google-acme.com-2026-09-29.xml.gz';
const file = await readFile(filename);

const res = await fetch('https://api.emailit.com/v2/domains/acme.com/dmarc/reports', {
  method: 'POST',
  headers: {
    Authorization: `Bearer ${process.env.EMAILIT_API_KEY}`,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({ filename, content_base64: file.toString('base64') }),
});
const report = await res.json();
```

**Python**

```python
import base64, os, requests

filename = "google-acme.com-2026-09-29.xml.gz"
with open(filename, "rb") as f:
    content = base64.b64encode(f.read()).decode()

r = requests.post(
    "https://api.emailit.com/v2/domains/acme.com/dmarc/reports",
    headers={"Authorization": f"Bearer {os.environ['EMAILIT_API_KEY']}"},
    json={"filename": filename, "content_base64": content},
)
report = r.json()
```

**PHP**

```php
$client = new GuzzleHttp\Client(['base_uri' => 'https://api.emailit.com/v2/']);
$filename = 'google-acme.com-2026-09-29.xml.gz';

$response = $client->post('domains/acme.com/dmarc/reports', [
    'headers' => ['Authorization' => 'Bearer ' . getenv('EMAILIT_API_KEY')],
    'json' => [
        'filename' => $filename,
        'content_base64' => base64_encode(file_get_contents($filename)),
    ],
]);
$report = json_decode($response->getBody(), true);
```

**202**

```json
{
  "object": "dmarc_report",
  "id": "dmr_3MjUXgcEBO0o7FkzeBdlrCY6NYk",
  "type": null,
  "source": "upload",
  "status": "pending",
  "org_name": null,
  "org_email": null,
  "external_report_id": null,
  "date_range_begin": null,
  "date_range_end": null,
  "policy_domain": null,
  "adkim": null,
  "aspf": null,
  "p": null,
  "sp": null,
  "pct": null,
  "fo": null,
  "original_filename": "google-acme.com-2026-09-29.xml.gz",
  "error_message": null,
  "envelope_to": null,
  "created_at": "2026-10-01 12:03:55.607+00",
  "updated_at": "2026-10-01 12:03:55.607+00",
  "processed_at": null
}
```

**400**

```json
{
  "error": "content_base64 or content is required"
}
```

**413**

```json
{
  "error": "Report exceeds maximum size of 10485760 bytes"
}
```

---
Fuente: https://emailit.com/es/docs/api-reference/dmarc/upload/

## Listar informes forenses — GET /domains/{id}/dmarc/forensic

> Obtén los informes forenses (de fallos) DMARC procesados de un dominio: IP de origen, ubicación, tipo de fallo y detalles del mensaje.

# Listar informes forenses

Devuelve los informes forenses (RUF) procesados de un dominio, del más reciente al más antiguo. Cada uno describe un mensaje que no superó DMARC. El listado no incluye las cabeceras; para verlas, [obtén el informe forense](/es/docs/api-reference/dmarc/forensic-get/). Requiere una clave de API con el permiso `full`.

Solo llegan informes de los dominios que tienen activados los informes DMARC, lo que requiere el plan Pro o superior. Pocos proveedores de correo envían informes forenses, y los que lo hacen pueden incluir datos personales del mensaje fallido.

`GET /domains/{id}/dmarc/forensic`

## Parámetros de ruta

- `id` (string, obligatorio): El ID (`dom_…`) o el nombre del dominio.

## Parámetros de consulta

- `from` (string): Solo los informes cuyo periodo empieza en esta fecha (o fecha y hora) o después.

- `to` (string): Solo los informes cuyo periodo empieza en esta fecha (o fecha y hora) o antes. Una fecha sin hora incluye el día completo (UTC).

- `limit` (integer): Informes por página, hasta 100.

- `offset` (integer): El número de informes que se omiten.

Los filtros genéricos `key.condition=value` también funcionan con `org_name` y `created_at`, junto con `match`, `order` y `direction`. Consulta [Filtrado](/es/docs/api-reference/filtering/).

## Devuelve

Devuelve `data` y `meta` (`total`, `limit`, `offset`). Cada elemento tiene:

- `object` (string): `dmarc_forensic_report`.

- `id, report_id` (string): El ID del informe (`dmr_…`).

- `arrival_date` (string | null): Cuándo llegó el mensaje fallido al servidor receptor.

- `source_ip` (string | null): La dirección IP que envió el mensaje.

- `country_code, country_name, continent_code, asn, as_org, latitude, longitude` (string | integer | number | null): La ubicación y la red de la IP de origen.

- `auth_failure` (string | null): Qué falló, por ejemplo `dmarc`, `spf` o `dkim`.

- `authentication_results` (string | null): La cabecera `Authentication-Results` del servidor receptor.

- `original_mail_from, original_rcpt_to, subject` (string | null): El remitente del sobre, el destinatario y el asunto del mensaje fallido.

- `delivery_result` (string | null): Qué hizo el servidor receptor, por ejemplo `reject` o `delivered`.

- `reported_domain` (string | null): Tu dominio tal como aparece en el informe.

- `created_at` (string | null): Cuándo guardó Emailit el informe.

**Petición** `GET /domains/{id}/dmarc/forensic`

**cURL**

```bash
curl -G https://api.emailit.com/v2/domains/acme.com/dmarc/forensic \
  -H "Authorization: Bearer $EMAILIT_API_KEY" \
  -d from=2026-09-01
```

**Node.js**

```javascript
const params = new URLSearchParams({ from: '2026-09-01' });
const res = await fetch(`https://api.emailit.com/v2/domains/acme.com/dmarc/forensic?${params}`, {
  headers: { Authorization: `Bearer ${process.env.EMAILIT_API_KEY}` },
});
const { data: reports } = await res.json();
```

**Python**

```python
import os, requests

r = requests.get(
    "https://api.emailit.com/v2/domains/acme.com/dmarc/forensic",
    headers={"Authorization": f"Bearer {os.environ['EMAILIT_API_KEY']}"},
    params={"from": "2026-09-01"},
)
reports = r.json()["data"]
```

**PHP**

```php
$client = new GuzzleHttp\Client(['base_uri' => 'https://api.emailit.com/v2/']);

$response = $client->get('domains/acme.com/dmarc/forensic', [
    'headers' => ['Authorization' => 'Bearer ' . getenv('EMAILIT_API_KEY')],
    'query' => ['from' => '2026-09-01'],
]);
$reports = json_decode($response->getBody(), true)['data'];
```

**200**

```json
{
  "data": [
    {
      "object": "dmarc_forensic_report",
      "id": "dmr_3MjUXgcEBO0o7FkzeBdlrCY6NYk",
      "report_id": "dmr_3MjUXgcEBO0o7FkzeBdlrCY6NYk",
      "arrival_date": "2026-09-28 17:44:02+00",
      "source_ip": "203.0.113.77",
      "country_code": "NL",
      "country_name": "Netherlands",
      "continent_code": "EU",
      "asn": 64511,
      "as_org": "Example Networks",
      "latitude": 52.3824,
      "longitude": 4.8995,
      "auth_failure": "dmarc",
      "authentication_results": "mx.example.net; dmarc=fail (p=none) header.from=acme.com; spf=softfail smtp.mailfrom=acme.com; dkim=none",
      "original_mail_from": "billing@acme.com",
      "original_rcpt_to": "ada@example.net",
      "subject": "Your invoice is ready",
      "delivery_result": "delivered",
      "reported_domain": "acme.com",
      "created_at": "2026-09-28 18:02:16.448210+00"
    }
  ],
  "meta": { "total": 1, "limit": 25, "offset": 0 }
}
```

**404**

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

---
Fuente: https://emailit.com/es/docs/api-reference/dmarc/forensic/

## Obtener un informe forense — GET /domains/{id}/dmarc/forensic/{report_id}

> Obtén un informe forense DMARC de un dominio, incluidas las cabeceras del mensaje que no superó la autenticación.

# Obtener un informe forense

Obtiene un informe forense (RUF) con las cabeceras del mensaje que no superó DMARC. Requiere una clave de API con el permiso `full`. Los informes forenses pueden contener datos personales, como direcciones de destinatarios y asuntos.

Solo llegan informes de los dominios que tienen activados los informes DMARC, lo que requiere el plan Pro o superior.

`GET /domains/{id}/dmarc/forensic/{report_id}`

## Parámetros de ruta

- `id` (string, obligatorio): El ID (`dom_…`) o el nombre del dominio.

- `report_id` (string, obligatorio): El ID (`dmr_…`) de un informe forense.

## Devuelve

Devuelve el informe forense con los campos descritos en [Listar informes forenses](/es/docs/api-reference/dmarc/forensic/), además de:

- `headers` (string | null): Las cabeceras del mensaje original incluidas en el informe, como texto en bruto.

Devuelve `404` si el dominio no existe, si el informe no existe o si no es un informe forense procesado.

**Petición** `GET /domains/{id}/dmarc/forensic/{report_id}`

**cURL**

```bash
curl https://api.emailit.com/v2/domains/acme.com/dmarc/forensic/dmr_3MjUXgcEBO0o7FkzeBdlrCY6NYk \
  -H "Authorization: Bearer $EMAILIT_API_KEY"
```

**Node.js**

```javascript
const res = await fetch(
  'https://api.emailit.com/v2/domains/acme.com/dmarc/forensic/dmr_3MjUXgcEBO0o7FkzeBdlrCY6NYk',
  { headers: { Authorization: `Bearer ${process.env.EMAILIT_API_KEY}` } },
);
const report = await res.json();
```

**Python**

```python
import os, requests

r = requests.get(
    "https://api.emailit.com/v2/domains/acme.com/dmarc/forensic/dmr_3MjUXgcEBO0o7FkzeBdlrCY6NYk",
    headers={"Authorization": f"Bearer {os.environ['EMAILIT_API_KEY']}"},
)
report = r.json()
```

**PHP**

```php
$client = new GuzzleHttp\Client(['base_uri' => 'https://api.emailit.com/v2/']);

$response = $client->get('domains/acme.com/dmarc/forensic/dmr_3MjUXgcEBO0o7FkzeBdlrCY6NYk', [
    'headers' => ['Authorization' => 'Bearer ' . getenv('EMAILIT_API_KEY')],
]);
$report = json_decode($response->getBody(), true);
```

**200**

```json
{
  "object": "dmarc_forensic_report",
  "id": "dmr_3MjUXgcEBO0o7FkzeBdlrCY6NYk",
  "report_id": "dmr_3MjUXgcEBO0o7FkzeBdlrCY6NYk",
  "arrival_date": "2026-09-28 17:44:02+00",
  "source_ip": "203.0.113.77",
  "country_code": "NL",
  "country_name": "Netherlands",
  "continent_code": "EU",
  "asn": 64511,
  "as_org": "Example Networks",
  "latitude": 52.3824,
  "longitude": 4.8995,
  "auth_failure": "dmarc",
  "authentication_results": "mx.example.net; dmarc=fail (p=none) header.from=acme.com; spf=softfail smtp.mailfrom=acme.com; dkim=none",
  "original_mail_from": "billing@acme.com",
  "original_rcpt_to": "ada@example.net",
  "subject": "Your invoice is ready",
  "delivery_result": "delivered",
  "reported_domain": "acme.com",
  "headers": "From: Acme Billing <billing@acme.com>\r\nTo: ada@example.net\r\nSubject: Your invoice is ready\r\nDate: Mon, 28 Sep 2026 17:43:58 +0000\r\nMessage-ID: <20260928174358.4f1c@mail.acme.com>",
  "created_at": "2026-09-28 18:02:16.448210+00"
}
```

**404**

```json
{
  "error": "Forensic report not found"
}
```

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

## Obtener estadísticas — GET /domains/{id}/dmarc/stats

> Obtén los totales DMARC de un dominio: volumen, tasa de aprobación, acciones aplicadas, resultados de SPF y DKIM, series diarias y los principales países y redes.

# Obtener estadísticas

Resume los informes DMARC agregados de un dominio en un intervalo de fechas: cuánto correo de tu dominio vieron los servidores receptores, cuánto superó la comprobación y de dónde procedía. Son los datos de la pestaña Overview de **Email API → DMARC reports**. Requiere una clave de API con el permiso `full`.

Solo llegan informes de los dominios que tienen activados los informes DMARC (`dmarc_reports: true` en [Actualizar un dominio](/es/docs/api-reference/domains/update/)), lo que requiere el plan Pro o superior.

`GET /domains/{id}/dmarc/stats`

## Parámetros de ruta

- `id` (string, obligatorio): El ID (`dom_…`) o el nombre del dominio.

## Parámetros de consulta

- `from` (string): Solo cuenta los periodos de informe que empiezan en esta fecha (o fecha y hora) o después, por ejemplo `2026-09-01`. Si no lo indicas, se cuentan todos los informes.

- `to` (string): Solo cuenta los periodos de informe que empiezan en esta fecha (o fecha y hora) o antes. Una fecha sin hora incluye el día completo (UTC).

## Devuelve

Devuelve `data` con estos campos. Un mensaje cuenta como aprobado si su resultado DKIM o SPF con alineación DMARC es `pass`.

- `total_volume` (integer): Los mensajes notificados.

- `pass_volume, fail_volume` (integer): Los mensajes que superaron y los que no superaron la comprobación.

- `pass_rate` (number): El porcentaje de mensajes que la superaron, redondeado a dos decimales. `0` si no hay volumen.

- `report_count` (integer): Los informes procesados en el intervalo, agregados y forenses.

- `dispositions` (object[]): El volumen por acción del servidor receptor: `disposition` (`none`, `quarantine`, `reject`) y `volume`.

- `dkim, spf` (object[]): El volumen por resultado alineado: `result` (`pass` o `fail`) y `volume`.

- `daily` (object[]): Una entrada por día (`date` con el formato `YYYY-MM-DD`, en UTC) con `volume`, `pass_volume` y `fail_volume`.

- `daily_dispositions, daily_dkim, daily_spf` (object[]): Los mismos desgloses por día: `date`, `disposition` o `result`, y `volume`.

- `top_countries` (object[]): Hasta 10 países por volumen: `country_code`, `country_name`, `volume`, `pass_volume`, `fail_volume`.

- `top_asns` (object[]): Hasta 10 redes por volumen: `asn`, `as_org`, `volume`, `pass_volume`, `fail_volume`.

- `unknown_geo_volume` (integer): Los mensajes de direcciones IP que no se han podido localizar.

Devuelve `404` si el dominio no existe en el espacio de trabajo.

**Petición** `GET /domains/{id}/dmarc/stats`

**cURL**

```bash
curl -G https://api.emailit.com/v2/domains/acme.com/dmarc/stats \
  -H "Authorization: Bearer $EMAILIT_API_KEY" \
  -d from=2026-09-28 \
  -d to=2026-09-29
```

**Node.js**

```javascript
const params = new URLSearchParams({ from: '2026-09-28', to: '2026-09-29' });
const res = await fetch(`https://api.emailit.com/v2/domains/acme.com/dmarc/stats?${params}`, {
  headers: { Authorization: `Bearer ${process.env.EMAILIT_API_KEY}` },
});
const { data: stats } = await res.json();
```

**Python**

```python
import os, requests

r = requests.get(
    "https://api.emailit.com/v2/domains/acme.com/dmarc/stats",
    headers={"Authorization": f"Bearer {os.environ['EMAILIT_API_KEY']}"},
    params={"from": "2026-09-28", "to": "2026-09-29"},
)
stats = r.json()["data"]
```

**PHP**

```php
$client = new GuzzleHttp\Client(['base_uri' => 'https://api.emailit.com/v2/']);

$response = $client->get('domains/acme.com/dmarc/stats', [
    'headers' => ['Authorization' => 'Bearer ' . getenv('EMAILIT_API_KEY')],
    'query' => ['from' => '2026-09-28', 'to' => '2026-09-29'],
]);
$stats = json_decode($response->getBody(), true)['data'];
```

**200**

```json
{
  "data": {
    "total_volume": 3712,
    "pass_volume": 3688,
    "fail_volume": 24,
    "pass_rate": 99.35,
    "report_count": 6,
    "dispositions": [
      { "disposition": "none", "volume": 3712 }
    ],
    "dkim": [
      { "result": "pass", "volume": 3680 },
      { "result": "fail", "volume": 32 }
    ],
    "spf": [
      { "result": "pass", "volume": 3676 },
      { "result": "fail", "volume": 36 }
    ],
    "daily": [
      { "date": "2026-09-28", "volume": 1860, "pass_volume": 1848, "fail_volume": 12 },
      { "date": "2026-09-29", "volume": 1852, "pass_volume": 1840, "fail_volume": 12 }
    ],
    "daily_dispositions": [
      { "date": "2026-09-28", "disposition": "none", "volume": 1860 },
      { "date": "2026-09-29", "disposition": "none", "volume": 1852 }
    ],
    "daily_dkim": [
      { "date": "2026-09-28", "result": "pass", "volume": 1844 },
      { "date": "2026-09-28", "result": "fail", "volume": 16 },
      { "date": "2026-09-29", "result": "pass", "volume": 1836 },
      { "date": "2026-09-29", "result": "fail", "volume": 16 }
    ],
    "daily_spf": [
      { "date": "2026-09-28", "result": "pass", "volume": 1842 },
      { "date": "2026-09-28", "result": "fail", "volume": 18 },
      { "date": "2026-09-29", "result": "pass", "volume": 1834 },
      { "date": "2026-09-29", "result": "fail", "volume": 18 }
    ],
    "top_countries": [
      { "country_code": "US", "country_name": "United States", "volume": 3688, "pass_volume": 3688, "fail_volume": 0 },
      { "country_code": "NL", "country_name": "Netherlands", "volume": 24, "pass_volume": 0, "fail_volume": 24 }
    ],
    "top_asns": [
      { "asn": 64500, "as_org": "Example Hosting", "volume": 3688, "pass_volume": 3688, "fail_volume": 0 },
      { "asn": 64511, "as_org": "Example Networks", "volume": 24, "pass_volume": 0, "fail_volume": 24 }
    ],
    "unknown_geo_volume": 0
  }
}
```

**404**

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

---
Fuente: https://emailit.com/es/docs/api-reference/dmarc/stats/

## Listar orígenes de envío — GET /domains/{id}/dmarc/sources

> Obtén las direcciones IP que enviaron correo en nombre de tu dominio según los informes DMARC, con su volumen y sus recuentos de mensajes aprobados y fallidos por IP.

# Listar orígenes de envío

Agrupa los datos agregados de DMARC de un dominio por dirección IP de origen, de mayor a menor volumen. Úsalo para detectar servidores que envían en nombre de tu dominio pero no superan SPF ni DKIM. Requiere una clave de API con el permiso `full`.

Solo llegan informes de los dominios que tienen activados los informes DMARC, lo que requiere el plan Pro o superior.

`GET /domains/{id}/dmarc/sources`

## Parámetros de ruta

- `id` (string, obligatorio): El ID (`dom_…`) o el nombre del dominio.

## Parámetros de consulta

- `from` (string): Solo cuenta los periodos de informe que empiezan en esta fecha (o fecha y hora) o después.

- `to` (string): Solo cuenta los periodos de informe que empiezan en esta fecha (o fecha y hora) o antes. Una fecha sin hora incluye el día completo (UTC).

- `limit` (integer): Orígenes por página, hasta 200.

- `offset` (integer): El número de orígenes que se omiten.

## Devuelve

Devuelve `data` y `meta` (`limit`, `offset`). La respuesta no incluye un total; pide la página siguiente hasta que `data` tenga menos elementos que `limit`. Cada origen tiene:

- `source_ip` (string): La dirección IP de envío.

- `country_code, country_name` (string | null): Dónde se encuentra la IP.

- `asn, as_org` (integer | string | null): La red a la que pertenece la IP.

- `volume` (integer): Los mensajes notificados desde esta IP.

- `pass_volume, fail_volume` (integer): Los mensajes que superaron DKIM o SPF con alineación DMARC y los que no superaron ninguno de los dos.

Devuelve `404` si el dominio no existe en el espacio de trabajo.

**Petición** `GET /domains/{id}/dmarc/sources`

**cURL**

```bash
curl -G https://api.emailit.com/v2/domains/acme.com/dmarc/sources \
  -H "Authorization: Bearer $EMAILIT_API_KEY" \
  -d from=2026-09-01
```

**Node.js**

```javascript
const params = new URLSearchParams({ from: '2026-09-01' });
const res = await fetch(`https://api.emailit.com/v2/domains/acme.com/dmarc/sources?${params}`, {
  headers: { Authorization: `Bearer ${process.env.EMAILIT_API_KEY}` },
});
const { data: sources } = await res.json();
```

**Python**

```python
import os, requests

r = requests.get(
    "https://api.emailit.com/v2/domains/acme.com/dmarc/sources",
    headers={"Authorization": f"Bearer {os.environ['EMAILIT_API_KEY']}"},
    params={"from": "2026-09-01"},
)
sources = r.json()["data"]
```

**PHP**

```php
$client = new GuzzleHttp\Client(['base_uri' => 'https://api.emailit.com/v2/']);

$response = $client->get('domains/acme.com/dmarc/sources', [
    'headers' => ['Authorization' => 'Bearer ' . getenv('EMAILIT_API_KEY')],
    'query' => ['from' => '2026-09-01'],
]);
$sources = json_decode($response->getBody(), true)['data'];
```

**200**

```json
{
  "data": [
    {
      "source_ip": "198.51.100.24",
      "country_code": "US",
      "country_name": "United States",
      "asn": 64500,
      "as_org": "Example Hosting",
      "volume": 3688,
      "pass_volume": 3688,
      "fail_volume": 0
    },
    {
      "source_ip": "203.0.113.77",
      "country_code": "NL",
      "country_name": "Netherlands",
      "asn": 64511,
      "as_org": "Example Networks",
      "volume": 24,
      "pass_volume": 0,
      "fail_volume": 24
    }
  ],
  "meta": { "limit": 50, "offset": 0 }
}
```

**404**

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

---
Fuente: https://emailit.com/es/docs/api-reference/dmarc/sources/

## Listar países — GET /domains/{id}/dmarc/countries

> Obtén los países desde los que se envió correo que dice proceder de tu dominio, con su volumen DMARC y sus recuentos de mensajes aprobados y fallidos.

# Listar países

Agrupa los datos agregados de DMARC de un dominio por el país de la IP de envío, de mayor a menor volumen. Requiere una clave de API con el permiso `full`.

Solo llegan informes de los dominios que tienen activados los informes DMARC, lo que requiere el plan Pro o superior.

`GET /domains/{id}/dmarc/countries`

## Parámetros de ruta

- `id` (string, obligatorio): El ID (`dom_…`) o el nombre del dominio.

## Parámetros de consulta

- `from` (string): Solo cuenta los periodos de informe que empiezan en esta fecha (o fecha y hora) o después.

- `to` (string): Solo cuenta los periodos de informe que empiezan en esta fecha (o fecha y hora) o antes. Una fecha sin hora incluye el día completo (UTC).

- `limit` (integer): Países por página, hasta 200.

- `offset` (integer): El número de países que se omiten.

## Devuelve

Devuelve `data` y `meta` (`limit`, `offset`). Cada país tiene:

- `country_code` (string | null): El código ISO 3166-1 alfa-2. `null` agrupa las direcciones IP que no se han podido localizar.

- `country_name` (string | null): El nombre del país.

- `continent_code` (string | null): El código del continente, por ejemplo `EU`.

- `volume` (integer): Los mensajes notificados desde este país.

- `pass_volume, fail_volume` (integer): Los mensajes que superaron DKIM o SPF con alineación DMARC y los que no superaron ninguno de los dos.

Devuelve `404` si el dominio no existe en el espacio de trabajo.

**Petición** `GET /domains/{id}/dmarc/countries`

**cURL**

```bash
curl -G https://api.emailit.com/v2/domains/acme.com/dmarc/countries \
  -H "Authorization: Bearer $EMAILIT_API_KEY" \
  -d from=2026-09-01
```

**Node.js**

```javascript
const params = new URLSearchParams({ from: '2026-09-01' });
const res = await fetch(`https://api.emailit.com/v2/domains/acme.com/dmarc/countries?${params}`, {
  headers: { Authorization: `Bearer ${process.env.EMAILIT_API_KEY}` },
});
const { data: countries } = await res.json();
```

**Python**

```python
import os, requests

r = requests.get(
    "https://api.emailit.com/v2/domains/acme.com/dmarc/countries",
    headers={"Authorization": f"Bearer {os.environ['EMAILIT_API_KEY']}"},
    params={"from": "2026-09-01"},
)
countries = r.json()["data"]
```

**PHP**

```php
$client = new GuzzleHttp\Client(['base_uri' => 'https://api.emailit.com/v2/']);

$response = $client->get('domains/acme.com/dmarc/countries', [
    'headers' => ['Authorization' => 'Bearer ' . getenv('EMAILIT_API_KEY')],
    'query' => ['from' => '2026-09-01'],
]);
$countries = json_decode($response->getBody(), true)['data'];
```

**200**

```json
{
  "data": [
    {
      "country_code": "US",
      "country_name": "United States",
      "continent_code": "NA",
      "volume": 3688,
      "pass_volume": 3688,
      "fail_volume": 0
    },
    {
      "country_code": "NL",
      "country_name": "Netherlands",
      "continent_code": "EU",
      "volume": 24,
      "pass_volume": 0,
      "fail_volume": 24
    }
  ],
  "meta": { "limit": 50, "offset": 0 }
}
```

**404**

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

---
Fuente: https://emailit.com/es/docs/api-reference/dmarc/countries/

## Listar redes (ASN) — GET /domains/{id}/dmarc/asns

> Obtén las redes (sistemas autónomos) que enviaron correo en nombre de tu dominio, con su volumen DMARC y sus recuentos de mensajes aprobados y fallidos por ASN.

# Listar redes (ASN)

Agrupa los datos agregados de DMARC de un dominio por el sistema autónomo (ASN) de la IP de envío, de mayor a menor volumen. Una red suele corresponder a un proveedor de alojamiento o a un servicio de email, lo que facilita reconocer a los remitentes legítimos. Requiere una clave de API con el permiso `full`.

Solo llegan informes de los dominios que tienen activados los informes DMARC, lo que requiere el plan Pro o superior.

`GET /domains/{id}/dmarc/asns`

## Parámetros de ruta

- `id` (string, obligatorio): El ID (`dom_…`) o el nombre del dominio.

## Parámetros de consulta

- `from` (string): Solo cuenta los periodos de informe que empiezan en esta fecha (o fecha y hora) o después.

- `to` (string): Solo cuenta los periodos de informe que empiezan en esta fecha (o fecha y hora) o antes. Una fecha sin hora incluye el día completo (UTC).

- `limit` (integer): Redes por página, hasta 200.

- `offset` (integer): El número de redes que se omiten.

## Devuelve

Devuelve `data` y `meta` (`limit`, `offset`). Cada red tiene:

- `asn` (integer | null): El número de sistema autónomo. `null` agrupa las direcciones IP que no se han podido consultar.

- `as_org` (string | null): El nombre de la organización que opera la red.

- `volume` (integer): Los mensajes notificados desde esta red.

- `pass_volume, fail_volume` (integer): Los mensajes que superaron DKIM o SPF con alineación DMARC y los que no superaron ninguno de los dos.

Devuelve `404` si el dominio no existe en el espacio de trabajo.

**Petición** `GET /domains/{id}/dmarc/asns`

**cURL**

```bash
curl -G https://api.emailit.com/v2/domains/acme.com/dmarc/asns \
  -H "Authorization: Bearer $EMAILIT_API_KEY" \
  -d from=2026-09-01
```

**Node.js**

```javascript
const params = new URLSearchParams({ from: '2026-09-01' });
const res = await fetch(`https://api.emailit.com/v2/domains/acme.com/dmarc/asns?${params}`, {
  headers: { Authorization: `Bearer ${process.env.EMAILIT_API_KEY}` },
});
const { data: networks } = await res.json();
```

**Python**

```python
import os, requests

r = requests.get(
    "https://api.emailit.com/v2/domains/acme.com/dmarc/asns",
    headers={"Authorization": f"Bearer {os.environ['EMAILIT_API_KEY']}"},
    params={"from": "2026-09-01"},
)
networks = r.json()["data"]
```

**PHP**

```php
$client = new GuzzleHttp\Client(['base_uri' => 'https://api.emailit.com/v2/']);

$response = $client->get('domains/acme.com/dmarc/asns', [
    'headers' => ['Authorization' => 'Bearer ' . getenv('EMAILIT_API_KEY')],
    'query' => ['from' => '2026-09-01'],
]);
$networks = json_decode($response->getBody(), true)['data'];
```

**200**

```json
{
  "data": [
    {
      "asn": 64500,
      "as_org": "Example Hosting",
      "volume": 3688,
      "pass_volume": 3688,
      "fail_volume": 0
    },
    {
      "asn": 64511,
      "as_org": "Example Networks",
      "volume": 24,
      "pass_volume": 0,
      "fail_volume": 24
    }
  ],
  "meta": { "limit": 50, "offset": 0 }
}
```

**404**

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

---
Fuente: https://emailit.com/es/docs/api-reference/dmarc/asns/

## Listar emisores de informes — GET /domains/{id}/dmarc/reporters

> Obtén las organizaciones, como Google o Microsoft, que enviaron informes DMARC agregados de tu dominio, con el número de informes de cada una.

# Listar emisores de informes

Enumera las organizaciones que enviaron informes agregados procesados de un dominio, de la que más informes envió a la que menos. Requiere una clave de API con el permiso `full`.

Solo llegan informes de los dominios que tienen activados los informes DMARC, lo que requiere el plan Pro o superior.

`GET /domains/{id}/dmarc/reporters`

## Parámetros de ruta

- `id` (string, obligatorio): El ID (`dom_…`) o el nombre del dominio.

## Parámetros de consulta

- `from` (string): Solo cuenta los informes cuyo periodo empieza en esta fecha (o fecha y hora) o después.

- `to` (string): Solo cuenta los informes cuyo periodo empieza en esta fecha (o fecha y hora) o antes. Una fecha sin hora incluye el día completo (UTC).

- `limit` (integer): Emisores por página, hasta 200.

- `offset` (integer): El número de emisores que se omiten.

## Devuelve

Devuelve `data` y `meta` (`limit`, `offset`). Cada emisor tiene:

- `org_name` (string | null): El nombre de la organización emisora, por ejemplo `google.com`. Pásalo como `org_name` a [Listar informes agregados](/es/docs/api-reference/dmarc/list/) para ver sus informes.

- `org_email` (string | null): La dirección de contacto del emisor.

- `report_count` (integer): El número de informes agregados procesados de esta organización.

Devuelve `404` si el dominio no existe en el espacio de trabajo.

**Petición** `GET /domains/{id}/dmarc/reporters`

**cURL**

```bash
curl https://api.emailit.com/v2/domains/acme.com/dmarc/reporters \
  -H "Authorization: Bearer $EMAILIT_API_KEY"
```

**Node.js**

```javascript
const res = await fetch('https://api.emailit.com/v2/domains/acme.com/dmarc/reporters', {
  headers: { Authorization: `Bearer ${process.env.EMAILIT_API_KEY}` },
});
const { data: reporters } = await res.json();
```

**Python**

```python
import os, requests

r = requests.get(
    "https://api.emailit.com/v2/domains/acme.com/dmarc/reporters",
    headers={"Authorization": f"Bearer {os.environ['EMAILIT_API_KEY']}"},
)
reporters = r.json()["data"]
```

**PHP**

```php
$client = new GuzzleHttp\Client(['base_uri' => 'https://api.emailit.com/v2/']);

$response = $client->get('domains/acme.com/dmarc/reporters', [
    'headers' => ['Authorization' => 'Bearer ' . getenv('EMAILIT_API_KEY')],
]);
$reporters = json_decode($response->getBody(), true)['data'];
```

**200**

```json
{
  "data": [
    { "org_name": "google.com", "org_email": "noreply-dmarc-support@google.com", "report_count": 30 },
    { "org_name": "Enterprise Outlook", "org_email": "dmarcreport@microsoft.com", "report_count": 28 },
    { "org_name": "Yahoo", "org_email": "dmarchelp@yahooinc.com", "report_count": 14 }
  ],
  "meta": { "limit": 50, "offset": 0 }
}
```

**404**

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

---
Fuente: https://emailit.com/es/docs/api-reference/dmarc/reporters/