Account

DMARC Monitoring

Receive and analyze DMARC reports and identify potential sending issues with MailerSend's DMARC Monitoring API. Create and fetch monitors and retrieve your DMARC reports.

Receive and analyze DMARC reports to identify potential sending issues. Create and manage monitors for your domains, retrieve aggregated and IP-specific reports, and track DMARC compliance across your email infrastructure.

List monitors

If you want to retrieve information about multiple DMARC monitors, use this GET request:

GET https://api.mailersend.com/v1/dmarc-monitoring

Request parameters

Query parameter	Type	Required	Limitations	Details
`page`	`int`	no	Min: `1`
`limit`	`int`	no	Min: `1`, Max: `100`	Default: `25`
`query`	`string`	no	Max: `255`	Search/filter monitors
`sort_by`	`string`	no		Allowed values: `created_at`, `updated_at`, `dmarc_valid`, `spf_status`
`order`	`string`	no		Allowed values: `asc`, `desc`

use MailerSend\MailerSend;

$mailersend = new MailerSend(['api_key' => 'key']);

$mailersend->dmarcMonitoring->getAll($page = 1, $limit = 25);

import 'dotenv/config';
import { MailerSend } from "mailersend";

const mailerSend = new MailerSend({
  apiKey: process.env.API_KEY,
});

mailerSend.dmarc.list({ page: 1, limit: 25 })
  .then((response) => console.log(response.body))
  .catch((error) => console.log(error.body));

from mailersend import MailerSendClient, DmarcMonitoringBuilder

ms = MailerSendClient()

request = DmarcMonitoringBuilder().page(1).limit(25).build_list_request()

response = ms.dmarc_monitoring.list_monitors(request)

package main

import (
	"context"
	"log"
	"time"

	"github.com/mailersend/mailersend-go"
)

var APIKey = "Api Key Here"

func main() {
	ms := mailersend.NewMailersend(APIKey)

	ctx := context.Background()
	ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
	defer cancel()

	options := &mailersend.ListDmarcMonitorOptions{
		Page:  1,
		Limit: 25,
	}

	_, _, err := ms.DmarcMonitoring.List(ctx, options)
	if err != nil {
		log.Fatal(err)
	}
}

import com.mailersend.sdk.MailerSend;
import com.mailersend.sdk.dmarcmonitoring.DmarcMonitor;
import com.mailersend.sdk.dmarcmonitoring.DmarcMonitorsList;
import com.mailersend.sdk.exceptions.MailerSendException;

public void listMonitors() {

    MailerSend ms = new MailerSend();
    ms.setToken("Your API token");

    try {

        DmarcMonitorsList list = ms.dmarcMonitoring().getMonitors();

        for (DmarcMonitor monitor : list.monitors) {
            System.out.println(monitor.id);
            System.out.println(monitor.dmarcRecord);
            System.out.println(monitor.spfStatus);
        }

    } catch (MailerSendException e) {
        e.printStackTrace();
    }
}

require "mailersend-ruby"

ms_client = Mailersend::Client.new('your_mailersend_token')

ms_dmarc = Mailersend::DmarcMonitoring.new(ms_client)
ms_dmarc.list

Responses

Valid

Response Code: 200 OK
Response Headers:
	content-type: application/json

{
    "data": [
        {
            "id": "9dnxr7qvdqg6pm0e",
            "dmarc_record": "v=DMARC1; p=reject; rua=mailto:dmarc_agg@dmarc.example.org,mailto:rua-dev@tests.example.org,mailto:rua@example.org; ruf=mailto:dmarc_fr@dmarc.example.org; fo=1; pct=100; rf=afrf",
            "wanted_dmarc_record": "v=DMARC1; p=reject; rua=mailto:dmarc_agg@dmarc.example.org,mailto:rua-dev@tests.example.org,mailto:rua@example.org; ruf=mailto:dmarc_fr@dmarc.example.org; fo=1; pct=100; rf=afrf",
            "dmarc_valid": true,
            "dmarc_record_checked_at": "2025-11-05T09:06:35.000000Z",
            "spf_record": "v=spf1 include:_spf.example.org include:_spf.example.org include:example.org include:_spf.example.org ip4:192.0.2.1 include:example.org -all",
            "spf_status": "valid",
            "created_at": "2025-11-05T09:06:35.000000Z",
            "updated_at": "2025-11-05T09:06:35.000000Z",
            "domain": {
                "id": "5genxmqlgozlyvk7",
                "name": "example.org",
                "created_at": "2025-11-05T06:18:44.000000Z",
                "updated_at": "2025-11-05T06:19:14.000000Z"
            }
        }
    ],
    "links": {
        "first": "https://api.mailersend.com/v1/dmarc-monitoring?page=1",
        "last": null,
        "prev": null,
        "next": null
    },
    "meta": {
        "current_page": 1,
        "current_page_url": "https://api.mailersend.com/v1/dmarc-monitoring?page=1",
        "from": 1,
        "path": "https://api.mailersend.com/v1/dmarc-monitoring",
        "per_page": 25,
        "to": 1
    }
}

Error

Response Code: 422 Unprocessable Entity

See - Validation errors

Create a monitor

If you want to create a new DMARC monitor for a domain, use this POST request:

POST https://api.mailersend.com/v1/dmarc-monitoring

Request parameters

JSON parameters are provided in dot notation

JSON Parameter	Type	Required	Limitations	Details
`domain_id`	`string`	yes		Must be a verified domain. Only one monitor can be created per domain.

Request body

{
    "domain_id": "0z76k5jg0o3yeg2d"
}

use MailerSend\MailerSend;
use MailerSend\Helpers\Builder\DmarcMonitoringParams;

$mailersend = new MailerSend(['api_key' => 'key']);

$mailersend->dmarcMonitoring->create(
    (new DmarcMonitoringParams('domain-id'))
);

import 'dotenv/config';
import { MailerSend, Dmarc } from "mailersend";

const mailerSend = new MailerSend({
  apiKey: process.env.API_KEY,
});

const dmarc = new Dmarc("domain_id");

mailerSend.dmarc.create(dmarc)
  .then((response) => console.log(response.body))
  .catch((error) => console.log(error.body));

from mailersend import MailerSendClient, DmarcMonitoringBuilder

ms = MailerSendClient()

request = DmarcMonitoringBuilder().domain_id("your-domain-id").build_create_request()

response = ms.dmarc_monitoring.create_monitor(request)

package main

import (
	"context"
	"log"
	"time"

	"github.com/mailersend/mailersend-go"
)

var APIKey = "Api Key Here"

func main() {
	ms := mailersend.NewMailersend(APIKey)

	ctx := context.Background()
	ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
	defer cancel()

	options := &mailersend.CreateDmarcMonitorOptions{
		DomainID: "domain-id",
	}

	_, _, err := ms.DmarcMonitoring.Create(ctx, options)
	if err != nil {
		log.Fatal(err)
	}
}

import com.mailersend.sdk.MailerSend;
import com.mailersend.sdk.dmarcmonitoring.DmarcMonitor;
import com.mailersend.sdk.exceptions.MailerSendException;

public void createMonitor() {

    MailerSend ms = new MailerSend();
    ms.setToken("Your API token");

    try {

        DmarcMonitor monitor = ms.dmarcMonitoring().createMonitorBuilder()
                .createMonitor("your-domain-id");

        System.out.println(monitor.id);
        System.out.println(monitor.wantedDmarcRecord);

    } catch (MailerSendException e) {
        e.printStackTrace();
    }
}

require "mailersend-ruby"

ms_client = Mailersend::Client.new('your_mailersend_token')

ms_dmarc = Mailersend::DmarcMonitoring.new(ms_client)
ms_dmarc.create(domain_id: "idofdomain12412")

Responses

Valid

Response Code: 201 CREATED
Response Headers:
	content-type: application/json

{
    "data": {
        "id": "lx1p78jk1o53rzn4",
        "dmarc_record": "",
        "wanted_dmarc_record": "rua=mailto:rua@example.org",
        "dmarc_valid": false,
        "dmarc_record_checked_at": null,
        "spf_record": null,
        "spf_status": "not_found",
        "created_at": "2025-11-06T10:27:34.000000Z",
        "updated_at": "2025-11-06T10:27:34.000000Z",
        "domain": {
            "id": "0z76k5jg0o3yeg2d",
            "name": "example.org",
            "created_at": "2025-11-06T10:24:03.000000Z",
            "updated_at": "2025-11-06T10:25:47.000000Z"
        }
    }
}

Error

Response Code: 422 Unprocessable Entity

See - Validation errors

Update a monitor

If you want to update a DMARC monitor, use this PUT request:

PUT https://api.mailersend.com/v1/dmarc-monitoring/{monitor_id}

Request parameters

URL parameter	Type	Required	Limitations	Details
`monitor_id`	`string`	yes

JSON parameters are provided in dot notation

JSON Parameter	Type	Required	Limitations	Details
`wanted_dmarc_record`	`string`	yes	Max: `1000`	Must be a valid DMARC record format (e.g. `v=DMARC1; p=none; rua=mailto:...`).

Request body

{
    "wanted_dmarc_record": "v=DMARC1; p=reject; rua=mailto:dmarc_agg@dmarc.example.org"
}

use MailerSend\MailerSend;
use MailerSend\Helpers\Builder\DmarcMonitoringUpdateParams;

$mailersend = new MailerSend(['api_key' => 'key']);

$mailersend->dmarcMonitoring->update(
    'monitor-id',
    (new DmarcMonitoringUpdateParams('v=DMARC1; p=reject; rua=mailto:dmarc_agg@dmarc.example.org'))
);

import 'dotenv/config';
import { MailerSend } from "mailersend";

const mailerSend = new MailerSend({
  apiKey: process.env.API_KEY,
});

mailerSend.dmarc.update("monitor_id", { wanted_dmarc_record: "v=DMARC1; p=reject; rua=mailto:dmarc_agg@dmarc.example.org" })
  .then((response) => console.log(response.body))
  .catch((error) => console.log(error.body));

from mailersend import MailerSendClient, DmarcMonitoringBuilder

ms = MailerSendClient()

request = (
    DmarcMonitoringBuilder()
    .monitor_id("monitor-id")
    .wanted_dmarc_record("v=DMARC1; p=reject; rua=mailto:dmarc_agg@dmarc.example.org")
    .build_update_request()
)

response = ms.dmarc_monitoring.update_monitor(request)

package main

import (
	"context"
	"log"
	"time"

	"github.com/mailersend/mailersend-go"
)

var APIKey = "Api Key Here"

func main() {
	ms := mailersend.NewMailersend(APIKey)

	ctx := context.Background()
	ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
	defer cancel()

	options := &mailersend.UpdateDmarcMonitorOptions{
		MonitorID:         "monitor-id",
		WantedDmarcRecord: "v=DMARC1; p=reject; rua=mailto:dmarc_agg@dmarc.example.org",
	}

	_, _, err := ms.DmarcMonitoring.Update(ctx, options)
	if err != nil {
		log.Fatal(err)
	}
}

import com.mailersend.sdk.MailerSend;
import com.mailersend.sdk.dmarcmonitoring.DmarcMonitor;
import com.mailersend.sdk.exceptions.MailerSendException;

public void updateMonitor() {

    MailerSend ms = new MailerSend();
    ms.setToken("Your API token");

    try {

        DmarcMonitor monitor = ms.dmarcMonitoring().updateMonitorBuilder()
                .wantedDmarcRecord("v=DMARC1; p=reject; rua=mailto:dmarc_agg@dmarc.example.org")
                .updateMonitor("your-monitor-id");

        System.out.println(monitor.id);
        System.out.println(monitor.wantedDmarcRecord);

    } catch (MailerSendException e) {
        e.printStackTrace();
    }
}

require "mailersend-ruby"

ms_client = Mailersend::Client.new('your_mailersend_token')

ms_dmarc = Mailersend::DmarcMonitoring.new(ms_client)
ms_dmarc.update(monitor_id: "idofmonitor12412", wanted_dmarc_record: "v=DMARC1; p=reject; rua=mailto:dmarc_agg@dmarc.example.org")

Responses

Valid

Response Code: 200 OK
Response Headers:
	content-type: application/json

{
    "data": {
        "id": "lx1p78jk1o53rzn4",
        "dmarc_record": "",
        "wanted_dmarc_record": "v=DMARC1; p=reject; rua=mailto:dmarc_agg@dmarc.example.org,mailto:rua-ms@example.org",
        "dmarc_valid": false,
        "dmarc_record_checked_at": "2025-11-06T10:31:55.000000Z",
        "spf_record": null,
        "spf_status": "not_found",
        "created_at": "2025-11-06T10:27:34.000000Z",
        "updated_at": "2025-11-06T10:31:55.000000Z",
        "domain": {
            "id": "0z76k5jg0o3yeg2d",
            "name": "example.org",
            "created_at": "2025-11-06T10:24:03.000000Z",
            "updated_at": "2025-11-06T10:25:47.000000Z"
        }
    }
}

Error

Response Code: 422 Unprocessable Entity

See - Validation errors

Delete a monitor

If you want to delete a DMARC monitor, use this DELETE request:

DELETE https://api.mailersend.com/v1/dmarc-monitoring/{monitor_id}

Request parameters

URL parameter	Type	Required	Limitations	Details
`monitor_id`	`string`	yes

use MailerSend\MailerSend;

$mailersend = new MailerSend(['api_key' => 'key']);

$mailersend->dmarcMonitoring->delete('monitor-id');

import 'dotenv/config';
import { MailerSend } from "mailersend";

const mailerSend = new MailerSend({
  apiKey: process.env.API_KEY,
});

mailerSend.dmarc.delete("monitor_id")
  .then((response) => console.log(response.body))
  .catch((error) => console.log(error.body));

from mailersend import MailerSendClient, DmarcMonitoringBuilder

ms = MailerSendClient()

request = DmarcMonitoringBuilder().monitor_id("monitor-id").build_delete_request()

response = ms.dmarc_monitoring.delete_monitor(request)

package main

import (
	"context"
	"log"
	"time"

	"github.com/mailersend/mailersend-go"
)

var APIKey = "Api Key Here"

func main() {
	ms := mailersend.NewMailersend(APIKey)

	ctx := context.Background()
	ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
	defer cancel()

	_, err := ms.DmarcMonitoring.Delete(ctx, "monitor-id")
	if err != nil {
		log.Fatal(err)
	}
}

import com.mailersend.sdk.MailerSend;
import com.mailersend.sdk.exceptions.MailerSendException;

public void deleteMonitor() {

    MailerSend ms = new MailerSend();
    ms.setToken("Your API token");

    try {

        boolean deleted = ms.dmarcMonitoring().deleteMonitor("your-monitor-id");

        System.out.println("Monitor deleted: " + deleted);

    } catch (MailerSendException e) {
        e.printStackTrace();
    }
}

require "mailersend-ruby"

ms_client = Mailersend::Client.new('your_mailersend_token')

ms_dmarc = Mailersend::DmarcMonitoring.new(ms_client)
ms_dmarc.delete(monitor_id: "idofmonitor12412")

Responses

Valid

Response Code: 204 No Content

Error

Response Code: 404 Not Found

Get aggregated reports

If you want to retrieve aggregated DMARC reports for a monitor, use this GET request:

GET https://api.mailersend.com/v1/dmarc-monitoring/{monitor_id}/report

Request parameters

URL parameter	Type	Required	Limitations	Details
`monitor_id`	`string`	yes

Query parameter	Type	Required	Limitations	Details
`page`	`int`	no	Min: `1`
`limit`	`int`	no	Min: `1`, Max: `100`	Default: `25`
`date_from`	`string`	no		Filter by report date (from). Format: Unix timestamp (`1704067200`), `Y-m-d H:i:s` (`2024-01-01 00:00:00`) or ISO 8601 (`2024-01-01T00:00:00Z`)
`date_to`	`string`	no		Filter by report date (to). Same format as `date_from`. Requires `date_from`, must be after it and not in the future
`search`	`string`	no	Max: `255`
`category`	`string`	no
`report_source`	`string`	no	Max: `255`	Filter by reporting organization

use MailerSend\MailerSend;

$mailersend = new MailerSend(['api_key' => 'key']);

$mailersend->dmarcMonitoring->getAggregatedReports('monitor-id', $page = 1, $limit = 25);

import 'dotenv/config';
import { MailerSend } from "mailersend";

const mailerSend = new MailerSend({
  apiKey: process.env.API_KEY,
});

mailerSend.dmarc.report("monitor_id", { page: 1, limit: 25 })
  .then((response) => console.log(response.body))
  .catch((error) => console.log(error.body));

from mailersend import MailerSendClient, DmarcMonitoringBuilder

ms = MailerSendClient()

request = (
    DmarcMonitoringBuilder()
    .monitor_id("monitor-id")
    .page(1)
    .limit(25)
    .build_report_request()
)

response = ms.dmarc_monitoring.get_aggregated_report(request)

package main

import (
	"context"
	"log"
	"time"

	"github.com/mailersend/mailersend-go"
)

var APIKey = "Api Key Here"

func main() {
	ms := mailersend.NewMailersend(APIKey)

	ctx := context.Background()
	ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
	defer cancel()

	options := &mailersend.ListDmarcReportOptions{
		MonitorID: "monitor-id",
		Page:      1,
		Limit:     25,
	}

	_, _, err := ms.DmarcMonitoring.GetAggregatedReport(ctx, options)
	if err != nil {
		log.Fatal(err)
	}
}

import com.mailersend.sdk.MailerSend;
import com.mailersend.sdk.dmarcmonitoring.DmarcAggregatedReport;
import com.mailersend.sdk.dmarcmonitoring.DmarcAggregatedReportList;
import com.mailersend.sdk.exceptions.MailerSendException;

public void getAggregatedReport() {

    MailerSend ms = new MailerSend();
    ms.setToken("Your API token");

    try {

        DmarcAggregatedReportList list = ms.dmarcMonitoring().getAggregatedReport("your-monitor-id");

        for (DmarcAggregatedReport report : list.reports) {
            System.out.println(report.ipAddress);
            System.out.println(report.totalVolume);
            System.out.println(report.passedDmarc);
            System.out.println(report.isFavorite);
        }

    } catch (MailerSendException e) {
        e.printStackTrace();
    }
}

require "mailersend-ruby"

ms_client = Mailersend::Client.new('your_mailersend_token')

ms_dmarc = Mailersend::DmarcMonitoring.new(ms_client)
ms_dmarc.report(monitor_id: "idofmonitor12412")

Responses

Valid

Response Code: 200 OK
Response Headers:
	content-type: application/json

{
    "data": [
        {
            "ip_address": "192.0.2.1",
            "total_volume": 2,
            "passed_dmarc": "100%",
            "passed_spf": "0%",
            "passed_dkim": "100%",
            "domain": "example.org",
            "country": "United States",
            "country_code": "US",
            "city": null,
            "is_favorite": true
        },
        {
            "ip_address": "192.0.2.2",
            "total_volume": 2,
            "passed_dmarc": "100%",
            "passed_spf": "100%",
            "passed_dkim": "100%",
            "domain": "example.org",
            "country": "United States",
            "country_code": "US",
            "city": null
        }
    ],
    "links": {
        "first": "https://api.mailersend.com/v1/dmarc-monitoring/9dnxr7qvdqg6pm0e/report?page=1",
        "last": "https://api.mailersend.com/v1/dmarc-monitoring/9dnxr7qvdqg6pm0e/report?page=1",
        "prev": null,
        "next": null
    },
    "meta": {
        "current_page": 1,
        "from": 1,
        "last_page": 1,
        "links": [
            {
                "url": null,
                "label": "&laquo; Previous",
                "page": null,
                "active": false
            },
            {
                "url": "https://api.mailersend.com/v1/dmarc-monitoring/9dnxr7qvdqg6pm0e/report?page=1",
                "label": "1",
                "page": 1,
                "active": true
            },
            {
                "url": null,
                "label": "Next &raquo;",
                "page": null,
                "active": false
            }
        ],
        "path": "https://api.mailersend.com/v1/dmarc-monitoring/9dnxr7qvdqg6pm0e/report",
        "per_page": 25,
        "to": 2,
        "total": 2
    }
}

Error

Response Code: 404 Not Found

Response Code: 422 Unprocessable Entity

See - Validation errors

Get IP-specific reports

If you want to retrieve detailed DMARC reports for a specific IP address, use this GET request:

GET https://api.mailersend.com/v1/dmarc-monitoring/{monitor_id}/report/{ip}

Request parameters

URL parameter	Type	Required	Limitations	Details
`monitor_id`	`string`	yes
`ip`	`string`	yes

Query parameter	Type	Required	Limitations	Details
`page`	`int`	no	Min: `1`
`limit`	`int`	no	Min: `1`, Max: `100`	Default: `25`
`date_from`	`string`	no		Filter by report date (from). Format: Unix timestamp (`1704067200`), `Y-m-d H:i:s` (`2024-01-01 00:00:00`) or ISO 8601 (`2024-01-01T00:00:00Z`)
`date_to`	`string`	no		Filter by report date (to). Same format as `date_from`. Requires `date_from`, must be after it and not in the future
`search`	`string`	no	Max: `255`
`category`	`string`	no
`report_source`	`string`	no	Max: `255`	Filter by reporting organization

use MailerSend\MailerSend;

$mailersend = new MailerSend(['api_key' => 'key']);

$mailersend->dmarcMonitoring->getIpReports('monitor-id', '192.0.2.1', $page = 1, $limit = 25);

import 'dotenv/config';
import { MailerSend } from "mailersend";

const mailerSend = new MailerSend({
  apiKey: process.env.API_KEY,
});

mailerSend.dmarc.reportByIp("monitor_id", "192.0.2.1", { page: 1, limit: 25 })
  .then((response) => console.log(response.body))
  .catch((error) => console.log(error.body));

from mailersend import MailerSendClient, DmarcMonitoringBuilder

ms = MailerSendClient()

request = (
    DmarcMonitoringBuilder()
    .monitor_id("monitor-id")
    .ip("192.0.2.1")
    .page(1)
    .limit(25)
    .build_ip_report_request()
)

response = ms.dmarc_monitoring.get_ip_report(request)

package main

import (
	"context"
	"log"
	"time"

	"github.com/mailersend/mailersend-go"
)

var APIKey = "Api Key Here"

func main() {
	ms := mailersend.NewMailersend(APIKey)

	ctx := context.Background()
	ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
	defer cancel()

	_, _, err := ms.DmarcMonitoring.GetIPReport(ctx, "monitor-id", "192.0.2.1")
	if err != nil {
		log.Fatal(err)
	}
}

import com.mailersend.sdk.MailerSend;
import com.mailersend.sdk.dmarcmonitoring.DmarcIpReport;
import com.mailersend.sdk.dmarcmonitoring.DmarcIpReportList;
import com.mailersend.sdk.exceptions.MailerSendException;

public void getIpReport() {

    MailerSend ms = new MailerSend();
    ms.setToken("Your API token");

    try {

        DmarcIpReportList list = ms.dmarcMonitoring().getIpReport("your-monitor-id", "192.0.2.1");

        for (DmarcIpReport report : list.reports) {
            System.out.println(report.ipAddress);
            System.out.println(report.totalVolume);
            System.out.println(report.appliedPolicy);
            System.out.println(report.reportSource);
        }

    } catch (MailerSendException e) {
        e.printStackTrace();
    }
}

require "mailersend-ruby"

ms_client = Mailersend::Client.new('your_mailersend_token')

ms_dmarc = Mailersend::DmarcMonitoring.new(ms_client)
ms_dmarc.report_by_ip(monitor_id: "idofmonitor12412", ip: "192.0.2.1")

Responses

Valid

Response Code: 200 OK
Response Headers:
	content-type: application/json

{
    "data": [
        {
            "id": "690b12b39dc30891fc35d3da",
            "ip_address": "192.0.2.1",
            "ip_domain": "example.org",
            "total_volume": 2,
            "passed_dmarc": "100%",
            "passed_spf": "0%",
            "spf_domain": null,
            "aligned_spf": false,
            "passed_dkim": "100%",
            "aligned_dkim": true,
            "dkim_domain": null,
            "created_at": "2025-11-05T00:00:00.000000Z",
            "applied_policy": "none",
            "override_reason": null,
            "override_comment": null,
            "domain": null,
            "country": null,
            "country_code": null,
            "city": null,
            "report_source": "example.com",
            "spf_auth": [
                {
                    "type": "spf",
                    "result": "pass",
                    "domain": "example.org",
                    "selector": null
                }
            ],
            "dkim_auth": [
                {
                    "type": "dkim",
                    "result": "fail",
                    "domain": "example.org",
                    "selector": "example"
                }
            ]
        }
    ],
    "links": {
        "first": "https://api.mailersend.com/v1/dmarc-monitoring/9dnxr7qvdqg6pm0e/report/192.0.2.1?page=1",
        "last": "https://api.mailersend.com/v1/dmarc-monitoring/9dnxr7qvdqg6pm0e/report/192.0.2.1?page=1",
        "prev": null,
        "next": null
    },
    "meta": {
        "current_page": 1,
        "from": 1,
        "last_page": 1,
        "links": [
            {
                "url": null,
                "label": "&laquo; Previous",
                "page": null,
                "active": false
            },
            {
                "url": "https://api.mailersend.com/v1/dmarc-monitoring/9dnxr7qvdqg6pm0e/report/192.0.2.1?page=1",
                "label": "1",
                "page": 1,
                "active": true
            },
            {
                "url": null,
                "label": "Next &raquo;",
                "page": null,
                "active": false
            }
        ],
        "path": "https://api.mailersend.com/v1/dmarc-monitoring/9dnxr7qvdqg6pm0e/report/192.0.2.1",
        "per_page": 25,
        "to": 1,
        "total": 1
    }
}

Error

Response Code: 404 Not Found

Response Code: 422 Unprocessable Entity

See - Validation errors

Get report sources

If you want to retrieve a list of report sources for a monitor, use this GET request:

GET https://api.mailersend.com/v1/dmarc-monitoring/{monitor_id}/report-sources

Request parameters

URL parameter	Type	Required	Limitations	Details
`monitor_id`	`string`	yes

Query parameter	Type	Required	Limitations	Details
`date_from`	`string`	yes		Filter start date. Format: Unix timestamp (`1704067200`), `Y-m-d H:i:s` (`2024-01-01 00:00:00`) or ISO 8601 (`2024-01-01T00:00:00Z`)
`date_to`	`string`	yes		Filter end date. Same format as `date_from`. Must be after `date_from` and not in the future
`status`	`string`	no		Filter by acceptance status. Allowed values: `accepted`, `rejected`, `quarantined`

use MailerSend\MailerSend;

$mailersend = new MailerSend(['api_key' => 'key']);

$mailersend->dmarcMonitoring->getReportSources('monitor-id', '2024-01-01 00:00:00', '2024-01-31 23:59:59');

import 'dotenv/config';
import { MailerSend } from "mailersend";

const mailerSend = new MailerSend({
  apiKey: process.env.API_KEY,
});

mailerSend.dmarc.reportSources("monitor_id", {
  date_from: "1704067200",
  date_to: "1706745599",
})
  .then((response) => console.log(response.body))
  .catch((error) => console.log(error.body));

import com.mailersend.sdk.MailerSend;
import com.mailersend.sdk.dmarcmonitoring.DmarcReportSource;
import com.mailersend.sdk.dmarcmonitoring.DmarcReportSourcesList;
import com.mailersend.sdk.exceptions.MailerSendException;

public void getReportSources() {

    MailerSend ms = new MailerSend();
    ms.setToken("Your API token");

    try {

        DmarcReportSourcesList list = ms.dmarcMonitoring()
                .dateFrom("1704067200")
                .dateTo("1706745599")
                .getReportSources("your-monitor-id");

        for (DmarcReportSource source : list.sources) {
            System.out.println(source.reportSource);
            System.out.println(source.reports);
        }

    } catch (MailerSendException e) {
        e.printStackTrace();
    }
}

Responses

Valid

Response Code: 200 OK
Response Headers:
	content-type: application/json

{
    "data": [
        {
            "report_source": "example.com",
            "reports": 3
        }
    ]
}

Error

Response Code: 404 Not Found

Response Code: 422 Unprocessable Entity

See - Validation errors

Mark IP as favorite

If you want to mark an IP address as a favorite for a monitor, use this PUT request:

PUT https://api.mailersend.com/v1/dmarc-monitoring/{monitor_id}/favorite/{ip}

Request parameters

URL parameter	Type	Required	Limitations	Details
`monitor_id`	`string`	yes
`ip`	`string`	yes

use MailerSend\MailerSend;

$mailersend = new MailerSend(['api_key' => 'key']);

$mailersend->dmarcMonitoring->markIpAsFavorite('monitor-id', '192.0.2.1');

import 'dotenv/config';
import { MailerSend } from "mailersend";

const mailerSend = new MailerSend({
  apiKey: process.env.API_KEY,
});

mailerSend.dmarc.addFavorite("monitor_id", "192.0.2.1")
  .then((response) => console.log(response.body))
  .catch((error) => console.log(error.body));

from mailersend import MailerSendClient, DmarcMonitoringBuilder

ms = MailerSendClient()

request = (
    DmarcMonitoringBuilder()
    .monitor_id("monitor-id")
    .ip("192.0.2.1")
    .build_mark_favorite_request()
)

response = ms.dmarc_monitoring.mark_ip_favorite(request)

package main

import (
	"context"
	"log"
	"time"

	"github.com/mailersend/mailersend-go"
)

var APIKey = "Api Key Here"

func main() {
	ms := mailersend.NewMailersend(APIKey)

	ctx := context.Background()
	ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
	defer cancel()

	_, err := ms.DmarcMonitoring.MarkIPFavorite(ctx, "monitor-id", "192.0.2.1")
	if err != nil {
		log.Fatal(err)
	}
}

import com.mailersend.sdk.MailerSend;
import com.mailersend.sdk.exceptions.MailerSendException;

public void markIpAsFavorite() {

    MailerSend ms = new MailerSend();
    ms.setToken("Your API token");

    try {

        boolean marked = ms.dmarcMonitoring().markIpAsFavorite("your-monitor-id", "192.0.2.1");

        System.out.println("IP marked as favorite: " + marked);

    } catch (MailerSendException e) {
        e.printStackTrace();
    }
}

require "mailersend-ruby"

ms_client = Mailersend::Client.new('your_mailersend_token')

ms_dmarc = Mailersend::DmarcMonitoring.new(ms_client)
ms_dmarc.add_favorite(monitor_id: "idofmonitor12412", ip: "192.0.2.1")

Responses

Valid

Response Code: 200 OK
Response Headers:
	content-type: application/json

[]

Error

Response Code: 404 Not Found

Remove IP from favorites

If you want to remove an IP address from favorites for a monitor, use this DELETE request:

DELETE https://api.mailersend.com/v1/dmarc-monitoring/{monitor_id}/favorite/{ip}

Request parameters

URL parameter	Type	Required	Limitations	Details
`monitor_id`	`string`	yes
`ip`	`string`	yes

use MailerSend\MailerSend;

$mailersend = new MailerSend(['api_key' => 'key']);

$mailersend->dmarcMonitoring->removeIpFromFavorites('monitor-id', '192.0.2.1');

import 'dotenv/config';
import { MailerSend } from "mailersend";

const mailerSend = new MailerSend({
  apiKey: process.env.API_KEY,
});

mailerSend.dmarc.removeFavorite("monitor_id", "192.0.2.1")
  .then((response) => console.log(response.body))
  .catch((error) => console.log(error.body));

from mailersend import MailerSendClient, DmarcMonitoringBuilder

ms = MailerSendClient()

request = (
    DmarcMonitoringBuilder()
    .monitor_id("monitor-id")
    .ip("192.0.2.1")
    .build_remove_favorite_request()
)

response = ms.dmarc_monitoring.remove_ip_favorite(request)

package main

import (
	"context"
	"log"
	"time"

	"github.com/mailersend/mailersend-go"
)

var APIKey = "Api Key Here"

func main() {
	ms := mailersend.NewMailersend(APIKey)

	ctx := context.Background()
	ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
	defer cancel()

	_, err := ms.DmarcMonitoring.RemoveIPFavorite(ctx, "monitor-id", "192.0.2.1")
	if err != nil {
		log.Fatal(err)
	}
}

import com.mailersend.sdk.MailerSend;
import com.mailersend.sdk.exceptions.MailerSendException;

public void removeIpFromFavorites() {

    MailerSend ms = new MailerSend();
    ms.setToken("Your API token");

    try {

        boolean removed = ms.dmarcMonitoring().removeIpFromFavorites("your-monitor-id", "192.0.2.1");

        System.out.println("IP removed from favorites: " + removed);

    } catch (MailerSendException e) {
        e.printStackTrace();
    }
}

require "mailersend-ruby"

ms_client = Mailersend::Client.new('your_mailersend_token')

ms_dmarc = Mailersend::DmarcMonitoring.new(ms_client)
ms_dmarc.remove_favorite(monitor_id: "idofmonitor12412", ip: "192.0.2.1")

Responses

Valid

Response Code: 204 No Content

Error

Response Code: 404 Not Found

Webhooks

View available webhook events and create, manage and update webhooks with the Webhooks API endpoint. Create triggered workflows and automations.

Blocklist Monitoring

Monitor your sending domains and IP addresses for blocklist hits with MailerSend's Blocklist Monitoring API. Create and manage monitors, receive notifications, and track blocklist status.