# Report DMARC API

> Leggi i report DMARC aggregati e forensi di un dominio di invio, o carica i tuoi.

URL di base: `https://api.emailit.com/v2`. Autenticati con `Authorization: Bearer <API key>`.

## Elenca i report aggregati — GET /domains/{id}/dmarc/reports

> Elenca i report DMARC che Emailit ha ricevuto o che hai caricato per un dominio di invio, filtrati per tipo, stato, mittente del report e data.

# Elenca i report aggregati

Restituisce i report DMARC di un dominio di invio, a partire dal più recente. Richiede una chiave API con il permesso `full`.

Emailit raccoglie i report solo per i domini con i report DMARC attivati (`dmarc_reports: true` in [Aggiorna un dominio](/it/docs/api-reference/domains/update/)), che richiedono il piano Pro o superiore. Vedi [Report DMARC](/it/docs/dmarc/reports/).

L’elenco include anche i report forensi. Passa `type=aggregate` per elencare solo i report aggregati, oppure usa [Elenca i report forensi](/it/docs/api-reference/dmarc/forensic/) per i dettagli forensi.

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

## Parametri di percorso

- `id` (string, obbligatorio): L’ID del dominio (`dom_…`) o il nome del dominio, ad esempio `acme.com`.

## Parametri di query

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

- `status` (string): Stato dell’elaborazione: `pending`, `processed`, `failed` o `duplicate`.

- `org_name` (string): Nome esatto dell’organizzazione che invia il report, ad esempio `google.com`.

- `from` (string): Solo i report il cui periodo inizia in questa data (o data e ora) o dopo, ad esempio `2026-09-01`.

- `to` (string): Solo i report il cui periodo inizia in questa data (o data e ora) o prima. Una data senza ora include l’intera giornata (UTC).

- `limit` (integer): Report per pagina, fino a 100.

- `offset` (integer): Numero di report da saltare.

- `match`, `order`, `direction`: vedi [Filtri e ordinamento](https://emailit.com/it/docs/api-reference/filtering/).

I filtri generici `key.condition=value` funzionano anche su `type`, `status`, `org_name` e `created_at`, che sono anche le chiavi di ordinamento per `order`. Vedi [Filtri e ordinamento](/it/docs/api-reference/filtering/).

## Restituisce

Restituisce `data`, un array di oggetti report, e `meta` con `total`, `limit` e `offset`.

- `id` (string): ID del report, con prefisso `dmr_`.

- `type` (string | null): `aggregate` o `forensic`. `null` finché un report caricato non viene elaborato.

- `source` (string): `smtp` per i report che Emailit ha ricevuto all’indirizzo di raccolta dei report del dominio, `upload` per i report che hai [caricato](/it/docs/api-reference/dmarc/upload/).

- `status` (string): `pending`, `processed`, `failed` (vedi `error_message`) o `duplicate` (lo stesso report era già stato elaborato).

- `org_name, org_email` (string | null): L’organizzazione che ha inviato il report e il suo indirizzo di contatto.

- `external_report_id` (string | null): L’ID del report assegnato dal mittente del report.

- `date_range_begin, date_range_end` (string | null): Il periodo coperto dal report, in UTC.

- `policy_domain, adkim, aspf, p, sp, pct, fo` (string | integer | null): La policy DMARC che il mittente del report ha trovato per il tuo dominio: modalità di allineamento (`r` o `s`), policy e policy dei sottodomini (`none`, `quarantine`, `reject`), percentuale e opzioni per i report di errore.

- `original_filename` (string | null): Nome del file di un report caricato.

- `envelope_to` (string | null): L’indirizzo di raccolta a cui è stato inviato il report.

- `created_at, updated_at, processed_at` (string | null): Timestamp in UTC.

Restituisce `404` se il dominio non esiste nel workspace.

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

---
Fonte: https://emailit.com/it/docs/api-reference/dmarc/list/

## Recupera un report — GET /domains/{id}/dmarc/reports/{report_id}

> Recupera un report DMARC di un dominio. I report aggregati includono i loro record: IP di origine, volumi ed esiti SPF e DKIM.

# Recupera un report

Recupera un report DMARC. Per un report aggregato, la risposta include i suoi record, uno per sorgente di invio, ordinati per numero di messaggi. Per un report forense, include il campione dell’errore in `forensic`. Richiede una chiave API con il permesso `full`.

I report arrivano solo per i domini con i report DMARC attivati, che richiedono il piano Pro o superiore.

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

## Parametri di percorso

- `id` (string, obbligatorio): L’ID del dominio (`dom_…`) o il nome del dominio.

- `report_id` (string, obbligatorio): L’ID del report (`dmr_…`).

## Parametri di query

- `limit` (integer): Record da restituire, fino a 500. Solo per i report aggregati.

- `offset` (integer): Record da saltare. Solo per i report aggregati.

## Restituisce

Restituisce l’oggetto report (vedi [Elenca i report aggregati](/it/docs/api-reference/dmarc/list/)) più:

- `records` (object[]): Solo per i report aggregati. Una voce per ogni combinazione di IP di origine ed esito. Vedi i campi qui sotto.

- `meta` (object): Solo per i report aggregati. `total` (numero di record), `limit` e `offset`.

- `forensic` (object | null): Solo per i report forensi. Gli stessi campi di [Recupera un report forense](/it/docs/api-reference/dmarc/forensic-get/).

Ogni record ha:

- `source_ip` (string): Indirizzo IP che ha inviato i messaggi.

- `count` (integer): Numero di messaggi da questa sorgente con questi esiti.

- `country_code, country_name, continent_code, asn, as_org, latitude, longitude` (string | integer | number | null): Posizione e rete dell’IP di origine. `null` quando non è stato possibile localizzare l’IP.

- `disposition` (string): Cosa ha fatto il server ricevente: `none`, `quarantine` o `reject`.

- `dkim, spf` (string): Esiti allineati a DMARC secondo la valutazione del server ricevente: `pass` o `fail`.

- `header_from, envelope_from, envelope_to` (string | null): Identificatori presenti nel report.

- `dkim_domain, dkim_selector, dkim_result` (string | null): La firma DKIM controllata dal server ricevente e il suo esito grezzo.

- `spf_domain, spf_result` (string | null): Il dominio SPF controllato dal server ricevente e il suo esito grezzo.

- `reason_type, reason_comment` (string | null): Motivo della deroga alla policy, ad esempio `forwarded` o `mailing_list`.

Restituisce `404` se il dominio o il report non esiste.

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

---
Fonte: https://emailit.com/it/docs/api-reference/dmarc/get/

## Carica un report — POST /domains/{id}/dmarc/reports

> Carica un report DMARC aggregato (XML, gzip o zip) o forense (EML) per un dominio. L’elaborazione avviene in background.

# Carica un report

Carica un report DMARC che hai ricevuto altrove, ad esempio in una casella che usavi prima di Emailit. Richiede una chiave API con il permesso `full`.

Emailit salva il file e lo elabora in background: la risposta ha lo stato `pending`, e poco dopo il report diventa `processed`, `failed` o `duplicate` (già importato). Controllalo con [Recupera un report](/it/docs/api-reference/dmarc/get/). Per i report che Emailit riceve via email, il dominio deve avere i report DMARC attivati (piano Pro o superiore); i report caricati vengono elaborati in ogni caso.

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

## Parametri di percorso

- `id` (string, obbligatorio): L’ID del dominio (`dom_…`) o il nome del dominio.

## Parametri del corpo

Invia uno solo tra `content_base64` e `content`. Il report decodificato può pesare fino a 10 MB.

- `content_base64` (string): Il file, codificato in Base64. Usalo per i formati binari: report aggregati in `.xml`, `.xml.gz` o `.zip`, e report forensi in `.eml` (AFRF).

- `content` (string): Il report come testo UTF-8, ad esempio l’XML aggregato grezzo.

- `filename` (string): Nome originale del file, salvato come `original_filename`.

## Restituisce

Restituisce `202 Accepted` con il nuovo oggetto report. `type` è `null` finché l’elaborazione non lo rileva.

| Stato | Quando |
| --- | --- |
| `400` | Non è impostato né `content_base64` né `content`, oppure il valore è vuoto. |
| `404` | Il dominio non esiste nel workspace. |
| `413` | Il report decodificato supera i 10 MB. |

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

---
Fonte: https://emailit.com/it/docs/api-reference/dmarc/upload/

## Elenca i report forensi — GET /domains/{id}/dmarc/forensic

> Elenca i report DMARC forensi (di errore) elaborati per un dominio: IP di origine, posizione, tipo di errore e dettagli del messaggio.

# Elenca i report forensi

Restituisce i report forensi (RUF) elaborati per un dominio, a partire dal più recente. Ognuno descrive un messaggio che non ha superato DMARC. Gli header non sono inclusi nell’elenco; per vederli, [recupera un report forense](/it/docs/api-reference/dmarc/forensic-get/). Richiede una chiave API con il permesso `full`.

I report arrivano solo per i domini con i report DMARC attivati, che richiedono il piano Pro o superiore. Pochi provider di posta inviano report forensi, e quelli che lo fanno possono includere dati personali del messaggio non riuscito.

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

## Parametri di percorso

- `id` (string, obbligatorio): L’ID del dominio (`dom_…`) o il nome del dominio.

## Parametri di query

- `from` (string): Solo i report il cui periodo inizia in questa data (o data e ora) o dopo.

- `to` (string): Solo i report il cui periodo inizia in questa data (o data e ora) o prima. Una data senza ora include l’intera giornata (UTC).

- `limit` (integer): Report per pagina, fino a 100.

- `offset` (integer): Numero di report da saltare.

I filtri generici `key.condition=value` funzionano anche su `org_name` e `created_at`, con `match`, `order` e `direction`. Vedi [Filtri e ordinamento](/it/docs/api-reference/filtering/).

## Restituisce

Restituisce `data` e `meta` (`total`, `limit`, `offset`). Ogni elemento ha:

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

- `id, report_id` (string): L’ID del report (`dmr_…`).

- `arrival_date` (string | null): Quando il messaggio non riuscito ha raggiunto il server ricevente.

- `source_ip` (string | null): Indirizzo IP che ha inviato il messaggio.

- `country_code, country_name, continent_code, asn, as_org, latitude, longitude` (string | integer | number | null): Posizione e rete dell’IP di origine.

- `auth_failure` (string | null): Cosa non è stato superato, ad esempio `dmarc`, `spf` o `dkim`.

- `authentication_results` (string | null): L’header `Authentication-Results` del server ricevente.

- `original_mail_from, original_rcpt_to, subject` (string | null): Mittente della busta, destinatario e oggetto del messaggio non riuscito.

- `delivery_result` (string | null): Cosa ha fatto il server ricevente, ad esempio `reject` o `delivered`.

- `reported_domain` (string | null): Il tuo dominio come indicato nel report.

- `created_at` (string | null): Quando Emailit ha salvato il report.

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

---
Fonte: https://emailit.com/it/docs/api-reference/dmarc/forensic/

## Recupera un report forense — GET /domains/{id}/dmarc/forensic/{report_id}

> Recupera un report DMARC forense di un dominio, compresi gli header del messaggio che non ha superato l’autenticazione.

# Recupera un report forense

Recupera un report forense (RUF) con gli header del messaggio che non ha superato DMARC. Richiede una chiave API con il permesso `full`. I report forensi possono contenere dati personali, come gli indirizzi dei destinatari e gli oggetti.

I report arrivano solo per i domini con i report DMARC attivati, che richiedono il piano Pro o superiore.

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

## Parametri di percorso

- `id` (string, obbligatorio): L’ID del dominio (`dom_…`) o il nome del dominio.

- `report_id` (string, obbligatorio): L’ID di un report forense (`dmr_…`).

## Restituisce

Restituisce il report forense con i campi descritti in [Elenca i report forensi](/it/docs/api-reference/dmarc/forensic/), più:

- `headers` (string | null): Gli header originali del messaggio inclusi nel report, come testo grezzo.

Restituisce `404` se il dominio non esiste, se il report non esiste o se non è un report forense elaborato.

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

---
Fonte: https://emailit.com/it/docs/api-reference/dmarc/forensic-get/

## Recupera le statistiche — GET /domains/{id}/dmarc/stats

> Ottieni i totali DMARC di un dominio: volume, tasso di superamento, azioni dei server riceventi, esiti SPF e DKIM, serie giornaliere e principali paesi e reti.

# Recupera le statistiche

Riepiloga i report DMARC aggregati di un dominio in un intervallo di date: quanta posta dal tuo dominio hanno visto i server riceventi, quanta ha superato il controllo e da dove proveniva. Sono i dati alla base della scheda Overview in **Email API → DMARC reports**. Richiede una chiave API con il permesso `full`.

I report arrivano solo per i domini con i report DMARC attivati (`dmarc_reports: true` in [Aggiorna un dominio](/it/docs/api-reference/domains/update/)), che richiedono il piano Pro o superiore.

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

## Parametri di percorso

- `id` (string, obbligatorio): L’ID del dominio (`dom_…`) o il nome del dominio.

## Parametri di query

- `from` (string): Conta solo i periodi dei report che iniziano in questa data (o data e ora) o dopo, ad esempio `2026-09-01`. Se lo ometti, vengono contati tutti i report.

- `to` (string): Conta solo i periodi dei report che iniziano in questa data (o data e ora) o prima. Una data senza ora include l’intera giornata (UTC).

## Restituisce

Restituisce `data` con questi campi. Un messaggio supera il controllo quando il suo esito DKIM o SPF allineato a DMARC è `pass`.

- `total_volume` (integer): Messaggi segnalati.

- `pass_volume, fail_volume` (integer): Messaggi che hanno superato e non hanno superato il controllo.

- `pass_rate` (number): Percentuale di messaggi che hanno superato il controllo, arrotondata a due decimali. `0` quando non c’è volume.

- `report_count` (integer): Report elaborati nell’intervallo, aggregati e forensi.

- `dispositions` (object[]): Volume per azione del server ricevente: `disposition` (`none`, `quarantine`, `reject`) e `volume`.

- `dkim, spf` (object[]): Volume per esito allineato: `result` (`pass` o `fail`) e `volume`.

- `daily` (object[]): Una voce per giorno (`date` nel formato `YYYY-MM-DD`, UTC) con `volume`, `pass_volume` e `fail_volume`.

- `daily_dispositions, daily_dkim, daily_spf` (object[]): Le stesse suddivisioni per giorno: `date`, `disposition` o `result`, e `volume`.

- `top_countries` (object[]): Fino a 10 paesi per volume: `country_code`, `country_name`, `volume`, `pass_volume`, `fail_volume`.

- `top_asns` (object[]): Fino a 10 reti per volume: `asn`, `as_org`, `volume`, `pass_volume`, `fail_volume`.

- `unknown_geo_volume` (integer): Messaggi da indirizzi IP che non è stato possibile localizzare.

Restituisce `404` se il dominio non esiste nel workspace.

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

---
Fonte: https://emailit.com/it/docs/api-reference/dmarc/stats/

## Elenca le sorgenti di invio — GET /domains/{id}/dmarc/sources

> Elenca gli indirizzi IP che, secondo i report DMARC, hanno inviato posta a nome del tuo dominio, con il volume e il numero di messaggi che superano o non superano il controllo per ogni IP.

# Elenca le sorgenti di invio

Raggruppa i dati DMARC aggregati di un dominio per indirizzo IP di origine, a partire dal volume più alto. Usalo per individuare i server che inviano a nome del tuo dominio ma non superano SPF e DKIM. Richiede una chiave API con il permesso `full`.

I report arrivano solo per i domini con i report DMARC attivati, che richiedono il piano Pro o superiore.

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

## Parametri di percorso

- `id` (string, obbligatorio): L’ID del dominio (`dom_…`) o il nome del dominio.

## Parametri di query

- `from` (string): Conta solo i periodi dei report che iniziano in questa data (o data e ora) o dopo.

- `to` (string): Conta solo i periodi dei report che iniziano in questa data (o data e ora) o prima. Una data senza ora include l’intera giornata (UTC).

- `limit` (integer): Sorgenti per pagina, fino a 200.

- `offset` (integer): Numero di sorgenti da saltare.

## Restituisce

Restituisce `data` e `meta` (`limit`, `offset`). La risposta non contiene un totale: richiedi la pagina successiva finché `data` non ha meno elementi di `limit`. Ogni sorgente ha:

- `source_ip` (string): L’indirizzo IP di invio.

- `country_code, country_name` (string | null): Dove si trova l’IP.

- `asn, as_org` (integer | string | null): La rete a cui appartiene l’IP.

- `volume` (integer): Messaggi segnalati da questo IP.

- `pass_volume, fail_volume` (integer): I messaggi che hanno superato DKIM o SPF allineati a DMARC e quelli che non hanno superato né l’uno né l’altro.

Restituisce `404` se il dominio non esiste nel workspace.

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

---
Fonte: https://emailit.com/it/docs/api-reference/dmarc/sources/

## Elenca i paesi — GET /domains/{id}/dmarc/countries

> Elenca i paesi da cui è stata inviata la posta che dichiara di provenire dal tuo dominio, con il volume DMARC e il numero di messaggi che superano o non superano il controllo.

# Elenca i paesi

Raggruppa i dati DMARC aggregati di un dominio per paese dell’IP mittente, a partire dal volume più alto. Richiede una chiave API con il permesso `full`.

I report arrivano solo per i domini con i report DMARC attivati, che richiedono il piano Pro o superiore.

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

## Parametri di percorso

- `id` (string, obbligatorio): L’ID del dominio (`dom_…`) o il nome del dominio.

## Parametri di query

- `from` (string): Conta solo i periodi dei report che iniziano in questa data (o data e ora) o dopo.

- `to` (string): Conta solo i periodi dei report che iniziano in questa data (o data e ora) o prima. Una data senza ora include l’intera giornata (UTC).

- `limit` (integer): Paesi per pagina, fino a 200.

- `offset` (integer): Numero di paesi da saltare.

## Restituisce

Restituisce `data` e `meta` (`limit`, `offset`). Ogni paese ha:

- `country_code` (string | null): Codice ISO 3166-1 alpha-2. `null` raggruppa gli indirizzi IP che non è stato possibile localizzare.

- `country_name` (string | null): Nome del paese.

- `continent_code` (string | null): Codice del continente, ad esempio `EU`.

- `volume` (integer): Messaggi segnalati da questo paese.

- `pass_volume, fail_volume` (integer): I messaggi che hanno superato DKIM o SPF allineati a DMARC e quelli che non hanno superato né l’uno né l’altro.

Restituisce `404` se il dominio non esiste nel workspace.

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

---
Fonte: https://emailit.com/it/docs/api-reference/dmarc/countries/

## Elenca le reti (ASN) — GET /domains/{id}/dmarc/asns

> Elenca le reti (sistemi autonomi) che hanno inviato posta a nome del tuo dominio, con il volume DMARC e il numero di messaggi che superano o non superano il controllo per ogni ASN.

# Elenca le reti (ASN)

Raggruppa i dati DMARC aggregati di un dominio per sistema autonomo (ASN) dell’IP mittente, a partire dal volume più alto. Una rete corrisponde di solito a un provider di hosting o a un servizio email, e questo rende più facile riconoscere i mittenti legittimi. Richiede una chiave API con il permesso `full`.

I report arrivano solo per i domini con i report DMARC attivati, che richiedono il piano Pro o superiore.

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

## Parametri di percorso

- `id` (string, obbligatorio): L’ID del dominio (`dom_…`) o il nome del dominio.

## Parametri di query

- `from` (string): Conta solo i periodi dei report che iniziano in questa data (o data e ora) o dopo.

- `to` (string): Conta solo i periodi dei report che iniziano in questa data (o data e ora) o prima. Una data senza ora include l’intera giornata (UTC).

- `limit` (integer): Reti per pagina, fino a 200.

- `offset` (integer): Numero di reti da saltare.

## Restituisce

Restituisce `data` e `meta` (`limit`, `offset`). Ogni rete ha:

- `asn` (integer | null): Numero del sistema autonomo. `null` raggruppa gli indirizzi IP che non è stato possibile identificare.

- `as_org` (string | null): Nome dell’organizzazione che gestisce la rete.

- `volume` (integer): Messaggi segnalati da questa rete.

- `pass_volume, fail_volume` (integer): I messaggi che hanno superato DKIM o SPF allineati a DMARC e quelli che non hanno superato né l’uno né l’altro.

Restituisce `404` se il dominio non esiste nel workspace.

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

---
Fonte: https://emailit.com/it/docs/api-reference/dmarc/asns/

## Elenca i mittenti dei report — GET /domains/{id}/dmarc/reporters

> Elenca le organizzazioni, come Google o Microsoft, che hanno inviato report DMARC aggregati per il tuo dominio, con il numero di report.

# Elenca i mittenti dei report

Elenca le organizzazioni che hanno inviato report aggregati elaborati per un dominio, a partire da quella con più report. Richiede una chiave API con il permesso `full`.

I report arrivano solo per i domini con i report DMARC attivati, che richiedono il piano Pro o superiore.

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

## Parametri di percorso

- `id` (string, obbligatorio): L’ID del dominio (`dom_…`) o il nome del dominio.

## Parametri di query

- `from` (string): Conta solo i report il cui periodo inizia in questa data (o data e ora) o dopo.

- `to` (string): Conta solo i report il cui periodo inizia in questa data (o data e ora) o prima. Una data senza ora include l’intera giornata (UTC).

- `limit` (integer): Mittenti per pagina, fino a 200.

- `offset` (integer): Numero di mittenti da saltare.

## Restituisce

Restituisce `data` e `meta` (`limit`, `offset`). Ogni mittente ha:

- `org_name` (string | null): Nome dell’organizzazione che invia i report, ad esempio `google.com`. Passalo come `org_name` a [Elenca i report aggregati](/it/docs/api-reference/dmarc/list/) per vederne i report.

- `org_email` (string | null): L’indirizzo di contatto del mittente del report.

- `report_count` (integer): Numero di report aggregati elaborati provenienti da questa organizzazione.

Restituisce `404` se il dominio non esiste nel workspace.

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

---
Fonte: https://emailit.com/it/docs/api-reference/dmarc/reporters/