# Relatórios DMARC API

> Consulte os relatórios DMARC agregados e forenses de um domínio de envio ou envie os seus próprios.

URL base: `https://api.emailit.com/v2`. Autentique-se com `Authorization: Bearer <API key>`.

## Listar relatórios agregados — GET /domains/{id}/dmarc/reports

> Liste os relatórios DMARC que o Emailit recebeu ou que você enviou para um domínio de envio, filtrados por tipo, status, emissor e data.

# Listar relatórios agregados

Retorna os relatórios DMARC de um domínio de envio, dos mais recentes para os mais antigos. Requer uma chave de API com escopo `full`.

O Emailit só coleta relatórios para domínios com os relatórios DMARC ativados (`dmarc_reports: true` em [Atualizar um domínio](/pt/docs/api-reference/domains/update/)), o que exige o plano Pro ou superior. Consulte [Relatórios DMARC](/pt/docs/dmarc/reports/).

A listagem também inclui relatórios forenses. Passe `type=aggregate` para listar apenas os relatórios agregados ou use [Listar relatórios forenses](/pt/docs/api-reference/dmarc/forensic/) para os detalhes forenses.

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

## Parâmetros de caminho

- `id` (string, obrigatório): O ID do domínio (`dom_…`) ou o nome do domínio, por exemplo `acme.com`.

## Parâmetros de consulta

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

- `status` (string): Status de processamento: `pending`, `processed`, `failed` ou `duplicate`.

- `org_name` (string): Nome exato da organização emissora, por exemplo `google.com`.

- `from` (string): Apenas os relatórios cujo período começa nesta data ou data e hora, ou depois dela, por exemplo `2026-09-01`.

- `to` (string): Apenas os relatórios cujo período começa nesta data ou data e hora, ou antes dela. Uma data sem hora inclui o dia inteiro (UTC).

- `limit` (integer): Relatórios por página, até 100.

- `offset` (integer): Número de relatórios a pular.

- `match`, `order`, `direction`: consulte [Filtragem](https://emailit.com/pt/docs/api-reference/filtering/).

Os filtros genéricos `key.condition=value` também funcionam em `type`, `status`, `org_name` e `created_at`; essas também são as chaves de ordenação para `order`. Consulte [Filtragem](/pt/docs/api-reference/filtering/).

## Retorno

Retorna `data`, um array de objetos de relatório, e `meta` com `total`, `limit` e `offset`.

- `id` (string): ID do relatório, com o prefixo `dmr_`.

- `type` (string | null): `aggregate` ou `forensic`. `null` até que um relatório enviado seja processado.

- `source` (string): `smtp` para relatórios que o Emailit recebeu no endereço de relatórios do domínio, `upload` para relatórios que você [enviou](/pt/docs/api-reference/dmarc/upload/).

- `status` (string): `pending`, `processed`, `failed` (consulte `error_message`) ou `duplicate` (o mesmo relatório já foi processado).

- `org_name, org_email` (string | null): A organização que enviou o relatório e o endereço de contato dela.

- `external_report_id` (string | null): O ID do relatório atribuído pelo próprio emissor.

- `date_range_begin, date_range_end` (string | null): O período coberto pelo relatório, em UTC.

- `policy_domain, adkim, aspf, p, sp, pct, fo` (string | integer | null): A política DMARC que o emissor encontrou para o seu domínio: modos de alinhamento (`r` ou `s`), política e política de subdomínio (`none`, `quarantine`, `reject`), porcentagem e opções de relatório de falhas.

- `original_filename` (string | null): Nome do arquivo de um relatório enviado.

- `envelope_to` (string | null): O endereço de relatórios para o qual o relatório foi enviado.

- `created_at, updated_at, processed_at` (string | null): Timestamps em UTC.

Retorna `404` se o domínio não existir no workspace.

**Requisição** `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/pt/docs/api-reference/dmarc/list/

## Obter um relatório — GET /domains/{id}/dmarc/reports/{report_id}

> Obtenha um relatório DMARC de um domínio. Os relatórios agregados incluem os registros deles: IPs de origem, volumes e resultados de SPF e DKIM.

# Obter um relatório

Obtém um relatório DMARC. Para um relatório agregado, a resposta inclui os registros dele, um por fonte de envio, ordenados pela contagem de mensagens. Para um relatório forense, inclui a amostra da falha em `forensic`. Requer uma chave de API com escopo `full`.

Os relatórios só chegam para domínios com os relatórios DMARC ativados, o que exige o plano Pro ou superior.

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

## Parâmetros de caminho

- `id` (string, obrigatório): O ID do domínio (`dom_…`) ou o nome do domínio.

- `report_id` (string, obrigatório): O ID do relatório (`dmr_…`).

## Parâmetros de consulta

- `limit` (integer): Registros a retornar, até 500. Apenas relatórios agregados.

- `offset` (integer): Registros a pular. Apenas relatórios agregados.

## Retorno

Retorna o objeto de relatório (consulte [Listar relatórios agregados](/pt/docs/api-reference/dmarc/list/)), além de:

- `records` (object[]): Apenas relatórios agregados. Uma entrada por combinação de IP de origem e resultado. Consulte os campos abaixo.

- `meta` (object): Apenas relatórios agregados. `total` de registros, `limit` e `offset`.

- `forensic` (object | null): Apenas relatórios forenses. Os mesmos campos de [Obter um relatório forense](/pt/docs/api-reference/dmarc/forensic-get/).

Cada registro tem:

- `source_ip` (string): Endereço IP que enviou as mensagens.

- `count` (integer): Número de mensagens desta fonte com estes resultados.

- `country_code, country_name, continent_code, asn, as_org, latitude, longitude` (string | integer | number | null): Localização e rede do IP de origem. `null` quando o IP não pôde ser localizado.

- `disposition` (string): O que o servidor de destino fez: `none`, `quarantine` ou `reject`.

- `dkim, spf` (string): Resultados alinhados ao DMARC conforme avaliados pelo servidor de destino: `pass` ou `fail`.

- `header_from, envelope_from, envelope_to` (string | null): Identificadores do relatório.

- `dkim_domain, dkim_selector, dkim_result` (string | null): A assinatura DKIM que o servidor de destino verificou e o resultado bruto dela.

- `spf_domain, spf_result` (string | null): O domínio SPF que o servidor de destino verificou e o resultado bruto dele.

- `reason_type, reason_comment` (string | null): Motivo da substituição da política, por exemplo `forwarded` ou `mailing_list`.

Retorna `404` se o domínio ou o relatório não existir.

**Requisição** `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/pt/docs/api-reference/dmarc/get/

## Enviar um relatório — POST /domains/{id}/dmarc/reports

> Envie um relatório DMARC agregado (XML, gzip ou zip) ou forense (EML) de um domínio. O processamento acontece em segundo plano.

# Enviar um relatório

Envia um relatório DMARC que você recebeu em outro lugar, por exemplo em uma caixa de e-mail que você usava antes do Emailit. Requer uma chave de API com escopo `full`.

O Emailit armazena o arquivo e o processa em segundo plano: a resposta tem o status `pending`, e o relatório passa para `processed`, `failed` ou `duplicate` (já importado) pouco depois. Confira com [Obter um relatório](/pt/docs/api-reference/dmarc/get/). Os relatórios que o Emailit recebe por e-mail exigem os relatórios DMARC ativados no domínio (plano Pro ou superior); os relatórios enviados pela API são processados de qualquer forma.

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

## Parâmetros de caminho

- `id` (string, obrigatório): O ID do domínio (`dom_…`) ou o nome do domínio.

## Parâmetros do corpo

Envie exatamente um destes: `content_base64` ou `content`. O relatório decodificado pode ter até 10 MB.

- `content_base64` (string): O arquivo, codificado em Base64. Use-o para formatos binários: relatórios agregados como `.xml`, `.xml.gz` ou `.zip`, e relatórios forenses como `.eml` (AFRF).

- `content` (string): O relatório como texto UTF-8, por exemplo o XML agregado bruto.

- `filename` (string): Nome original do arquivo, armazenado como `original_filename`.

## Retorno

Retorna `202 Accepted` com o novo objeto de relatório. `type` é `null` até que o processamento o detecte.

| Status | Quando |
| --- | --- |
| `400` | Nem `content_base64` nem `content` foi definido, ou o valor está vazio. |
| `404` | O domínio não existe no workspace. |
| `413` | O relatório decodificado tem mais de 10 MB. |

**Requisição** `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/pt/docs/api-reference/dmarc/upload/

## Listar relatórios forenses — GET /domains/{id}/dmarc/forensic

> Liste os relatórios DMARC forenses (de falhas) processados de um domínio: IP de origem, localização, tipo de falha e detalhes da mensagem.

# Listar relatórios forenses

Retorna os relatórios forenses (RUF) processados de um domínio, dos mais recentes para os mais antigos. Cada um descreve uma mensagem que falhou no DMARC. Os cabeçalhos ficam fora da listagem; [obtenha um relatório forense](/pt/docs/api-reference/dmarc/forensic-get/) para vê-los. Requer uma chave de API com escopo `full`.

Os relatórios só chegam para domínios com os relatórios DMARC ativados, o que exige o plano Pro ou superior. Poucos provedores de e-mail enviam relatórios forenses, e os que enviam podem incluir dados pessoais da mensagem que falhou.

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

## Parâmetros de caminho

- `id` (string, obrigatório): O ID do domínio (`dom_…`) ou o nome do domínio.

## Parâmetros de consulta

- `from` (string): Apenas os relatórios cujo período começa nesta data ou data e hora, ou depois dela.

- `to` (string): Apenas os relatórios cujo período começa nesta data ou data e hora, ou antes dela. Uma data sem hora inclui o dia inteiro (UTC).

- `limit` (integer): Relatórios por página, até 100.

- `offset` (integer): Número de relatórios a pular.

Os filtros genéricos `key.condition=value` também funcionam em `org_name` e `created_at`, com `match`, `order` e `direction`. Consulte [Filtragem](/pt/docs/api-reference/filtering/).

## Retorno

Retorna `data` e `meta` (`total`, `limit`, `offset`). Cada item tem:

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

- `id, report_id` (string): O ID do relatório (`dmr_…`).

- `arrival_date` (string | null): Quando a mensagem que falhou chegou ao servidor de destino.

- `source_ip` (string | null): Endereço IP que enviou a mensagem.

- `country_code, country_name, continent_code, asn, as_org, latitude, longitude` (string | integer | number | null): Localização e rede do IP de origem.

- `auth_failure` (string | null): O que falhou, por exemplo `dmarc`, `spf` ou `dkim`.

- `authentication_results` (string | null): O cabeçalho `Authentication-Results` do servidor de destino.

- `original_mail_from, original_rcpt_to, subject` (string | null): Remetente do envelope, destinatário e assunto da mensagem que falhou.

- `delivery_result` (string | null): O que o servidor de destino fez, por exemplo `reject` ou `delivered`.

- `reported_domain` (string | null): O seu domínio como aparece no relatório.

- `created_at` (string | null): Quando o Emailit armazenou o relatório.

**Requisição** `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/pt/docs/api-reference/dmarc/forensic/

## Obter um relatório forense — GET /domains/{id}/dmarc/forensic/{report_id}

> Obtenha um relatório DMARC forense de um domínio, incluindo os cabeçalhos da mensagem que falhou na autenticação.

# Obter um relatório forense

Obtém um relatório forense (RUF) com os cabeçalhos da mensagem que falhou no DMARC. Requer uma chave de API com escopo `full`. Os relatórios forenses podem conter dados pessoais, como endereços de destinatários e assuntos.

Os relatórios só chegam para domínios com os relatórios DMARC ativados, o que exige o plano Pro ou superior.

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

## Parâmetros de caminho

- `id` (string, obrigatório): O ID do domínio (`dom_…`) ou o nome do domínio.

- `report_id` (string, obrigatório): O ID (`dmr_…`) de um relatório forense.

## Retorno

Retorna o relatório forense com os campos descritos em [Listar relatórios forenses](/pt/docs/api-reference/dmarc/forensic/), além de:

- `headers` (string | null): Os cabeçalhos da mensagem original incluídos no relatório, como texto bruto.

Retorna `404` se o domínio não existir, se o relatório não existir ou se ele não for um relatório forense processado.

**Requisição** `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/pt/docs/api-reference/dmarc/forensic-get/

## Obter estatísticas — GET /domains/{id}/dmarc/stats

> Obtenha os totais DMARC de um domínio: volume, taxa de aprovação, disposições, resultados de SPF e DKIM, séries diárias e os principais países e redes.

# Obter estatísticas

Resume os relatórios DMARC agregados de um domínio em um intervalo de datas: quantos e-mails do seu domínio os servidores de destino viram, quantos passaram e de onde vieram. São os dados por trás da aba Overview em **Email API → DMARC reports**. Requer uma chave de API com escopo `full`.

Os relatórios só chegam para domínios com os relatórios DMARC ativados (`dmarc_reports: true` em [Atualizar um domínio](/pt/docs/api-reference/domains/update/)), o que exige o plano Pro ou superior.

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

## Parâmetros de caminho

- `id` (string, obrigatório): O ID do domínio (`dom_…`) ou o nome do domínio.

## Parâmetros de consulta

- `from` (string): Conta apenas os períodos de relatório que começam nesta data ou data e hora, ou depois dela, por exemplo `2026-09-01`. Sem ele, todos os relatórios são contados.

- `to` (string): Conta apenas os períodos de relatório que começam nesta data ou data e hora, ou antes dela. Uma data sem hora inclui o dia inteiro (UTC).

## Retorno

Retorna `data` com estes campos. Uma mensagem conta como aprovada quando o resultado do DKIM ou do SPF alinhado ao DMARC é `pass`.

- `total_volume` (integer): Mensagens relatadas.

- `pass_volume, fail_volume` (integer): Mensagens que passaram e que falharam.

- `pass_rate` (number): Porcentagem de mensagens que passaram, arredondada para duas casas decimais. `0` quando não há volume.

- `report_count` (integer): Relatórios processados no intervalo, agregados e forenses.

- `dispositions` (object[]): Volume por ação do servidor de destino: `disposition` (`none`, `quarantine`, `reject`) e `volume`.

- `dkim, spf` (object[]): Volume por resultado alinhado: `result` (`pass` ou `fail`) e `volume`.

- `daily` (object[]): Uma entrada por dia (`date` no formato `YYYY-MM-DD`, UTC) com `volume`, `pass_volume` e `fail_volume`.

- `daily_dispositions, daily_dkim, daily_spf` (object[]): Os mesmos detalhamentos por dia: `date`, `disposition` ou `result`, e `volume`.

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

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

- `unknown_geo_volume` (integer): Mensagens de endereços IP que não puderam ser localizados.

Retorna `404` se o domínio não existir no workspace.

**Requisição** `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/pt/docs/api-reference/dmarc/stats/

## Listar fontes de envio — GET /domains/{id}/dmarc/sources

> Liste os endereços IP que enviaram e-mails como o seu domínio segundo os relatórios DMARC, com o volume e as contagens de aprovações e falhas por IP.

# Listar fontes de envio

Agrupa os dados DMARC agregados de um domínio pelo endereço IP de origem, do maior volume para o menor. Use-o para identificar servidores que enviam como o seu domínio, mas falham no SPF e no DKIM. Requer uma chave de API com escopo `full`.

Os relatórios só chegam para domínios com os relatórios DMARC ativados, o que exige o plano Pro ou superior.

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

## Parâmetros de caminho

- `id` (string, obrigatório): O ID do domínio (`dom_…`) ou o nome do domínio.

## Parâmetros de consulta

- `from` (string): Conta apenas os períodos de relatório que começam nesta data ou data e hora, ou depois dela.

- `to` (string): Conta apenas os períodos de relatório que começam nesta data ou data e hora, ou antes dela. Uma data sem hora inclui o dia inteiro (UTC).

- `limit` (integer): Fontes por página, até 200.

- `offset` (integer): Número de fontes a pular.

## Retorno

Retorna `data` e `meta` (`limit`, `offset`). A resposta não tem total; peça a próxima página até que `data` tenha menos itens que `limit`. Cada fonte tem:

- `source_ip` (string): O endereço IP de envio.

- `country_code, country_name` (string | null): Onde o IP está localizado.

- `asn, as_org` (integer | string | null): A rede a que o IP pertence.

- `volume` (integer): Mensagens relatadas a partir deste IP.

- `pass_volume, fail_volume` (integer): Mensagens que passaram no DKIM ou no SPF alinhado ao DMARC e mensagens que falharam em ambos.

Retorna `404` se o domínio não existir no workspace.

**Requisição** `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/pt/docs/api-reference/dmarc/sources/

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

> Liste os países de onde foram enviados e-mails que dizem vir do seu domínio, com o volume DMARC e as contagens de aprovações e falhas.

# Listar países

Agrupa os dados DMARC agregados de um domínio pelo país do IP de envio, do maior volume para o menor. Requer uma chave de API com escopo `full`.

Os relatórios só chegam para domínios com os relatórios DMARC ativados, o que exige o plano Pro ou superior.

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

## Parâmetros de caminho

- `id` (string, obrigatório): O ID do domínio (`dom_…`) ou o nome do domínio.

## Parâmetros de consulta

- `from` (string): Conta apenas os períodos de relatório que começam nesta data ou data e hora, ou depois dela.

- `to` (string): Conta apenas os períodos de relatório que começam nesta data ou data e hora, ou antes dela. Uma data sem hora inclui o dia inteiro (UTC).

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

- `offset` (integer): Número de países a pular.

## Retorno

Retorna `data` e `meta` (`limit`, `offset`). Cada país tem:

- `country_code` (string | null): Código ISO 3166-1 alfa-2. `null` agrupa os endereços IP que não puderam ser localizados.

- `country_name` (string | null): Nome do país.

- `continent_code` (string | null): Código do continente, por exemplo `EU`.

- `volume` (integer): Mensagens relatadas a partir deste país.

- `pass_volume, fail_volume` (integer): Mensagens que passaram no DKIM ou no SPF alinhado ao DMARC e mensagens que falharam em ambos.

Retorna `404` se o domínio não existir no workspace.

**Requisição** `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/pt/docs/api-reference/dmarc/countries/

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

> Liste as redes (sistemas autônomos) que enviaram e-mails como o seu domínio, com o volume DMARC e as contagens de aprovações e falhas por ASN.

# Listar redes (ASNs)

Agrupa os dados DMARC agregados de um domínio pelo sistema autônomo (ASN) do IP de envio, do maior volume para o menor. Uma rede normalmente corresponde a um provedor de hospedagem ou a um serviço de e-mail, o que facilita reconhecer os remetentes legítimos. Requer uma chave de API com escopo `full`.

Os relatórios só chegam para domínios com os relatórios DMARC ativados, o que exige o plano Pro ou superior.

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

## Parâmetros de caminho

- `id` (string, obrigatório): O ID do domínio (`dom_…`) ou o nome do domínio.

## Parâmetros de consulta

- `from` (string): Conta apenas os períodos de relatório que começam nesta data ou data e hora, ou depois dela.

- `to` (string): Conta apenas os períodos de relatório que começam nesta data ou data e hora, ou antes dela. Uma data sem hora inclui o dia inteiro (UTC).

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

- `offset` (integer): Número de redes a pular.

## Retorno

Retorna `data` e `meta` (`limit`, `offset`). Cada rede tem:

- `asn` (integer | null): Número do sistema autônomo. `null` agrupa os endereços IP que não puderam ser consultados.

- `as_org` (string | null): Nome da organização que opera a rede.

- `volume` (integer): Mensagens relatadas a partir desta rede.

- `pass_volume, fail_volume` (integer): Mensagens que passaram no DKIM ou no SPF alinhado ao DMARC e mensagens que falharam em ambos.

Retorna `404` se o domínio não existir no workspace.

**Requisição** `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/pt/docs/api-reference/dmarc/asns/

## Listar emissores — GET /domains/{id}/dmarc/reporters

> Liste as organizações, como o Google ou a Microsoft, que enviaram relatórios DMARC agregados do seu domínio, com a contagem de relatórios.

# Listar emissores

Lista as organizações que enviaram relatórios agregados processados de um domínio, das que enviaram mais relatórios para as que enviaram menos. Requer uma chave de API com escopo `full`.

Os relatórios só chegam para domínios com os relatórios DMARC ativados, o que exige o plano Pro ou superior.

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

## Parâmetros de caminho

- `id` (string, obrigatório): O ID do domínio (`dom_…`) ou o nome do domínio.

## Parâmetros de consulta

- `from` (string): Conta apenas os relatórios cujo período começa nesta data ou data e hora, ou depois dela.

- `to` (string): Conta apenas os relatórios cujo período começa nesta data ou data e hora, ou antes dela. Uma data sem hora inclui o dia inteiro (UTC).

- `limit` (integer): Emissores por página, até 200.

- `offset` (integer): Número de emissores a pular.

## Retorno

Retorna `data` e `meta` (`limit`, `offset`). Cada emissor tem:

- `org_name` (string | null): Nome da organização emissora, por exemplo `google.com`. Passe-o como `org_name` para [Listar relatórios agregados](/pt/docs/api-reference/dmarc/list/) para ver os relatórios dela.

- `org_email` (string | null): O endereço de contato do emissor.

- `report_count` (integer): Número de relatórios agregados processados desta organização.

Retorna `404` se o domínio não existir no workspace.

**Requisição** `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/pt/docs/api-reference/dmarc/reporters/