# DMARC-Berichte API

> Aggregierte und forensische DMARC-Berichte einer Versanddomain lesen oder eigene hochladen.

Basis-URL: `https://api.emailit.com/v2`. Authentifizieren Sie sich mit `Authorization: Bearer <API key>`.

## Aggregierte Berichte auflisten — GET /domains/{id}/dmarc/reports

> Listen Sie die DMARC-Berichte einer Versanddomain auf, die Emailit empfangen oder Sie hochgeladen haben, gefiltert nach Typ, Status, berichtender Organisation und Datum.

# Aggregierte Berichte auflisten

Gibt die DMARC-Berichte einer Versanddomain zurück, die neuesten zuerst. Erfordert einen API-Schlüssel mit dem Scope `full`.

Emailit sammelt Berichte nur für Domains mit aktivierten DMARC-Berichten (`dmarc_reports: true` in [Domain aktualisieren](/de/docs/api-reference/domains/update/)); dafür benötigen Sie mindestens den Tarif Pro. Siehe [DMARC-Berichte](/de/docs/dmarc/reports/).

Die Liste enthält auch forensische Berichte. Übergeben Sie `type=aggregate`, um nur aggregierte Berichte aufzulisten, oder nutzen Sie [Forensische Berichte auflisten](/de/docs/api-reference/dmarc/forensic/) für forensische Details.

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

## Pfadparameter

- `id` (string, erforderlich): Die ID der Domain (`dom_…`) oder der Domainname, zum Beispiel `acme.com`.

## Query-Parameter

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

- `status` (string): Verarbeitungsstatus: `pending`, `processed`, `failed` oder `duplicate`.

- `org_name` (string): Exakter Name der berichtenden Organisation, zum Beispiel `google.com`.

- `from` (string): Nur Berichte, deren Zeitraum an oder nach diesem Datum bzw. Zeitpunkt beginnt, zum Beispiel `2026-09-01`.

- `to` (string): Nur Berichte, deren Zeitraum an oder vor diesem Datum bzw. Zeitpunkt beginnt. Ein Datum ohne Uhrzeit umfasst den ganzen Tag (UTC).

- `limit` (integer): Berichte pro Seite, bis zu 100.

- `offset` (integer): Anzahl der zu überspringenden Berichte.

- `match`, `order`, `direction`: siehe [Filtern und Sortieren](https://emailit.com/de/docs/api-reference/filtering/).

Die allgemeinen Filter `key.condition=value` funktionieren auch für `type`, `status`, `org_name` und `created_at`; das sind auch die Sortierschlüssel für `order`. Siehe [Filtern und Sortieren](/de/docs/api-reference/filtering/).

## Rückgabe

Gibt `data` zurück, ein Array von Bericht-Objekten, sowie `meta` mit `total`, `limit` und `offset`.

- `id` (string): Berichts-ID mit dem Präfix `dmr_`.

- `type` (string | null): `aggregate` oder `forensic`. `null`, bis ein hochgeladener Bericht verarbeitet ist.

- `source` (string): `smtp` für Berichte, die Emailit an der Berichtsadresse der Domain empfangen hat, `upload` für Berichte, die Sie [hochgeladen](/de/docs/api-reference/dmarc/upload/) haben.

- `status` (string): `pending`, `processed`, `failed` (siehe `error_message`) oder `duplicate` (derselbe Bericht wurde bereits verarbeitet).

- `org_name, org_email` (string | null): Die Organisation, die den Bericht gesendet hat, und ihre Kontaktadresse.

- `external_report_id` (string | null): Die eigene Berichts-ID der berichtenden Organisation.

- `date_range_begin, date_range_end` (string | null): Der vom Bericht abgedeckte Zeitraum in UTC.

- `policy_domain, adkim, aspf, p, sp, pct, fo` (string | integer | null): Die DMARC-Richtlinie, die die berichtende Organisation für Ihre Domain vorgefunden hat: Alignment-Modi (`r` oder `s`), Richtlinie und Subdomain-Richtlinie (`none`, `quarantine`, `reject`), Prozentsatz und Optionen für Fehlerberichte.

- `original_filename` (string | null): Dateiname eines hochgeladenen Berichts.

- `envelope_to` (string | null): Die Berichtsadresse, an die der Bericht gesendet wurde.

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

Gibt `404` zurück, wenn die Domain im Workspace nicht existiert.

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

---
Quelle: https://emailit.com/de/docs/api-reference/dmarc/list/

## Bericht abrufen — GET /domains/{id}/dmarc/reports/{report_id}

> Rufen Sie einen DMARC-Bericht für eine Domain ab. Aggregierte Berichte enthalten ihre Datensätze: Quell-IPs, Volumen sowie SPF- und DKIM-Ergebnisse.

# Bericht abrufen

Ruft einen DMARC-Bericht ab. Bei einem aggregierten Bericht enthält die Antwort seine Datensätze, einen pro sendender Quelle, sortiert nach Anzahl der Nachrichten. Bei einem forensischen Bericht enthält sie das Fehlerbeispiel in `forensic`. Erfordert einen API-Schlüssel mit dem Scope `full`.

Berichte gehen nur für Domains mit aktivierten DMARC-Berichten ein; dafür benötigen Sie mindestens den Tarif Pro.

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

## Pfadparameter

- `id` (string, erforderlich): Die ID der Domain (`dom_…`) oder der Domainname.

- `report_id` (string, erforderlich): Die Berichts-ID (`dmr_…`).

## Query-Parameter

- `limit` (integer): Anzahl der zurückgegebenen Datensätze, bis zu 500. Nur bei aggregierten Berichten.

- `offset` (integer): Anzahl der zu überspringenden Datensätze. Nur bei aggregierten Berichten.

## Rückgabe

Gibt das Bericht-Objekt (siehe [Aggregierte Berichte auflisten](/de/docs/api-reference/dmarc/list/)) zurück, dazu:

- `records` (object[]): Nur bei aggregierten Berichten. Ein Eintrag pro Kombination aus Quell-IP und Ergebnis. Siehe die Felder unten.

- `meta` (object): Nur bei aggregierten Berichten. `total` (Anzahl der Datensätze), `limit` und `offset`.

- `forensic` (object | null): Nur bei forensischen Berichten. Dieselben Felder wie bei [Forensischen Bericht abrufen](/de/docs/api-reference/dmarc/forensic-get/).

Jeder Datensatz hat:

- `source_ip` (string): IP-Adresse, die die Nachrichten gesendet hat.

- `count` (integer): Anzahl der Nachrichten aus dieser Quelle mit diesen Ergebnissen.

- `country_code, country_name, continent_code, asn, as_org, latitude, longitude` (string | integer | number | null): Standort und Netzwerk der Quell-IP. `null`, wenn sich die IP nicht lokalisieren ließ.

- `disposition` (string): Was der Empfangsserver getan hat: `none`, `quarantine` oder `reject`.

- `dkim, spf` (string): Ergebnisse mit DMARC-Alignment, wie der Empfangsserver sie bewertet hat: `pass` oder `fail`.

- `header_from, envelope_from, envelope_to` (string | null): Kennungen aus dem Bericht.

- `dkim_domain, dkim_selector, dkim_result` (string | null): Die vom Empfangsserver geprüfte DKIM-Signatur und ihr Rohergebnis.

- `spf_domain, spf_result` (string | null): Die vom Empfangsserver geprüfte SPF-Domain und ihr Rohergebnis.

- `reason_type, reason_comment` (string | null): Grund für eine Abweichung von der Richtlinie, zum Beispiel `forwarded` oder `mailing_list`.

Gibt `404` zurück, wenn die Domain oder der Bericht nicht existiert.

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

---
Quelle: https://emailit.com/de/docs/api-reference/dmarc/get/

## Bericht hochladen — POST /domains/{id}/dmarc/reports

> Laden Sie einen aggregierten (XML, gzip oder zip) oder forensischen (EML) DMARC-Bericht für eine Domain hoch. Die Verarbeitung läuft im Hintergrund.

# Bericht hochladen

Lädt einen DMARC-Bericht hoch, den Sie anderswo erhalten haben, zum Beispiel in einem Postfach, das Sie vor Emailit genutzt haben. Erfordert einen API-Schlüssel mit dem Scope `full`.

Emailit speichert die Datei und verarbeitet sie im Hintergrund: Die Antwort hat den Status `pending`, kurz darauf wechselt der Bericht zu `processed`, `failed` oder `duplicate` (bereits importiert). Prüfen Sie ihn mit [Bericht abrufen](/de/docs/api-reference/dmarc/get/). Berichte, die Emailit per E-Mail empfängt, setzen aktivierte DMARC-Berichte für die Domain voraus (ab Pro); hochgeladene Berichte werden in jedem Fall verarbeitet.

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

## Pfadparameter

- `id` (string, erforderlich): Die ID der Domain (`dom_…`) oder der Domainname.

## Body-Parameter

Senden Sie genau eines der Felder `content_base64` oder `content`. Der dekodierte Bericht darf bis zu 10 MB groß sein.

- `content_base64` (string): Die Datei, Base64-kodiert. Verwenden Sie dieses Feld für Binärformate: aggregierte Berichte als `.xml`, `.xml.gz` oder `.zip` und forensische Berichte als `.eml` (AFRF).

- `content` (string): Der Bericht als UTF-8-Text, zum Beispiel das rohe XML eines aggregierten Berichts.

- `filename` (string): Ursprünglicher Dateiname, gespeichert als `original_filename`.

## Rückgabe

Gibt `202 Accepted` mit dem neuen Bericht-Objekt zurück. `type` ist `null`, bis die Verarbeitung den Typ erkennt.

| Status | Wann |
| --- | --- |
| `400` | Weder `content_base64` noch `content` ist gesetzt oder der Wert ist leer. |
| `404` | Die Domain existiert im Workspace nicht. |
| `413` | Der dekodierte Bericht ist größer als 10 MB. |

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

---
Quelle: https://emailit.com/de/docs/api-reference/dmarc/upload/

## Forensische Berichte auflisten — GET /domains/{id}/dmarc/forensic

> Listen Sie die verarbeiteten forensischen DMARC-Berichte (Fehlerberichte) einer Domain auf: Quell-IP, Standort, Fehlerart und Details der Nachricht.

# Forensische Berichte auflisten

Gibt die verarbeiteten forensischen Berichte (RUF) einer Domain zurück, die neuesten zuerst. Jeder beschreibt eine Nachricht, die DMARC nicht bestanden hat. Die Header fehlen in der Liste; um sie zu sehen, [rufen Sie einen forensischen Bericht ab](/de/docs/api-reference/dmarc/forensic-get/). Erfordert einen API-Schlüssel mit dem Scope `full`.

Berichte gehen nur für Domains mit aktivierten DMARC-Berichten ein; dafür benötigen Sie mindestens den Tarif Pro. Nur wenige Postfachanbieter senden forensische Berichte, und diese können personenbezogene Daten aus der fehlgeschlagenen Nachricht enthalten.

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

## Pfadparameter

- `id` (string, erforderlich): Die ID der Domain (`dom_…`) oder der Domainname.

## Query-Parameter

- `from` (string): Nur Berichte, deren Zeitraum an oder nach diesem Datum bzw. Zeitpunkt beginnt.

- `to` (string): Nur Berichte, deren Zeitraum an oder vor diesem Datum bzw. Zeitpunkt beginnt. Ein Datum ohne Uhrzeit umfasst den ganzen Tag (UTC).

- `limit` (integer): Berichte pro Seite, bis zu 100.

- `offset` (integer): Anzahl der zu überspringenden Berichte.

Die allgemeinen Filter `key.condition=value` funktionieren auch für `org_name` und `created_at`, zusammen mit `match`, `order` und `direction`. Siehe [Filtern und Sortieren](/de/docs/api-reference/filtering/).

## Rückgabe

Gibt `data` und `meta` (`total`, `limit`, `offset`) zurück. Jeder Eintrag hat:

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

- `id, report_id` (string): Die Berichts-ID (`dmr_…`).

- `arrival_date` (string | null): Zeitpunkt, zu dem die fehlgeschlagene Nachricht beim Empfangsserver ankam.

- `source_ip` (string | null): IP-Adresse, die die Nachricht gesendet hat.

- `country_code, country_name, continent_code, asn, as_org, latitude, longitude` (string | integer | number | null): Standort und Netzwerk der Quell-IP.

- `auth_failure` (string | null): Was fehlgeschlagen ist, zum Beispiel `dmarc`, `spf` oder `dkim`.

- `authentication_results` (string | null): Der Header `Authentication-Results` des Empfangsservers.

- `original_mail_from, original_rcpt_to, subject` (string | null): Envelope-Absender, Empfänger und Betreff der fehlgeschlagenen Nachricht.

- `delivery_result` (string | null): Was der Empfangsserver getan hat, zum Beispiel `reject` oder `delivered`.

- `reported_domain` (string | null): Ihre Domain, wie sie im Bericht genannt wird.

- `created_at` (string | null): Zeitpunkt, zu dem Emailit den Bericht gespeichert hat.

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

---
Quelle: https://emailit.com/de/docs/api-reference/dmarc/forensic/

## Forensischen Bericht abrufen — GET /domains/{id}/dmarc/forensic/{report_id}

> Rufen Sie einen forensischen DMARC-Bericht für eine Domain ab, einschließlich der Header der Nachricht, deren Authentifizierung fehlgeschlagen ist.

# Forensischen Bericht abrufen

Ruft einen forensischen Bericht (RUF) mit den Headern der Nachricht ab, die DMARC nicht bestanden hat. Erfordert einen API-Schlüssel mit dem Scope `full`. Forensische Berichte können personenbezogene Daten enthalten, etwa Empfängeradressen und Betreffzeilen.

Berichte gehen nur für Domains mit aktivierten DMARC-Berichten ein; dafür benötigen Sie mindestens den Tarif Pro.

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

## Pfadparameter

- `id` (string, erforderlich): Die ID der Domain (`dom_…`) oder der Domainname.

- `report_id` (string, erforderlich): Die Berichts-ID (`dmr_…`) eines forensischen Berichts.

## Rückgabe

Gibt den forensischen Bericht mit den unter [Forensische Berichte auflisten](/de/docs/api-reference/dmarc/forensic/) beschriebenen Feldern zurück, dazu:

- `headers` (string | null): Die im Bericht enthaltenen ursprünglichen Header der Nachricht als Rohtext.

Gibt `404` zurück, wenn die Domain oder der Bericht nicht existiert oder es kein verarbeiteter forensischer Bericht ist.

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

---
Quelle: https://emailit.com/de/docs/api-reference/dmarc/forensic-get/

## Statistiken abrufen — GET /domains/{id}/dmarc/stats

> Rufen Sie DMARC-Gesamtwerte für eine Domain ab: Volumen, Erfolgsquote, Dispositionen, SPF- und DKIM-Ergebnisse, Tageswerte sowie die wichtigsten Länder und Netzwerke.

# Statistiken abrufen

Fasst die aggregierten DMARC-Berichte einer Domain über einen Zeitraum zusammen: wie viele E-Mails Empfangsserver von Ihrer Domain gesehen haben, wie viele davon bestanden haben und woher sie kamen. Auf diesen Daten basiert der Tab Overview unter **Email API → DMARC reports**. Erfordert einen API-Schlüssel mit dem Scope `full`.

Berichte gehen nur für Domains mit aktivierten DMARC-Berichten ein (`dmarc_reports: true` in [Domain aktualisieren](/de/docs/api-reference/domains/update/)); dafür benötigen Sie mindestens den Tarif Pro.

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

## Pfadparameter

- `id` (string, erforderlich): Die ID der Domain (`dom_…`) oder der Domainname.

## Query-Parameter

- `from` (string): Zählt nur Berichtszeiträume, die an oder nach diesem Datum bzw. Zeitpunkt beginnen, zum Beispiel `2026-09-01`. Ohne diesen Parameter werden alle Berichte gezählt.

- `to` (string): Zählt nur Berichtszeiträume, die an oder vor diesem Datum bzw. Zeitpunkt beginnen. Ein Datum ohne Uhrzeit umfasst den ganzen Tag (UTC).

## Rückgabe

Gibt `data` mit diesen Feldern zurück. Eine Nachricht gilt als bestanden, wenn ihr DKIM- oder SPF-Ergebnis mit DMARC-Alignment `pass` ist.

- `total_volume` (integer): Gemeldete Nachrichten.

- `pass_volume, fail_volume` (integer): Bestandene und fehlgeschlagene Nachrichten.

- `pass_rate` (number): Anteil der bestandenen Nachrichten in Prozent, auf zwei Dezimalstellen gerundet. `0`, wenn kein Volumen vorliegt.

- `report_count` (integer): Verarbeitete Berichte im Zeitraum, aggregierte und forensische.

- `dispositions` (object[]): Volumen pro Aktion des Empfangsservers: `disposition` (`none`, `quarantine`, `reject`) und `volume`.

- `dkim, spf` (object[]): Volumen pro Ergebnis mit Alignment: `result` (`pass` oder `fail`) und `volume`.

- `daily` (object[]): Ein Eintrag pro Tag (`date` als `YYYY-MM-DD`, UTC) mit `volume`, `pass_volume` und `fail_volume`.

- `daily_dispositions, daily_dkim, daily_spf` (object[]): Dieselben Aufschlüsselungen pro Tag: `date`, `disposition` bzw. `result` und `volume`.

- `top_countries` (object[]): Bis zu 10 Länder nach Volumen: `country_code`, `country_name`, `volume`, `pass_volume`, `fail_volume`.

- `top_asns` (object[]): Bis zu 10 Netzwerke nach Volumen: `asn`, `as_org`, `volume`, `pass_volume`, `fail_volume`.

- `unknown_geo_volume` (integer): Nachrichten von IP-Adressen, die sich nicht lokalisieren ließen.

Gibt `404` zurück, wenn die Domain im Workspace nicht existiert.

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

---
Quelle: https://emailit.com/de/docs/api-reference/dmarc/stats/

## Versandquellen auflisten — GET /domains/{id}/dmarc/sources

> Listen Sie die IP-Adressen auf, die laut DMARC-Berichten E-Mails im Namen Ihrer Domain gesendet haben, mit Volumen und der Anzahl bestandener und fehlgeschlagener Nachrichten pro IP.

# Versandquellen auflisten

Gruppiert die aggregierten DMARC-Daten einer Domain nach Quell-IP-Adresse, das höchste Volumen zuerst. So erkennen Sie Server, die im Namen Ihrer Domain senden, aber SPF und DKIM nicht bestehen. Erfordert einen API-Schlüssel mit dem Scope `full`.

Berichte gehen nur für Domains mit aktivierten DMARC-Berichten ein; dafür benötigen Sie mindestens den Tarif Pro.

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

## Pfadparameter

- `id` (string, erforderlich): Die ID der Domain (`dom_…`) oder der Domainname.

## Query-Parameter

- `from` (string): Zählt nur Berichtszeiträume, die an oder nach diesem Datum bzw. Zeitpunkt beginnen.

- `to` (string): Zählt nur Berichtszeiträume, die an oder vor diesem Datum bzw. Zeitpunkt beginnen. Ein Datum ohne Uhrzeit umfasst den ganzen Tag (UTC).

- `limit` (integer): Quellen pro Seite, bis zu 200.

- `offset` (integer): Anzahl der zu überspringenden Quellen.

## Rückgabe

Gibt `data` und `meta` (`limit`, `offset`) zurück. Die Antwort enthält keine Gesamtzahl; rufen Sie die nächste Seite ab, bis `data` weniger Einträge als `limit` enthält. Jede Quelle hat:

- `source_ip` (string): Die sendende IP-Adresse.

- `country_code, country_name` (string | null): Wo sich die IP befindet.

- `asn, as_org` (integer | string | null): Das Netzwerk, zu dem die IP gehört.

- `volume` (integer): Von dieser IP gemeldete Nachrichten.

- `pass_volume, fail_volume` (integer): Nachrichten, die DKIM oder SPF mit DMARC-Alignment bestanden haben, und Nachrichten, bei denen beides fehlgeschlagen ist.

Gibt `404` zurück, wenn die Domain im Workspace nicht existiert.

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

---
Quelle: https://emailit.com/de/docs/api-reference/dmarc/sources/

## Länder auflisten — GET /domains/{id}/dmarc/countries

> Listen Sie die Länder auf, aus denen E-Mails gesendet wurden, die angeblich von Ihrer Domain stammen, mit DMARC-Volumen und der Anzahl bestandener und fehlgeschlagener Nachrichten.

# Länder auflisten

Gruppiert die aggregierten DMARC-Daten einer Domain nach dem Land der sendenden IP, das höchste Volumen zuerst. Erfordert einen API-Schlüssel mit dem Scope `full`.

Berichte gehen nur für Domains mit aktivierten DMARC-Berichten ein; dafür benötigen Sie mindestens den Tarif Pro.

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

## Pfadparameter

- `id` (string, erforderlich): Die ID der Domain (`dom_…`) oder der Domainname.

## Query-Parameter

- `from` (string): Zählt nur Berichtszeiträume, die an oder nach diesem Datum bzw. Zeitpunkt beginnen.

- `to` (string): Zählt nur Berichtszeiträume, die an oder vor diesem Datum bzw. Zeitpunkt beginnen. Ein Datum ohne Uhrzeit umfasst den ganzen Tag (UTC).

- `limit` (integer): Länder pro Seite, bis zu 200.

- `offset` (integer): Anzahl der zu überspringenden Länder.

## Rückgabe

Gibt `data` und `meta` (`limit`, `offset`) zurück. Jedes Land hat:

- `country_code` (string | null): Code nach ISO 3166-1 alpha-2. `null` fasst IP-Adressen zusammen, die sich nicht lokalisieren ließen.

- `country_name` (string | null): Name des Landes.

- `continent_code` (string | null): Kontinentcode, zum Beispiel `EU`.

- `volume` (integer): Aus diesem Land gemeldete Nachrichten.

- `pass_volume, fail_volume` (integer): Nachrichten, die DKIM oder SPF mit DMARC-Alignment bestanden haben, und Nachrichten, bei denen beides fehlgeschlagen ist.

Gibt `404` zurück, wenn die Domain im Workspace nicht existiert.

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

---
Quelle: https://emailit.com/de/docs/api-reference/dmarc/countries/

## Netzwerke (ASNs) auflisten — GET /domains/{id}/dmarc/asns

> Listen Sie die Netzwerke (autonome Systeme) auf, die E-Mails im Namen Ihrer Domain gesendet haben, mit DMARC-Volumen und der Anzahl bestandener und fehlgeschlagener Nachrichten pro ASN.

# Netzwerke (ASNs) auflisten

Gruppiert die aggregierten DMARC-Daten einer Domain nach dem autonomen System (ASN) der sendenden IP, das höchste Volumen zuerst. Ein Netzwerk entspricht meist einem Hosting-Anbieter oder E-Mail-Dienst, wodurch sich legitime Absender leichter erkennen lassen. Erfordert einen API-Schlüssel mit dem Scope `full`.

Berichte gehen nur für Domains mit aktivierten DMARC-Berichten ein; dafür benötigen Sie mindestens den Tarif Pro.

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

## Pfadparameter

- `id` (string, erforderlich): Die ID der Domain (`dom_…`) oder der Domainname.

## Query-Parameter

- `from` (string): Zählt nur Berichtszeiträume, die an oder nach diesem Datum bzw. Zeitpunkt beginnen.

- `to` (string): Zählt nur Berichtszeiträume, die an oder vor diesem Datum bzw. Zeitpunkt beginnen. Ein Datum ohne Uhrzeit umfasst den ganzen Tag (UTC).

- `limit` (integer): Netzwerke pro Seite, bis zu 200.

- `offset` (integer): Anzahl der zu überspringenden Netzwerke.

## Rückgabe

Gibt `data` und `meta` (`limit`, `offset`) zurück. Jedes Netzwerk hat:

- `asn` (integer | null): Nummer des autonomen Systems. `null` fasst IP-Adressen zusammen, die sich nicht zuordnen ließen.

- `as_org` (string | null): Name der Organisation, die das Netzwerk betreibt.

- `volume` (integer): Aus diesem Netzwerk gemeldete Nachrichten.

- `pass_volume, fail_volume` (integer): Nachrichten, die DKIM oder SPF mit DMARC-Alignment bestanden haben, und Nachrichten, bei denen beides fehlgeschlagen ist.

Gibt `404` zurück, wenn die Domain im Workspace nicht existiert.

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

---
Quelle: https://emailit.com/de/docs/api-reference/dmarc/asns/

## Berichtende Organisationen auflisten — GET /domains/{id}/dmarc/reporters

> Listen Sie die Organisationen wie Google oder Microsoft auf, die aggregierte DMARC-Berichte für Ihre Domain gesendet haben, mit der Anzahl ihrer Berichte.

# Berichtende Organisationen auflisten

Listet die Organisationen auf, die verarbeitete aggregierte Berichte für eine Domain gesendet haben, die mit den meisten Berichten zuerst. Erfordert einen API-Schlüssel mit dem Scope `full`.

Berichte gehen nur für Domains mit aktivierten DMARC-Berichten ein; dafür benötigen Sie mindestens den Tarif Pro.

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

## Pfadparameter

- `id` (string, erforderlich): Die ID der Domain (`dom_…`) oder der Domainname.

## Query-Parameter

- `from` (string): Zählt nur Berichte, deren Zeitraum an oder nach diesem Datum bzw. Zeitpunkt beginnt.

- `to` (string): Zählt nur Berichte, deren Zeitraum an oder vor diesem Datum bzw. Zeitpunkt beginnt. Ein Datum ohne Uhrzeit umfasst den ganzen Tag (UTC).

- `limit` (integer): Organisationen pro Seite, bis zu 200.

- `offset` (integer): Anzahl der zu überspringenden Organisationen.

## Rückgabe

Gibt `data` und `meta` (`limit`, `offset`) zurück. Jede Organisation hat:

- `org_name` (string | null): Name der berichtenden Organisation, zum Beispiel `google.com`. Übergeben Sie ihn als `org_name` an [Aggregierte Berichte auflisten](/de/docs/api-reference/dmarc/list/), um ihre Berichte zu sehen.

- `org_email` (string | null): Die Kontaktadresse der Organisation.

- `report_count` (integer): Anzahl der verarbeiteten aggregierten Berichte dieser Organisation.

Gibt `404` zurück, wenn die Domain im Workspace nicht existiert.

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

---
Quelle: https://emailit.com/de/docs/api-reference/dmarc/reporters/