# Rapports DMARC API

> Consultez les rapports DMARC agrégés et forensiques d’un domaine d’envoi, ou importez les vôtres.

URL de base : `https://api.emailit.com/v2`. Authentifiez-vous avec `Authorization: Bearer <API key>`.

## Lister les rapports agrégés — GET /domains/{id}/dmarc/reports

> Listez les rapports DMARC reçus par Emailit ou importés par vous pour un domaine d’envoi, filtrés par type, statut, émetteur de rapports et date.

# Lister les rapports agrégés

Renvoie les rapports DMARC d’un domaine d’envoi, du plus récent au plus ancien. Nécessite une clé API de portée `full`.

Emailit ne collecte les rapports que pour les domaines dont les rapports DMARC sont activés (`dmarc_reports: true` dans [Mettre à jour un domaine](/fr/docs/api-reference/domains/update/)), ce qui nécessite le forfait Pro ou supérieur. Consultez [Rapports DMARC](/fr/docs/dmarc/reports/).

La liste inclut aussi les rapports forensiques. Transmettez `type=aggregate` pour ne lister que les rapports agrégés, ou utilisez [Lister les rapports forensiques](/fr/docs/api-reference/dmarc/forensic/) pour obtenir le détail des rapports forensiques.

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

## Paramètres de chemin

- `id` (string, obligatoire): L’ID du domaine (`dom_…`) ou le nom de domaine, par exemple `acme.com`.

## Paramètres de requête

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

- `status` (string): Statut de traitement : `pending`, `processed`, `failed` ou `duplicate`.

- `org_name` (string): Nom exact de l’organisation émettrice du rapport, par exemple `google.com`.

- `from` (string): Uniquement les rapports dont la période commence à cette date (ou date et heure) ou après, par exemple `2026-09-01`.

- `to` (string): Uniquement les rapports dont la période commence à cette date (ou date et heure) ou avant. Une date sans heure inclut toute la journée (UTC).

- `limit` (integer): Nombre de rapports par page, 100 au maximum.

- `offset` (integer): Nombre de rapports à ignorer.

- `match`, `order`, `direction`: voir [Filtrage et tri](https://emailit.com/fr/docs/api-reference/filtering/).

Les filtres génériques `key.condition=value` fonctionnent aussi sur `type`, `status`, `org_name` et `created_at` ; ce sont aussi les clés de tri disponibles pour `order`. Consultez [Filtrage et tri](/fr/docs/api-reference/filtering/).

## Réponse

Renvoie `data`, un tableau d’objets rapport, et `meta` avec `total`, `limit` et `offset`.

- `id` (string): ID du rapport, avec le préfixe `dmr_`.

- `type` (string | null): `aggregate` ou `forensic`. `null` tant qu’un rapport importé n’a pas été traité.

- `source` (string): `smtp` pour les rapports reçus par Emailit à l’adresse de réception des rapports du domaine, `upload` pour les rapports que vous avez [importés](/fr/docs/api-reference/dmarc/upload/).

- `status` (string): `pending`, `processed`, `failed` (voir `error_message`) ou `duplicate` (le même rapport a déjà été traité).

- `org_name, org_email` (string | null): L’organisation qui a envoyé le rapport et son adresse de contact.

- `external_report_id` (string | null): L’ID que l’émetteur a lui-même attribué au rapport.

- `date_range_begin, date_range_end` (string | null): La période couverte par le rapport, en UTC.

- `policy_domain, adkim, aspf, p, sp, pct, fo` (string | integer | null): La politique DMARC trouvée par l’émetteur pour votre domaine : modes d’alignement (`r` ou `s`), politique et politique des sous-domaines (`none`, `quarantine`, `reject`), pourcentage et options de signalement des échecs.

- `original_filename` (string | null): Nom du fichier d’un rapport importé.

- `envelope_to` (string | null): L’adresse de réception des rapports à laquelle le rapport a été envoyé.

- `created_at, updated_at, processed_at` (string | null): Horodatages en UTC.

Renvoie `404` si le domaine n’existe pas dans l’espace de travail.

**Requête** `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"
}
```

---
Source: https://emailit.com/fr/docs/api-reference/dmarc/list/

## Récupérer un rapport — GET /domains/{id}/dmarc/reports/{report_id}

> Récupérez un rapport DMARC d’un domaine. Les rapports agrégés incluent leurs enregistrements : IP sources, volumes et résultats SPF et DKIM.

# Récupérer un rapport

Récupère un rapport DMARC. Pour un rapport agrégé, la réponse inclut ses enregistrements, un par source d’envoi, triés par nombre de messages. Pour un rapport forensique, elle inclut l’échantillon de l’échec dans `forensic`. Nécessite une clé API de portée `full`.

Les rapports n’arrivent que pour les domaines dont les rapports DMARC sont activés, ce qui nécessite le forfait Pro ou supérieur.

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

## Paramètres de chemin

- `id` (string, obligatoire): L’ID du domaine (`dom_…`) ou le nom de domaine.

- `report_id` (string, obligatoire): L’ID du rapport (`dmr_…`).

## Paramètres de requête

- `limit` (integer): Nombre d’enregistrements à renvoyer, 500 au maximum. Rapports agrégés uniquement.

- `offset` (integer): Nombre d’enregistrements à ignorer. Rapports agrégés uniquement.

## Réponse

Renvoie l’objet rapport (voir [Lister les rapports agrégés](/fr/docs/api-reference/dmarc/list/)), ainsi que :

- `records` (object[]): Rapports agrégés uniquement. Une entrée par combinaison d’IP source et de résultats. Voir les champs ci-dessous.

- `meta` (object): Rapports agrégés uniquement. `total` (nombre d’enregistrements), `limit` et `offset`.

- `forensic` (object | null): Rapports forensiques uniquement. Les mêmes champs que [Récupérer un rapport forensique](/fr/docs/api-reference/dmarc/forensic-get/).

Chaque enregistrement comporte :

- `source_ip` (string): Adresse IP qui a envoyé les messages.

- `count` (integer): Nombre de messages de cette source avec ces résultats.

- `country_code, country_name, continent_code, asn, as_org, latitude, longitude` (string | integer | number | null): Localisation et réseau de l’IP source. `null` si l’IP n’a pas pu être localisée.

- `disposition` (string): Ce qu’a fait le serveur destinataire : `none`, `quarantine` ou `reject`.

- `dkim, spf` (string): Résultats alignés sur DMARC tels qu’évalués par le serveur destinataire : `pass` ou `fail`.

- `header_from, envelope_from, envelope_to` (string | null): Identifiants issus du rapport.

- `dkim_domain, dkim_selector, dkim_result` (string | null): La signature DKIM vérifiée par le serveur destinataire et son résultat brut.

- `spf_domain, spf_result` (string | null): Le domaine SPF vérifié par le serveur destinataire et son résultat brut.

- `reason_type, reason_comment` (string | null): Motif de dérogation à la politique, par exemple `forwarded` ou `mailing_list`.

Renvoie `404` si le domaine ou le rapport n’existe pas.

**Requête** `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"
}
```

---
Source: https://emailit.com/fr/docs/api-reference/dmarc/get/

## Importer un rapport — POST /domains/{id}/dmarc/reports

> Importez un rapport DMARC agrégé (XML, gzip ou zip) ou forensique (EML) pour un domaine. Le traitement s’effectue en arrière-plan.

# Importer un rapport

Importe un rapport DMARC que vous avez reçu ailleurs, par exemple dans une boîte aux lettres que vous utilisiez avant Emailit. Nécessite une clé API de portée `full`.

Emailit enregistre le fichier et le traite en arrière-plan : la réponse a le statut `pending`, et le rapport passe à `processed`, `failed` ou `duplicate` (déjà importé) peu après. Vérifiez-le avec [Récupérer un rapport](/fr/docs/api-reference/dmarc/get/). Les rapports qu’Emailit reçoit par e-mail nécessitent que les rapports DMARC soient activés pour le domaine (forfait Pro ou supérieur) ; les rapports importés sont traités dans tous les cas.

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

## Paramètres de chemin

- `id` (string, obligatoire): L’ID du domaine (`dom_…`) ou le nom de domaine.

## Paramètres du corps

Envoyez exactement l’un des deux champs `content_base64` ou `content`. Le rapport décodé peut atteindre 10 Mo.

- `content_base64` (string): Le fichier, encodé en Base64. Utilisez-le pour les formats binaires : rapports agrégés en `.xml`, `.xml.gz` ou `.zip`, et rapports forensiques en `.eml` (AFRF).

- `content` (string): Le rapport en texte UTF-8, par exemple le XML agrégé brut.

- `filename` (string): Nom de fichier d’origine, enregistré dans `original_filename`.

## Réponse

Renvoie `202 Accepted` avec le nouvel objet rapport. `type` vaut `null` jusqu’à ce que le traitement le détecte.

| Statut | Cas |
| --- | --- |
| `400` | Ni `content_base64` ni `content` n’est défini, ou la valeur est vide. |
| `404` | Le domaine n’existe pas dans l’espace de travail. |
| `413` | Le rapport décodé dépasse 10 Mo. |

**Requête** `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"
}
```

---
Source: https://emailit.com/fr/docs/api-reference/dmarc/upload/

## Lister les rapports forensiques — GET /domains/{id}/dmarc/forensic

> Listez les rapports DMARC forensiques (rapports d’échec) traités d’un domaine : IP source, localisation, type d’échec et détails du message.

# Lister les rapports forensiques

Renvoie les rapports forensiques (RUF) traités d’un domaine, du plus récent au plus ancien. Chacun décrit un message qui a échoué à DMARC. Les en-têtes ne figurent pas dans la liste ; [récupérez un rapport forensique](/fr/docs/api-reference/dmarc/forensic-get/) pour les consulter. Nécessite une clé API de portée `full`.

Les rapports n’arrivent que pour les domaines dont les rapports DMARC sont activés, ce qui nécessite le forfait Pro ou supérieur. Peu de fournisseurs de messagerie envoient des rapports forensiques, et ceux qui le font peuvent y inclure des données personnelles issues du message en échec.

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

## Paramètres de chemin

- `id` (string, obligatoire): L’ID du domaine (`dom_…`) ou le nom de domaine.

## Paramètres de requête

- `from` (string): Uniquement les rapports dont la période commence à cette date (ou date et heure) ou après.

- `to` (string): Uniquement les rapports dont la période commence à cette date (ou date et heure) ou avant. Une date sans heure inclut toute la journée (UTC).

- `limit` (integer): Nombre de rapports par page, 100 au maximum.

- `offset` (integer): Nombre de rapports à ignorer.

Les filtres génériques `key.condition=value` fonctionnent aussi sur `org_name` et `created_at`, avec `match`, `order` et `direction`. Consultez [Filtrage et tri](/fr/docs/api-reference/filtering/).

## Réponse

Renvoie `data` et `meta` (`total`, `limit`, `offset`). Chaque élément comporte :

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

- `id, report_id` (string): L’ID du rapport (`dmr_…`).

- `arrival_date` (string | null): Date d’arrivée du message en échec sur le serveur destinataire.

- `source_ip` (string | null): Adresse IP qui a envoyé le message.

- `country_code, country_name, continent_code, asn, as_org, latitude, longitude` (string | integer | number | null): Localisation et réseau de l’IP source.

- `auth_failure` (string | null): Ce qui a échoué, par exemple `dmarc`, `spf` ou `dkim`.

- `authentication_results` (string | null): L’en-tête `Authentication-Results` du serveur destinataire.

- `original_mail_from, original_rcpt_to, subject` (string | null): Expéditeur d’enveloppe, destinataire et objet du message en échec.

- `delivery_result` (string | null): Ce qu’a fait le serveur destinataire, par exemple `reject` ou `delivered`.

- `reported_domain` (string | null): Votre domaine tel qu’il est nommé dans le rapport.

- `created_at` (string | null): Date à laquelle Emailit a enregistré le rapport.

**Requête** `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"
}
```

---
Source: https://emailit.com/fr/docs/api-reference/dmarc/forensic/

## Récupérer un rapport forensique — GET /domains/{id}/dmarc/forensic/{report_id}

> Récupérez un rapport DMARC forensique d’un domaine, y compris les en-têtes du message qui a échoué à l’authentification.

# Récupérer un rapport forensique

Récupère un rapport forensique (RUF) avec les en-têtes du message qui a échoué à DMARC. Nécessite une clé API de portée `full`. Les rapports forensiques peuvent contenir des données personnelles, comme les adresses des destinataires et les objets des messages.

Les rapports n’arrivent que pour les domaines dont les rapports DMARC sont activés, ce qui nécessite le forfait Pro ou supérieur.

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

## Paramètres de chemin

- `id` (string, obligatoire): L’ID du domaine (`dom_…`) ou le nom de domaine.

- `report_id` (string, obligatoire): L’ID (`dmr_…`) d’un rapport forensique.

## Réponse

Renvoie le rapport forensique avec les champs décrits dans [Lister les rapports forensiques](/fr/docs/api-reference/dmarc/forensic/), ainsi que :

- `headers` (string | null): Les en-têtes d’origine du message inclus dans le rapport, en texte brut.

Renvoie `404` si le domaine n’existe pas, si le rapport n’existe pas ou s’il ne s’agit pas d’un rapport forensique traité.

**Requête** `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"
}
```

---
Source: https://emailit.com/fr/docs/api-reference/dmarc/forensic-get/

## Récupérer les statistiques — GET /domains/{id}/dmarc/stats

> Obtenez les totaux DMARC d’un domaine : volume, taux de réussite, actions appliquées, résultats SPF et DKIM, séries quotidiennes, principaux pays et réseaux.

# Récupérer les statistiques

Résume les rapports DMARC agrégés d’un domaine sur une période : le volume d’e-mails que les serveurs destinataires ont reçu de votre domaine, la part qui a réussi et sa provenance. Ce sont les données affichées dans l’onglet Overview sous **Email API → DMARC reports**. Nécessite une clé API de portée `full`.

Les rapports n’arrivent que pour les domaines dont les rapports DMARC sont activés (`dmarc_reports: true` dans [Mettre à jour un domaine](/fr/docs/api-reference/domains/update/)), ce qui nécessite le forfait Pro ou supérieur.

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

## Paramètres de chemin

- `id` (string, obligatoire): L’ID du domaine (`dom_…`) ou le nom de domaine.

## Paramètres de requête

- `from` (string): Ne compte que les périodes de rapport qui commencent à cette date (ou date et heure) ou après, par exemple `2026-09-01`. Sans ce paramètre, tous les rapports sont comptés.

- `to` (string): Ne compte que les périodes de rapport qui commencent à cette date (ou date et heure) ou avant. Une date sans heure inclut toute la journée (UTC).

## Réponse

Renvoie `data` avec les champs suivants. Un message est considéré comme réussi lorsque son résultat DKIM ou SPF aligné sur DMARC est `pass`.

- `total_volume` (integer): Messages signalés.

- `pass_volume, fail_volume` (integer): Messages ayant réussi et messages ayant échoué.

- `pass_rate` (number): Pourcentage de messages ayant réussi, arrondi à deux décimales. `0` en l’absence de volume.

- `report_count` (integer): Rapports traités sur la période, agrégés et forensiques.

- `dispositions` (object[]): Volume par action du serveur destinataire : `disposition` (`none`, `quarantine`, `reject`) et `volume`.

- `dkim, spf` (object[]): Volume par résultat aligné : `result` (`pass` ou `fail`) et `volume`.

- `daily` (object[]): Une entrée par jour (`date` au format `YYYY-MM-DD`, UTC) avec `volume`, `pass_volume` et `fail_volume`.

- `daily_dispositions, daily_dkim, daily_spf` (object[]): Les mêmes répartitions par jour : `date`, `disposition` ou `result`, et `volume`.

- `top_countries` (object[]): 10 pays au maximum, classés par volume : `country_code`, `country_name`, `volume`, `pass_volume`, `fail_volume`.

- `top_asns` (object[]): 10 réseaux au maximum, classés par volume : `asn`, `as_org`, `volume`, `pass_volume`, `fail_volume`.

- `unknown_geo_volume` (integer): Messages provenant d’adresses IP qui n’ont pas pu être localisées.

Renvoie `404` si le domaine n’existe pas dans l’espace de travail.

**Requête** `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"
}
```

---
Source: https://emailit.com/fr/docs/api-reference/dmarc/stats/

## Lister les sources d’envoi — GET /domains/{id}/dmarc/sources

> Listez les adresses IP qui ont envoyé des e-mails au nom de votre domaine selon les rapports DMARC, avec le volume et le nombre de réussites et d’échecs par IP.

# Lister les sources d’envoi

Regroupe les données DMARC agrégées d’un domaine par adresse IP source, du volume le plus élevé au plus faible. Utilisez-le pour repérer les serveurs qui envoient au nom de votre domaine mais échouent à SPF et à DKIM. Nécessite une clé API de portée `full`.

Les rapports n’arrivent que pour les domaines dont les rapports DMARC sont activés, ce qui nécessite le forfait Pro ou supérieur.

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

## Paramètres de chemin

- `id` (string, obligatoire): L’ID du domaine (`dom_…`) ou le nom de domaine.

## Paramètres de requête

- `from` (string): Ne compte que les périodes de rapport qui commencent à cette date (ou date et heure) ou après.

- `to` (string): Ne compte que les périodes de rapport qui commencent à cette date (ou date et heure) ou avant. Une date sans heure inclut toute la journée (UTC).

- `limit` (integer): Nombre de sources par page, 200 au maximum.

- `offset` (integer): Nombre de sources à ignorer.

## Réponse

Renvoie `data` et `meta` (`limit`, `offset`). La réponse n’indique pas de total : demandez la page suivante jusqu’à ce que `data` contienne moins d’éléments que `limit`. Chaque source comporte :

- `source_ip` (string): L’adresse IP d’envoi.

- `country_code, country_name` (string | null): Localisation de l’IP.

- `asn, as_org` (integer | string | null): Le réseau auquel appartient l’IP.

- `volume` (integer): Messages signalés en provenance de cette IP.

- `pass_volume, fail_volume` (integer): Messages ayant réussi DKIM ou SPF aligné sur DMARC, et messages ayant échoué aux deux.

Renvoie `404` si le domaine n’existe pas dans l’espace de travail.

**Requête** `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"
}
```

---
Source: https://emailit.com/fr/docs/api-reference/dmarc/sources/

## Lister les pays — GET /domains/{id}/dmarc/countries

> Listez les pays depuis lesquels ont été envoyés des e-mails se réclamant de votre domaine, avec le volume DMARC et le nombre de réussites et d’échecs.

# Lister les pays

Regroupe les données DMARC agrégées d’un domaine par pays de l’IP d’envoi, du volume le plus élevé au plus faible. Nécessite une clé API de portée `full`.

Les rapports n’arrivent que pour les domaines dont les rapports DMARC sont activés, ce qui nécessite le forfait Pro ou supérieur.

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

## Paramètres de chemin

- `id` (string, obligatoire): L’ID du domaine (`dom_…`) ou le nom de domaine.

## Paramètres de requête

- `from` (string): Ne compte que les périodes de rapport qui commencent à cette date (ou date et heure) ou après.

- `to` (string): Ne compte que les périodes de rapport qui commencent à cette date (ou date et heure) ou avant. Une date sans heure inclut toute la journée (UTC).

- `limit` (integer): Nombre de pays par page, 200 au maximum.

- `offset` (integer): Nombre de pays à ignorer.

## Réponse

Renvoie `data` et `meta` (`limit`, `offset`). Chaque pays comporte :

- `country_code` (string | null): Code ISO 3166-1 alpha-2. `null` regroupe les adresses IP qui n’ont pas pu être localisées.

- `country_name` (string | null): Nom du pays.

- `continent_code` (string | null): Code du continent, par exemple `EU`.

- `volume` (integer): Messages signalés en provenance de ce pays.

- `pass_volume, fail_volume` (integer): Messages ayant réussi DKIM ou SPF aligné sur DMARC, et messages ayant échoué aux deux.

Renvoie `404` si le domaine n’existe pas dans l’espace de travail.

**Requête** `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"
}
```

---
Source: https://emailit.com/fr/docs/api-reference/dmarc/countries/

## Lister les réseaux (ASN) — GET /domains/{id}/dmarc/asns

> Listez les réseaux (systèmes autonomes) qui ont envoyé des e-mails au nom de votre domaine, avec le volume DMARC et le nombre de réussites et d’échecs par ASN.

# Lister les réseaux (ASN)

Regroupe les données DMARC agrégées d’un domaine par système autonome (ASN) de l’IP d’envoi, du volume le plus élevé au plus faible. Un réseau correspond généralement à un hébergeur ou à un service d’e-mail, ce qui permet de reconnaître plus facilement les expéditeurs légitimes. Nécessite une clé API de portée `full`.

Les rapports n’arrivent que pour les domaines dont les rapports DMARC sont activés, ce qui nécessite le forfait Pro ou supérieur.

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

## Paramètres de chemin

- `id` (string, obligatoire): L’ID du domaine (`dom_…`) ou le nom de domaine.

## Paramètres de requête

- `from` (string): Ne compte que les périodes de rapport qui commencent à cette date (ou date et heure) ou après.

- `to` (string): Ne compte que les périodes de rapport qui commencent à cette date (ou date et heure) ou avant. Une date sans heure inclut toute la journée (UTC).

- `limit` (integer): Nombre de réseaux par page, 200 au maximum.

- `offset` (integer): Nombre de réseaux à ignorer.

## Réponse

Renvoie `data` et `meta` (`limit`, `offset`). Chaque réseau comporte :

- `asn` (integer | null): Numéro de système autonome. `null` regroupe les adresses IP qui n’ont pas pu être identifiées.

- `as_org` (string | null): Nom de l’organisation qui exploite le réseau.

- `volume` (integer): Messages signalés en provenance de ce réseau.

- `pass_volume, fail_volume` (integer): Messages ayant réussi DKIM ou SPF aligné sur DMARC, et messages ayant échoué aux deux.

Renvoie `404` si le domaine n’existe pas dans l’espace de travail.

**Requête** `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"
}
```

---
Source: https://emailit.com/fr/docs/api-reference/dmarc/asns/

## Lister les émetteurs de rapports — GET /domains/{id}/dmarc/reporters

> Listez les organisations, comme Google ou Microsoft, qui ont envoyé des rapports DMARC agrégés pour votre domaine, avec le nombre de rapports.

# Lister les émetteurs de rapports

Liste les organisations qui ont envoyé des rapports agrégés traités pour un domaine, par nombre de rapports décroissant. Nécessite une clé API de portée `full`.

Les rapports n’arrivent que pour les domaines dont les rapports DMARC sont activés, ce qui nécessite le forfait Pro ou supérieur.

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

## Paramètres de chemin

- `id` (string, obligatoire): L’ID du domaine (`dom_…`) ou le nom de domaine.

## Paramètres de requête

- `from` (string): Ne compte que les rapports dont la période commence à cette date (ou date et heure) ou après.

- `to` (string): Ne compte que les rapports dont la période commence à cette date (ou date et heure) ou avant. Une date sans heure inclut toute la journée (UTC).

- `limit` (integer): Nombre d’émetteurs par page, 200 au maximum.

- `offset` (integer): Nombre d’émetteurs à ignorer.

## Réponse

Renvoie `data` et `meta` (`limit`, `offset`). Chaque émetteur comporte :

- `org_name` (string | null): Nom de l’organisation émettrice, par exemple `google.com`. Transmettez-le comme `org_name` à [Lister les rapports agrégés](/fr/docs/api-reference/dmarc/list/) pour voir ses rapports.

- `org_email` (string | null): L’adresse de contact de l’émetteur.

- `report_count` (integer): Nombre de rapports agrégés traités provenant de cette organisation.

Renvoie `404` si le domaine n’existe pas dans l’espace de travail.

**Requête** `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"
}
```

---
Source: https://emailit.com/fr/docs/api-reference/dmarc/reporters/