Ellipse Gradient for Header

Datto RMM Integration Guide

Connect Datto RMM monitoring, device, site, alert, job, and policy data with enterprise systems through REST APIs, selected webhook notifications, and Martini workflows.

Datto RMM integration options at a glance

Datto RMM’s primary integration mechanism is its REST API, which provides access to Accounts, Sites, Devices, Alerts, Jobs, Policies, and related resources. Datto RMM also supports webhook-style outbound notifications for selected operational events, although coverage should not be assumed for every object or state change. OAuth-based authentication uses client credentials, regional platform endpoints, and bearer access tokens. Martini can consume these APIs, receive supported notifications, schedule paginated synchronization workflows, apply mappings and business rules, and expose normalized REST APIs to downstream applications. Where webhook coverage is incomplete, Martini can use polling, checkpoints, reconciliation, bounded batches, and controlled retries.

Integration pointSupported by Datto RMM?Common use casesHow Martini supports it
REST APIsYesRetrieve and manage Accounts, Sites, Devices, Alerts, Jobs, Policies, and related resources. REST is the primary Datto RMM integration interface.Martini can consume the Datto RMM REST API from workflows, map responses, apply business rules, and expose normalized APIs.
Webhooks / outbound callbacksLimitedReceive notifications for selected operational events. Coverage should not be assumed for every object or state transition.Martini can receive HTTP notifications, validate and normalize them, process them asynchronously where appropriate, and use polling for uncovered events.
AuthenticationYesOAuth-based client credentials, regional platform endpoints, bearer access tokens, and permission-scoped API clients are used for API access.Martini can store credentials and tokens in secrets or secured environment configuration and send bearer authentication on API calls.
Pagination and application-managed batchingYesLarge device, site, and alert collections should be retrieved through pagination and bounded batches; a general-purpose bulk API was not confirmed.Martini workflows can loop through pages, persist checkpoints, limit batch size, and resume incremental synchronization.
Bulk / asynchronous APIsNot confirmedA general-purpose bulk or asynchronous data API was not confirmed for all core Datto RMM objects.Martini can implement bounded, scheduler-triggered REST batches instead of assuming a vendor bulk endpoint.
File / attachment APIsNot confirmedA general-purpose Datto RMM file or attachment API was not confirmed in the reviewed material.Martini should use documented REST resources only and should not assume that scripts or job artifacts are exposed as attachments.
Database / analytics accessNoDirect database access to the Datto RMM SaaS platform is not an integration approach.Martini can integrate through Datto RMM APIs and supported notifications, then write data to an approved reporting database or service.
SDKs and client librariesNot confirmedA vendor-maintained SDK was not confirmed as the required or primary integration method.Martini can use the documented HTTP API directly and isolate request logic in reusable workflow assets.

How Datto RMM exposes data and business events

Datto RMM REST APIs

Datto RMM’s REST API is the primary documented integration mechanism for Accounts, Sites, Devices, Alerts, Jobs, Policies, and related resources. It supports retrieval and management operations subject to the endpoint and client permissions.

Martini implementation pattern

Martini implementation pattern: a workflow authenticates against the tenant’s regional Datto RMM platform, retrieves resources with pagination, maps the response into a canonical model, applies business rules, and writes to a target system or exposes the result through a Martini API.

Implementation sequence

Acquire an OAuth access token for the Datto RMM platform
Call the documented REST resource
Follow pagination and persist the synchronization cursor
Map the Datto RMM object to the target model
Apply routing, validation, and idempotency rules
Write the result and record the outcome

Datto RMM webhook notifications

Datto RMM supports webhook-style outbound notifications for selected operational events. These notifications are not a complete event stream for every Datto RMM object or state transition.

Martini implementation pattern

Martini implementation pattern: a workflow receives the notification, validates the request and event type, acknowledges quickly where appropriate, retrieves current resource details through the REST API, and processes the event asynchronously. Scheduled reconciliation covers gaps in webhook coverage.

Implementation sequence

Receive the Datto RMM webhook notification
Validate the request and confirm the event type
Acknowledge the notification within the expected response window
Retrieve current resource details when the payload is incomplete
Map and route the event to the target system
Store the source identifier and reconcile missed events

Scheduled Datto RMM synchronization

Scheduled REST retrieval is appropriate for inventory reconciliation and events not covered by selected webhook notifications. Large collections should use pagination, bounded batches, and checkpoints.

Martini implementation pattern

Martini implementation pattern: a scheduler starts a workflow that reads the last successful cursor, retrieves pages of Sites, Devices, Alerts, or Policies, applies incremental comparison logic, and records progress so a failed run can resume safely.

Implementation sequence

Start the workflow on a defined schedule
Read the saved cursor or last successful timestamp
Retrieve the next bounded page of Datto RMM resources
Transform and upsert the page into the target system
Persist progress after successful writes
Retry transient failures and report unreconciled items

Common Datto RMM integration patterns

Pattern 1: Route alerts to service tickets

When to use this pattern

Use this pattern when monitoring Alerts should create or update incidents in a PSA or service-management platform. Selected webhook notifications can provide lower latency, while polling provides coverage for events that are not notified.

Integration direction
Datto RMM
Martini
Autotask PSA or ConnectWise Manage
Example Mapping
Datto RMM FieldCanonical FieldTarget Field
alertIdsourceAlertIdexternalReference
severityprioritypriority
deviceIdconfigurationItemIdasset
messagedescriptiondescription
Martini implementation pattern

Martini receives or retrieves the Alert, validates severity and account context, enriches it with Site and Device details, and checks the source alert ID before creating a ticket. Existing tickets are updated instead of duplicated, and transient failures are retried without blindly repeating non-idempotent creates.

Martini capabilities used
  • workflows
  • API consumption
  • data mapping
  • business rules
  • error handling

Pattern 2: Synchronize devices to a CMDB

When to use this pattern

Use this pattern to maintain an inventory of Datto RMM Devices and Sites in ServiceNow or another CMDB. It is suited to scheduled reconciliation where inventory completeness matters more than event latency.

Integration direction
Datto RMM
Martini
ServiceNow
Example Mapping
Datto RMM FieldCanonical FieldTarget Field
deviceIdsourceDeviceIdcorrelation_id
hostnamedeviceNamename
siteIdsourceSiteIdlocation
lastSeenlastCheckInlast_discovered
Martini implementation pattern

A scheduled Martini workflow retrieves paginated Sites and Devices, resolves relationships, maps endpoint properties, and upserts configuration items using stable source identifiers. It marks or reports missing devices according to an agreed lifecycle rule and resumes from a checkpoint after failures.

Martini capabilities used
  • scheduled workflows
  • API consumption
  • pagination and checkpointing
  • data mapping
  • idempotent writes

Pattern 3: Expose controlled remediation requests

When to use this pattern

Use this pattern when ServiceNow, a PSA, or an operations portal must request a documented Datto RMM job or management action against a specific Device.

Integration direction
ServiceNow
Martini
Datto RMM
Example Mapping
Datto RMM FieldCanonical FieldTarget Field
deviceIdtargetDeviceIddeviceId
jobIdapprovedActionjobId
requesterinitiatedByaudit.actor
requestIdidempotencyKeyrequestCorrelationId
Martini implementation pattern

Martini exposes a protected REST API, validates the caller and request, checks that the action is approved and has not already run, locates the Device, and invokes the documented Datto RMM operation. The workflow records the operator, target, result, and failure details for audit and retry handling.

Martini capabilities used
  • API exposure
  • authentication and authorization
  • workflows
  • business rules
  • audit logging
  • error handling

Pattern 4: Build site and policy governance reporting

When to use this pattern

Use this pattern for scheduled operational reporting across Sites, Devices, Policies, Alerts, and Jobs, including identifying policy exceptions, elevated alert volumes, or endpoints that have not checked in recently.

Integration direction
Datto RMM
Martini
Microsoft Power BI
Example Mapping
Datto RMM FieldCanonical FieldTarget Field
siteIdsiteKeySiteKey
deviceIddeviceKeyDeviceKey
policyIdassignedPolicyPolicyKey
alertCountopenAlertCountOpenAlerts
Martini implementation pattern

Martini extracts paginated resources, joins related context, applies governance rules, and writes stable reporting structures to a data store or reporting API. The workflow uses bounded batches, checkpoints, retries, and a final reconciliation summary before the reporting refresh.

Martini capabilities used
  • scheduled workflows
  • API consumption
  • data transformation
  • business rules
  • checkpointing
  • monitoring

Applications commonly integrated with Datto RMM

Datto RMM data can be connected to MSP service-management, enterprise operations, collaboration, and reporting products. The exact packaged behavior of any vendor relationship should be verified independently; Martini can implement the integration using each application’s supported APIs or HTTP endpoints.

Application Scenario Direction Martini Pattern
Autotask PSA Create and update service tickets from Datto RMM Alerts and associate managed Devices or customers with PSA records. Datto RMM → Martini → Autotask PSA Receive selected notifications or poll Alerts, correlate the Datto RMM alert identifier with an Autotask PSA ticket, apply routing and priority rules, and create or update the ticket with retry and duplicate protection.
ConnectWise Manage Route monitoring alerts into service tickets and synchronize customer, site, or configuration information. Datto RMM → Martini → ConnectWise Manage Use a webhook or scheduled REST workflow to normalize Alerts and Devices, map them to ConnectWise Manage objects, and preserve cross-system identifiers for idempotent ticket updates.
HaloPSA Convert Datto RMM alerts into incidents and associate them with customers and managed assets. Datto RMM → Martini → HaloPSA Poll or receive eligible alert events, validate the payload, map customer and device context, and invoke HaloPSA APIs with controlled retries and reconciliation.
ServiceNow Populate CMDB or incident records with managed-device and monitoring data and support approved remediation requests. Datto RMM → Martini → ServiceNow Synchronize Sites and Devices into CMDB structures, route Alerts to incidents, and expose a protected Martini API for validated ServiceNow remediation requests.
Microsoft Teams Send selected monitoring alerts and operational notifications to Teams channels. Datto RMM → Martini → Microsoft Teams Filter and enrich Datto RMM Alerts in a Martini workflow, format concise notifications, and deliver them through the supported Teams HTTP integration while recording delivery outcomes.
Slack Notify operations teams about critical Alerts, job failures, or device-state changes. Datto RMM → Martini → Slack Use selected webhook events or scheduled alert retrieval, apply severity and site routing rules, and send structured Slack notifications with duplicate suppression.
Microsoft Power BI Combine device, site, alert, and job data for MSP operational reporting. Datto RMM → Martini → Microsoft Power BI Extract paginated Datto RMM resources on a schedule, transform them into reporting tables, write to an intermediate data store or API, and expose stable data for Power BI refreshes.

How to build a Datto RMM integration in Martini

Objective

Configure the tenant-specific Datto RMM platform and OAuth credentials without embedding secrets in workflows.

Instructions in Martini

  • Create or obtain the Datto RMM API client and required permissions
  • Store client credentials and tokens in Martini secrets or secured environment configuration
  • Use the regional API and authorization endpoints supplied for the tenant

Objective

Select webhook-driven, scheduled, or API-driven execution according to event coverage and operational latency requirements.

Instructions in Martini

  • Use a webhook workflow for supported selected events
  • Use a scheduler for inventory, reconciliation, and uncovered state changes
  • Expose a protected Martini API for approved external requests

Objective

Call Datto RMM REST resources and obtain current resource details before processing downstream actions.

Instructions in Martini

  • Retrieve Accounts, Sites, Devices, Alerts, Jobs, or Policies as required
  • Implement pagination and bounded batches
  • Persist a cursor, timestamp, or source identifier for incremental processing

Objective

Coordinate enrichment, routing, target writes, and operational controls in a Martini workflow.

Instructions in Martini

  • Resolve related Site, Device, or Account context
  • Separate read-only inventory from remediation operations
  • Use asynchronous processing where webhook work is too heavy for the acknowledgement path

Objective

Transform Datto RMM objects into canonical and target-system models while enforcing data quality rules.

Instructions in Martini

  • Map stable source identifiers and retain cross-system correlation keys
  • Validate required fields and normalize severity, status, and timestamps
  • Apply routing, authorization, and policy rules before writes or job execution

Objective

Create or update tickets, CMDB items, reports, or notifications without generating duplicates.

Instructions in Martini

  • Use deterministic idempotency keys
  • Upsert target objects where supported
  • Record source and target identifiers and the result of each operation

Common Datto RMM data objects used in integrations

ObjectTypical UseCommon target systemsMartini handling
AccountsRepresent the MSP or Datto RMM account context used to scope integration data.PSA platforms, reporting stores, service-management platformsMartini uses account identifiers as correlation and tenancy context while retrieving and routing downstream data.
SitesRepresent customer or organizational locations managed within an account.Autotask PSA, ConnectWise Manage, ServiceNow CMDB, reporting platformsMartini maps site identity and ownership fields, preserves source identifiers, and upserts target locations.
DevicesRepresent managed endpoints associated with Sites.CMDBs, PSA platforms, databases, Power BI data storesMartini retrieves Devices page by page, transforms endpoint properties, compares state, and creates or updates target configuration items.
AlertsRepresent monitoring and operational alerts generated for managed Devices.Autotask PSA, ConnectWise Manage, HaloPSA, ServiceNow, Teams, SlackMartini normalizes severity and device context, applies routing rules, and correlates source alert IDs with target tickets or notifications.
JobsRepresent automation, monitoring, or management jobs executed against Devices or Sites.Service desks, audit stores, reporting platformsMartini can retrieve job information or invoke a documented operation after authorization, with audit logging and idempotency controls.
PoliciesRepresent configuration and monitoring policies applied to managed Devices.CMDBs, governance reports, data warehousesMartini compares policy assignments with expected rules and publishes exceptions or governance metrics.

Authentication and security considerations

OAuth-based access

Datto RMM uses OAuth-based API authentication with client credentials, tenant-specific platform endpoints, and bearer access tokens. The applicable region and authorization URLs should come from the tenant environment and current Datto documentation.

Credential protection

  • Store client credentials and tokens in Martini secrets or secured environment configuration.
  • Do not place credentials in payloads, mappings, logs, or source code.
  • Grant API clients only the permissions required by the workflows.
  • Protect exposed Martini APIs with authentication and authorization controls.

Operational considerations for Datto RMM integrations

Volume and rate limits

Use pagination, bounded batches, filtering, and checkpoints for large Device and Alert collections. Handle HTTP 429 and transient 5xx responses with controlled exponential backoff.

Idempotency and reconciliation

Store Datto RMM identifiers alongside target identifiers and treat webhook delivery as potentially duplicated unless the current vendor documentation guarantees otherwise. Use scheduled reconciliation where selected-event notifications do not provide complete coverage.

Operational safety

  • Separate read-only inventory workflows from workflows that execute Jobs or remediation actions.
  • Apply timeouts and define handling for partially completed batches.
  • Monitor schema and endpoint changes and preserve useful unknown fields where appropriate.
  • Test mappings with representative Sites, Devices, Alerts, and Policies before production deployment.

Why use Martini instead of scripts or point-to-point integrations?

Orchestration beyond a script

Martini provides a maintainable workflow layer for authentication, API calls, pagination, transformation, routing, target writes, and error handling. This avoids embedding integration behavior in one-off scripts or duplicating logic across point-to-point connections.

Controlled automation

Reusable workflows can distinguish inventory synchronization from operational remediation, apply authorization and idempotency rules, and expose a controlled API to downstream systems.

Operational visibility

Martini supports structured workflow execution, checkpoints, retries, logging, and reusable mappings so teams can troubleshoot failures and evolve Datto RMM integrations as requirements change.

Frequently asked questions

How can Datto RMM be integrated with enterprise systems?

Datto RMM can be integrated through its REST API, OAuth-based authentication, and webhook-style notifications for selected operational events. Scheduled workflows, pagination, checkpoints, and reconciliation can cover inventory synchronization and events not represented by webhooks.

Can Martini integrate with Datto RMM?

Yes. Martini can consume the Datto RMM REST API, receive selected Datto RMM webhook notifications, orchestrate synchronization and alert workflows, map Datto RMM objects, and expose APIs for controlled downstream or remediation requests.

Do I need a connector to integrate Datto RMM with Martini?

No. A dedicated Datto RMM connector is not required. Martini can use Datto RMM’s native REST API, supported webhook notifications, OAuth authentication, and HTTP-based workflows.

Is there any extra Lonti cost to integrate Datto RMM with Martini?

Lonti does not charge an additional per-connector or per-vendor fee to integrate Datto RMM. The integration is subject to the provisioned capacity of the Martini environment; separate costs may apply from Datto, infrastructure providers, or other third-party systems.

Which Datto RMM integration methods should be used?

REST APIs should be treated as the primary method for Accounts, Sites, Devices, Alerts, Jobs, and Policies. Webhook-style notifications are useful for selected events, while scheduled REST polling and reconciliation should cover incomplete event coverage. GraphQL and SOAP APIs were not confirmed.

Does Datto RMM provide webhooks for every event?

No complete event stream should be assumed. Datto RMM supports webhook-style notifications for selected operational events, but integrations may need scheduled polling and reconciliation for objects or state changes outside that coverage.

How should Datto RMM data be synchronized and transformed?

Martini can retrieve paginated resources, maintain a timestamp or identifier cursor, map objects into canonical models, apply business rules, and upsert target records using source identifiers. Bounded batches and checkpoints help manage large MSP inventories.

How are errors, retries, and duplicate events handled?

A robust workflow validates notifications, handles HTTP 429 and transient 5xx responses with controlled backoff, avoids blind retries for non-idempotent operations, and stores source-to-target correlation keys. Reconciliation workflows can identify missed or duplicated processing.

Related Martini documentation

APIs

Webhooks

Workflows

Security

Operations

Connect Datto RMM with your enterprise systems

Use Martini to build secure, maintainable Datto RMM integrations for alert routing, device synchronization, remediation workflows, and operational reporting.

EXPLORE MARTINI
BOOK A DEMO