# DMARC reporty API

> Čtěte souhrnné a forenzní DMARC reporty odesílací domény, nebo nahrajte vlastní.

Základní URL: `https://api.emailit.com/v2`. Autentizujte se hlavičkou `Authorization: Bearer <API key>`.

## Výpis souhrnných reportů — GET /domains/{id}/dmarc/reports

> Vypište DMARC reporty, které Emailit pro odesílací doménu přijal nebo které jste nahráli, a filtrujte je podle typu, stavu, odesílatele reportu a data.

# Výpis souhrnných reportů

Vrací DMARC reporty odesílací domény od nejnovějších. Vyžaduje API klíč s oprávněním `full`.

Emailit sbírá reporty jen u domén se zapnutými DMARC reporty (`dmarc_reports: true` v endpointu [Úprava domény](/cs/docs/api-reference/domains/update/)), což vyžaduje tarif Pro nebo vyšší. Viz [Čtení DMARC reportů](/cs/docs/dmarc/reports/).

Seznam obsahuje i forenzní reporty. Pokud chcete vypsat jen souhrnné reporty, předejte `type=aggregate`; podrobnosti forenzních reportů získáte endpointem [Výpis forenzních reportů](/cs/docs/api-reference/dmarc/forensic/).

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

## Parametry v cestě

- `id` (string, povinné): ID domény (`dom_…`), nebo název domény, například `acme.com`.

## Parametry dotazu

- `type` (string): `aggregate`, nebo `forensic`.

- `status` (string): Stav zpracování: `pending`, `processed`, `failed` nebo `duplicate`.

- `org_name` (string): Přesný název organizace, která report poslala, například `google.com`.

- `from` (string): Jen reporty, jejichž období začíná zadaným datem (nebo datem a časem) či později, například `2026-09-01`.

- `to` (string): Jen reporty, jejichž období začíná zadaným datem (nebo datem a časem) či dříve. Datum bez času zahrnuje celý den (UTC).

- `limit` (integer): Počet reportů na stránce, nejvýše 100.

- `offset` (integer): Počet reportů, které se mají přeskočit.

- `match`, `order`, `direction`: viz [Filtrování](https://emailit.com/cs/docs/api-reference/filtering/).

Obecné filtry `key.condition=value` fungují také u `type`, `status`, `org_name` a `created_at`; to jsou zároveň klíče řazení pro `order`. Viz [Filtrování a řazení](/cs/docs/api-reference/filtering/).

## Odpověď

Vrací `data`, pole objektů reportů, a `meta` s `total`, `limit` a `offset`.

- `id` (string): ID reportu s předponou `dmr_`.

- `type` (string | null): `aggregate`, nebo `forensic`. U nahraného reportu `null`, dokud se nezpracuje.

- `source` (string): `smtp` u reportů, které Emailit přijal na adresu domény pro reporty, `upload` u reportů, které jste [nahráli](/cs/docs/api-reference/dmarc/upload/).

- `status` (string): `pending`, `processed`, `failed` (viz `error_message`) nebo `duplicate` (stejný report už byl zpracován).

- `org_name, org_email` (string | null): Organizace, která report poslala, a její kontaktní adresa.

- `external_report_id` (string | null): Vlastní ID reportu, které mu přidělil jeho odesílatel.

- `date_range_begin, date_range_end` (string | null): Období, které report pokrývá, v UTC.

- `policy_domain, adkim, aspf, p, sp, pct, fo` (string | integer | null): Politika DMARC, kterou odesílatel reportu u vaší domény našel: režimy zarovnání (`r`, nebo `s`), politika a politika pro subdomény (`none`, `quarantine`, `reject`), procento a volby pro hlášení selhání.

- `original_filename` (string | null): Název souboru nahraného reportu.

- `envelope_to` (string | null): Adresa pro reporty, na kterou byl report odeslán.

- `created_at, updated_at, processed_at` (string | null): Časová razítka v UTC.

Pokud doména ve workspace neexistuje, vrací `404`.

**Požadavek** `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"
}
```

---
Zdroj: https://emailit.com/cs/docs/api-reference/dmarc/list/

## Načtení reportu — GET /domains/{id}/dmarc/reports/{report_id}

> Načtěte jeden DMARC report domény. Souhrnné reporty obsahují své záznamy: zdrojové IP adresy, objemy a výsledky SPF a DKIM.

# Načtení reportu

Načte jeden DMARC report. U souhrnného reportu obsahuje odpověď jeho záznamy, jeden pro každý odesílací zdroj, seřazené podle počtu zpráv. U forenzního reportu obsahuje ukázku selhání v poli `forensic`. Vyžaduje API klíč s oprávněním `full`.

Reporty přicházejí jen u domén se zapnutými DMARC reporty, což vyžaduje tarif Pro nebo vyšší.

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

## Parametry v cestě

- `id` (string, povinné): ID domény (`dom_…`), nebo název domény.

- `report_id` (string, povinné): ID reportu (`dmr_…`).

## Parametry dotazu

- `limit` (integer): Počet záznamů, které se mají vrátit, nejvýše 500. Jen u souhrnných reportů.

- `offset` (integer): Počet záznamů, které se mají přeskočit. Jen u souhrnných reportů.

## Odpověď

Vrací objekt reportu (viz [Výpis souhrnných reportů](/cs/docs/api-reference/dmarc/list/)) a navíc:

- `records` (object[]): Jen u souhrnných reportů. Jedna položka pro každou kombinaci zdrojové IP adresy a výsledku. Pole jsou popsaná níže.

- `meta` (object): Jen u souhrnných reportů. Celkový počet záznamů `total`, `limit` a `offset`.

- `forensic` (object | null): Jen u forenzních reportů. Stejná pole jako u endpointu [Načtení forenzního reportu](/cs/docs/api-reference/dmarc/forensic-get/).

Každý záznam obsahuje:

- `source_ip` (string): IP adresa, ze které byly zprávy odeslány.

- `count` (integer): Počet zpráv z tohoto zdroje s těmito výsledky.

- `country_code, country_name, continent_code, asn, as_org, latitude, longitude` (string | integer | number | null): Poloha a síť zdrojové IP adresy. `null`, když se IP adresu nepodařilo lokalizovat.

- `disposition` (string): Co přijímající server se zprávami udělal: `none`, `quarantine` nebo `reject`.

- `dkim, spf` (string): Výsledky se zarovnáním podle DMARC, jak je vyhodnotil přijímající server: `pass`, nebo `fail`.

- `header_from, envelope_from, envelope_to` (string | null): Identifikátory z reportu.

- `dkim_domain, dkim_selector, dkim_result` (string | null): Podpis DKIM, který přijímající server kontroloval, a jeho surový výsledek.

- `spf_domain, spf_result` (string | null): Doména SPF, kterou přijímající server kontroloval, a její surový výsledek.

- `reason_type, reason_comment` (string | null): Důvod přepsání politiky, například `forwarded` nebo `mailing_list`.

Pokud doména nebo report neexistuje, vrací `404`.

**Požadavek** `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"
}
```

---
Zdroj: https://emailit.com/cs/docs/api-reference/dmarc/get/

## Nahrání reportu — POST /domains/{id}/dmarc/reports

> Nahrajte k doméně souhrnný (XML, gzip nebo zip), nebo forenzní (EML) DMARC report. Zpracování probíhá na pozadí.

# Nahrání reportu

Nahraje DMARC report, který jste dostali jinde, například do schránky, kterou jste používali před Emailitem. Vyžaduje API klíč s oprávněním `full`.

Emailit soubor uloží a zpracuje ho na pozadí: odpověď má stav `pending` a report brzy potom přejde do stavu `processed`, `failed` nebo `duplicate` (už naimportovaný). Zkontrolujete ho endpointem [Načtení reportu](/cs/docs/api-reference/dmarc/get/). Reporty, které Emailit přijímá e-mailem, vyžadují u domény zapnuté DMARC reporty (tarif Pro nebo vyšší); nahrané reporty se zpracují v každém případě.

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

## Parametry v cestě

- `id` (string, povinné): ID domény (`dom_…`), nebo název domény.

## Parametry v těle požadavku

Pošlete právě jeden z parametrů `content_base64` a `content`. Dekódovaný report může mít nejvýše 10 MB.

- `content_base64` (string): Soubor zakódovaný v Base64. Použijte ho pro binární formáty: souhrnné reporty jako `.xml`, `.xml.gz` nebo `.zip` a forenzní reporty jako `.eml` (AFRF).

- `content` (string): Report jako text v UTF-8, například surové XML souhrnného reportu.

- `filename` (string): Původní název souboru, uloží se jako `original_filename`.

## Odpověď

Vrací `202 Accepted` s novým objektem reportu. `type` je `null`, dokud ho zpracování nerozpozná.

| Stavový kód | Kdy |
| --- | --- |
| `400` | Není nastavený ani `content_base64`, ani `content`, nebo je hodnota prázdná. |
| `404` | Doména ve workspace neexistuje. |
| `413` | Dekódovaný report je větší než 10 MB. |

**Požadavek** `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"
}
```

---
Zdroj: https://emailit.com/cs/docs/api-reference/dmarc/upload/

## Výpis forenzních reportů — GET /domains/{id}/dmarc/forensic

> Vypište zpracované forenzní DMARC reporty (o selháních) domény: zdrojovou IP adresu, polohu, typ selhání a údaje o zprávě.

# Výpis forenzních reportů

Vrací zpracované forenzní (RUF) reporty domény od nejnovějších. Každý popisuje jednu zprávu, která neprošla kontrolou DMARC. Seznam neobsahuje hlavičky; uvidíte je, když [načtete forenzní report](/cs/docs/api-reference/dmarc/forensic-get/). Vyžaduje API klíč s oprávněním `full`.

Reporty přicházejí jen u domén se zapnutými DMARC reporty, což vyžaduje tarif Pro nebo vyšší. Forenzní reporty posílá jen málo poskytovatelů schránek a ti, kteří je posílají, do nich mohou zahrnout osobní údaje z neúspěšné zprávy.

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

## Parametry v cestě

- `id` (string, povinné): ID domény (`dom_…`), nebo název domény.

## Parametry dotazu

- `from` (string): Jen reporty, jejichž období začíná zadaným datem (nebo datem a časem) či později.

- `to` (string): Jen reporty, jejichž období začíná zadaným datem (nebo datem a časem) či dříve. Datum bez času zahrnuje celý den (UTC).

- `limit` (integer): Počet reportů na stránce, nejvýše 100.

- `offset` (integer): Počet reportů, které se mají přeskočit.

Obecné filtry `key.condition=value` fungují také u `org_name` a `created_at`, spolu s `match`, `order` a `direction`. Viz [Filtrování a řazení](/cs/docs/api-reference/filtering/).

## Odpověď

Vrací `data` a `meta` (`total`, `limit`, `offset`). Každá položka obsahuje:

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

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

- `arrival_date` (string | null): Kdy neúspěšná zpráva dorazila na přijímající server.

- `source_ip` (string | null): IP adresa, ze které byla zpráva odeslána.

- `country_code, country_name, continent_code, asn, as_org, latitude, longitude` (string | integer | number | null): Poloha a síť zdrojové IP adresy.

- `auth_failure` (string | null): Co selhalo, například `dmarc`, `spf` nebo `dkim`.

- `authentication_results` (string | null): Hlavička `Authentication-Results` od přijímajícího serveru.

- `original_mail_from, original_rcpt_to, subject` (string | null): Odesílatel v obálce, příjemce a předmět neúspěšné zprávy.

- `delivery_result` (string | null): Co přijímající server se zprávou udělal, například `reject` nebo `delivered`.

- `reported_domain` (string | null): Vaše doména, jak je uvedená v reportu.

- `created_at` (string | null): Kdy Emailit report uložil.

**Požadavek** `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"
}
```

---
Zdroj: https://emailit.com/cs/docs/api-reference/dmarc/forensic/

## Načtení forenzního reportu — GET /domains/{id}/dmarc/forensic/{report_id}

> Načtěte jeden forenzní DMARC report domény včetně hlaviček zprávy, která neprošla ověřením.

# Načtení forenzního reportu

Načte jeden forenzní (RUF) report s hlavičkami zprávy, která neprošla kontrolou DMARC. Vyžaduje API klíč s oprávněním `full`. Forenzní reporty mohou obsahovat osobní údaje, například adresy příjemců a předměty.

Reporty přicházejí jen u domén se zapnutými DMARC reporty, což vyžaduje tarif Pro nebo vyšší.

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

## Parametry v cestě

- `id` (string, povinné): ID domény (`dom_…`), nebo název domény.

- `report_id` (string, povinné): ID forenzního reportu (`dmr_…`).

## Odpověď

Vrací forenzní report s poli popsanými na stránce [Výpis forenzních reportů](/cs/docs/api-reference/dmarc/forensic/) a navíc:

- `headers` (string | null): Původní hlavičky zprávy obsažené v reportu, jako surový text.

Pokud doména neexistuje, report neexistuje nebo nejde o zpracovaný forenzní report, vrací `404`.

**Požadavek** `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"
}
```

---
Zdroj: https://emailit.com/cs/docs/api-reference/dmarc/forensic-get/

## Načtení statistik — GET /domains/{id}/dmarc/stats

> Získejte souhrnná čísla DMARC pro doménu: objem, míru úspěšnosti, akce přijímajících serverů, výsledky SPF a DKIM, denní řady a nejčastější země a sítě.

# Načtení statistik

Shrnuje souhrnné DMARC reporty domény za zvolené období: kolik pošty z vaší domény přijímající servery viděly, kolik jí prošlo a odkud pocházela. Z těchto dat vychází karta Overview v sekci **Email API → DMARC reports**. Vyžaduje API klíč s oprávněním `full`.

Reporty přicházejí jen u domén se zapnutými DMARC reporty (`dmarc_reports: true` v endpointu [Úprava domény](/cs/docs/api-reference/domains/update/)), což vyžaduje tarif Pro nebo vyšší.

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

## Parametry v cestě

- `id` (string, povinné): ID domény (`dom_…`), nebo název domény.

## Parametry dotazu

- `from` (string): Započítá jen období reportů, která začínají zadaným datem (nebo datem a časem) či později, například `2026-09-01`. Bez tohoto parametru se započítají všechny reporty.

- `to` (string): Započítá jen období reportů, která začínají zadaným datem (nebo datem a časem) či dříve. Datum bez času zahrnuje celý den (UTC).

## Odpověď

Vrací `data` s těmito poli. Zpráva se počítá jako úspěšná, když má výsledek DKIM nebo SPF se zarovnáním podle DMARC hodnotu `pass`.

- `total_volume` (integer): Počet nahlášených zpráv.

- `pass_volume, fail_volume` (integer): Zprávy, které prošly a neprošly.

- `pass_rate` (number): Procento zpráv, které prošly, zaokrouhlené na dvě desetinná místa. `0`, když není žádný objem.

- `report_count` (integer): Zpracované reporty v daném období, souhrnné i forenzní.

- `dispositions` (object[]): Objem podle akce přijímajícího serveru: `disposition` (`none`, `quarantine`, `reject`) a `volume`.

- `dkim, spf` (object[]): Objem podle výsledku se zarovnáním: `result` (`pass`, nebo `fail`) a `volume`.

- `daily` (object[]): Jedna položka za každý den (`date` ve tvaru `YYYY-MM-DD`, UTC) s `volume`, `pass_volume` a `fail_volume`.

- `daily_dispositions, daily_dkim, daily_spf` (object[]): Stejné rozpady po dnech: `date`, `disposition` nebo `result` a `volume`.

- `top_countries` (object[]): Nejvýše 10 zemí podle objemu: `country_code`, `country_name`, `volume`, `pass_volume`, `fail_volume`.

- `top_asns` (object[]): Nejvýše 10 sítí podle objemu: `asn`, `as_org`, `volume`, `pass_volume`, `fail_volume`.

- `unknown_geo_volume` (integer): Zprávy z IP adres, které se nepodařilo lokalizovat.

Pokud doména ve workspace neexistuje, vrací `404`.

**Požadavek** `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"
}
```

---
Zdroj: https://emailit.com/cs/docs/api-reference/dmarc/stats/

## Výpis odesílacích zdrojů — GET /domains/{id}/dmarc/sources

> Vypište IP adresy, které podle DMARC reportů odesílaly poštu jménem vaší domény, s objemem a počty úspěšných a neúspěšných zpráv pro každou IP adresu.

# Výpis odesílacích zdrojů

Seskupí souhrnná data DMARC domény podle zdrojové IP adresy, od největšího objemu. Pomůže vám najít servery, které odesílají jménem vaší domény, ale neprocházejí kontrolou SPF a DKIM. Vyžaduje API klíč s oprávněním `full`.

Reporty přicházejí jen u domén se zapnutými DMARC reporty, což vyžaduje tarif Pro nebo vyšší.

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

## Parametry v cestě

- `id` (string, povinné): ID domény (`dom_…`), nebo název domény.

## Parametry dotazu

- `from` (string): Započítá jen období reportů, která začínají zadaným datem (nebo datem a časem) či později.

- `to` (string): Započítá jen období reportů, která začínají zadaným datem (nebo datem a časem) či dříve. Datum bez času zahrnuje celý den (UTC).

- `limit` (integer): Počet zdrojů na stránce, nejvýše 200.

- `offset` (integer): Počet zdrojů, které se mají přeskočit.

## Odpověď

Vrací `data` a `meta` (`limit`, `offset`). Odpověď neobsahuje celkový počet; načítejte další stránky, dokud `data` nemá méně položek než `limit`. Každý zdroj obsahuje:

- `source_ip` (string): Odesílající IP adresa.

- `country_code, country_name` (string | null): Kde se IP adresa nachází.

- `asn, as_org` (integer | string | null): Síť, do které IP adresa patří.

- `volume` (integer): Počet zpráv nahlášených z této IP adresy.

- `pass_volume, fail_volume` (integer): Zprávy, které prošly kontrolou DKIM nebo SPF se zarovnáním podle DMARC, a zprávy, které neprošly ani jednou.

Pokud doména ve workspace neexistuje, vrací `404`.

**Požadavek** `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"
}
```

---
Zdroj: https://emailit.com/cs/docs/api-reference/dmarc/sources/

## Výpis zemí — GET /domains/{id}/dmarc/countries

> Vypište země, ze kterých byla odeslána pošta vydávající se za poštu z vaší domény, s objemem podle DMARC a počty úspěšných a neúspěšných zpráv.

# Výpis zemí

Seskupí souhrnná data DMARC domény podle země odesílající IP adresy, od největšího objemu. Vyžaduje API klíč s oprávněním `full`.

Reporty přicházejí jen u domén se zapnutými DMARC reporty, což vyžaduje tarif Pro nebo vyšší.

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

## Parametry v cestě

- `id` (string, povinné): ID domény (`dom_…`), nebo název domény.

## Parametry dotazu

- `from` (string): Započítá jen období reportů, která začínají zadaným datem (nebo datem a časem) či později.

- `to` (string): Započítá jen období reportů, která začínají zadaným datem (nebo datem a časem) či dříve. Datum bez času zahrnuje celý den (UTC).

- `limit` (integer): Počet zemí na stránce, nejvýše 200.

- `offset` (integer): Počet zemí, které se mají přeskočit.

## Odpověď

Vrací `data` a `meta` (`limit`, `offset`). Každá země obsahuje:

- `country_code` (string | null): Kód podle ISO 3166-1 alpha-2. Pod `null` jsou seskupené IP adresy, které se nepodařilo lokalizovat.

- `country_name` (string | null): Název země.

- `continent_code` (string | null): Kód kontinentu, například `EU`.

- `volume` (integer): Počet zpráv nahlášených z této země.

- `pass_volume, fail_volume` (integer): Zprávy, které prošly kontrolou DKIM nebo SPF se zarovnáním podle DMARC, a zprávy, které neprošly ani jednou.

Pokud doména ve workspace neexistuje, vrací `404`.

**Požadavek** `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"
}
```

---
Zdroj: https://emailit.com/cs/docs/api-reference/dmarc/countries/

## Výpis sítí (ASN) — GET /domains/{id}/dmarc/asns

> Vypište sítě (autonomní systémy), které odesílaly poštu jménem vaší domény, s objemem podle DMARC a počty úspěšných a neúspěšných zpráv pro každou síť.

# Výpis sítí (ASN)

Seskupí souhrnná data DMARC domény podle autonomního systému (ASN) odesílající IP adresy, od největšího objemu. Síť obvykle odpovídá poskytovateli hostingu nebo e-mailové službě, takže legitimní odesílatele snáz poznáte. Vyžaduje API klíč s oprávněním `full`.

Reporty přicházejí jen u domén se zapnutými DMARC reporty, což vyžaduje tarif Pro nebo vyšší.

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

## Parametry v cestě

- `id` (string, povinné): ID domény (`dom_…`), nebo název domény.

## Parametry dotazu

- `from` (string): Započítá jen období reportů, která začínají zadaným datem (nebo datem a časem) či později.

- `to` (string): Započítá jen období reportů, která začínají zadaným datem (nebo datem a časem) či dříve. Datum bez času zahrnuje celý den (UTC).

- `limit` (integer): Počet sítí na stránce, nejvýše 200.

- `offset` (integer): Počet sítí, které se mají přeskočit.

## Odpověď

Vrací `data` a `meta` (`limit`, `offset`). Každá síť obsahuje:

- `asn` (integer | null): Číslo autonomního systému. Pod `null` jsou seskupené IP adresy, které se nepodařilo dohledat.

- `as_org` (string | null): Název organizace, která síť provozuje.

- `volume` (integer): Počet zpráv nahlášených z této sítě.

- `pass_volume, fail_volume` (integer): Zprávy, které prošly kontrolou DKIM nebo SPF se zarovnáním podle DMARC, a zprávy, které neprošly ani jednou.

Pokud doména ve workspace neexistuje, vrací `404`.

**Požadavek** `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"
}
```

---
Zdroj: https://emailit.com/cs/docs/api-reference/dmarc/asns/

## Výpis odesílatelů reportů — GET /domains/{id}/dmarc/reporters

> Vypište organizace, například Google nebo Microsoft, které pro vaši doménu poslaly souhrnné DMARC reporty, s počty reportů.

# Výpis odesílatelů reportů

Vypíše organizace, které pro doménu poslaly zpracované souhrnné reporty, od těch s nejvíce reporty. Vyžaduje API klíč s oprávněním `full`.

Reporty přicházejí jen u domén se zapnutými DMARC reporty, což vyžaduje tarif Pro nebo vyšší.

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

## Parametry v cestě

- `id` (string, povinné): ID domény (`dom_…`), nebo název domény.

## Parametry dotazu

- `from` (string): Započítá jen reporty, jejichž období začíná zadaným datem (nebo datem a časem) či později.

- `to` (string): Započítá jen reporty, jejichž období začíná zadaným datem (nebo datem a časem) či dříve. Datum bez času zahrnuje celý den (UTC).

- `limit` (integer): Počet odesílatelů reportů na stránce, nejvýše 200.

- `offset` (integer): Počet odesílatelů reportů, které se mají přeskočit.

## Odpověď

Vrací `data` a `meta` (`limit`, `offset`). Každý odesílatel reportů obsahuje:

- `org_name` (string | null): Název organizace, která reporty posílá, například `google.com`. Pokud chcete vidět její reporty, předejte ho jako `org_name` endpointu [Výpis souhrnných reportů](/cs/docs/api-reference/dmarc/list/).

- `org_email` (string | null): Kontaktní adresa odesílatele reportů.

- `report_count` (integer): Počet zpracovaných souhrnných reportů od této organizace.

Pokud doména ve workspace neexistuje, vrací `404`.

**Požadavek** `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"
}
```

---
Zdroj: https://emailit.com/cs/docs/api-reference/dmarc/reporters/