Ellipse Gradient for Header

ConnectWise RMM Integration Guide

ConnectWise RMM integrates with enterprise systems through REST APIs and OAuth-based application authentication for monitoring, inventory, alerting, and operational automation.

ConnectWise RMM integration options at a glance

ConnectWise RMM provides a REST API for accessing Companies, Sites, Devices, Alerts, Scripts, Users, and supported operational actions. OAuth 2.0 application authentication is the expected current approach, with tenant permissions and scopes controlling access. A universal webhook model, dedicated bulk API, general attachment API, GraphQL API, and SOAP interface were not confirmed, so scheduled polling, pagination, incremental filters, and bounded concurrency are important for synchronization. Martini can consume the REST API, securely manage credentials, orchestrate scheduled workflows, map RMM data to downstream systems, expose normalized APIs, and apply idempotency, retry, validation, and tenant-isolation rules.

Integration pointSupported by ConnectWise RMM?Common use casesHow Martini supports it
REST APIsYesQuery Companies, Sites, Devices, Alerts, Scripts, and Users, and submit supported operational actions.Martini can consume the ConnectWise RMM REST API from workflows, handle pagination and transformations, and expose reusable API-led integration assets.
AuthenticationYesAuthenticate registered applications using OAuth 2.0, application credentials, tenant context, scopes, and assigned permissions.Martini can keep credentials and environment-specific configuration in secure configuration and use authenticated API-consuming workflows.
Webhooks / outbound callbacksNot confirmedSelected event notifications or callbacks may be available for particular tenants, subscriptions, API versions, or event types, but universal delivery is not confirmed.Martini can receive webhook-style notifications if the tenant exposes them; otherwise it can use scheduled polling and incremental API queries.
Bulk / async / batch APIsNot confirmedA dedicated bulk or asynchronous RMM API was not confirmed. Large synchronizations should use pagination and incremental filters where available.Martini can control request concurrency, partition synchronization windows, persist cursors, and process pages through workflows.
GraphQL APIsNot confirmedOfficial ConnectWise RMM GraphQL support was not confirmed for the reviewed materials.Martini can consume GraphQL when a provider documents it, but this integration should use the confirmed RMM REST API instead.
SOAP APIsNoSOAP support for the current ConnectWise RMM API was not confirmed and should not be assumed for new integrations.Martini supports SOAP generally, but no SOAP-based ConnectWise RMM design should be proposed without provider documentation.
File / attachment APIsNot confirmedA general RMM file, script-upload, or attachment API was not confirmed; such capabilities must be verified as product-specific features.Martini can process files when an endpoint is documented, but should not assume file transfer or attachment support for this API.
Database / analytics accessNoDirect access to the underlying ConnectWise RMM database is not a documented integration approach.Martini can write normalized data to approved downstream databases, while using the supported RMM API as the source.

How ConnectWise RMM exposes data and business events

ConnectWise RMM REST APIs

ConnectWise documents a REST API for RMM resource access and supported operational actions. The API is the primary confirmed integration mechanism for Companies, Sites, Devices, Alerts, Scripts, Users, and related tenant-aware operations.

Martini implementation pattern

Martini implementation pattern: a workflow authenticates with the configured OAuth application, calls the required RMM endpoint, follows pagination or incremental filters, maps the response into a canonical model, and writes the result to a downstream system or exposes it through a Martini API.

Implementation sequence

Authenticate the application with the configured OAuth credentials
Retrieve the required ConnectWise RMM resource page
Follow pagination and apply an incremental synchronization boundary
Preserve Company, Site, Device, and tenant context
Map and transform the response into the target model
Apply validation, routing, and idempotency rules before writing the result

Scheduled synchronization

Universal webhook delivery for ConnectWise RMM events was not confirmed, so scheduled polling and incremental API queries may be required for alert, device, and inventory synchronization.

Martini implementation pattern

Martini implementation pattern: a scheduler starts a workflow, the workflow loads a durable cursor or overlapping time window, retrieves changed resources through the REST API, processes pages with bounded concurrency, and advances the cursor only after successful downstream writes.

Implementation sequence

Start the workflow on a controlled schedule
Load the durable cursor or overlapping synchronization window
Retrieve changed Companies, Sites, Devices, or Alerts
Process pages without overlapping concurrent synchronization windows
Check stable identifiers before creating downstream objects
Persist the new high-water mark after successful processing

Selected event notifications

A general-purpose webhook or callback interface for all ConnectWise RMM events was not confirmed. Tenant- or subscription-specific notifications should be verified for the exact event type and API version before use.

Martini implementation pattern

Martini implementation pattern: if a documented RMM callback is available, Martini receives the notification, validates its source and event identity, retrieves the current resource from the REST API, and applies the same mapping and idempotency logic used by polling workflows.

Implementation sequence

Verify that the required event type is supported for the tenant
Receive and validate the event notification
Retrieve the current resource when the notification is not a complete representation
Correlate the event with its Company, Site, Device, or Alert
Apply idempotency and lifecycle rules
Record processing status and route failures for retry

Common ConnectWise RMM integration patterns

Pattern 1: Route RMM alerts to service tickets

When to use this pattern

Use this pattern when monitoring Alerts must become incidents or service tickets in ConnectWise PSA, ServiceNow, or Jira Service Management. Polling is appropriate when the required event type does not have confirmed webhook coverage.

Integration direction
ConnectWise RMM
Martini
ServiceNow
Example Mapping
ConnectWise RMM FieldCanonical FieldTarget Field
Alert.idsourceAlertIdexternal_reference
Alert.severityseveritypriority
Alert.statuslifecycleStatusstate
Device.iddeviceIdconfiguration_item
Martini implementation pattern

A scheduled Martini workflow retrieves changed Alerts using an overlapping time window, enriches each item with Company, Site, and Device data, maps severity and lifecycle values, checks an idempotency mapping, and creates or updates the target ticket. Retryable API failures use bounded backoff, while permission, validation, and missing-object errors are routed to an operational exception path.

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

Pattern 2: Synchronize device inventory

When to use this pattern

Use this pattern when a reporting, asset, configuration-management, or endpoint-management platform needs an updated view of ConnectWise RMM Devices and their Company and Site relationships.

Integration direction
ConnectWise RMM
Martini
Microsoft Intune
Example Mapping
ConnectWise RMM FieldCanonical FieldTarget Field
Device.iddeviceIdmanagedDeviceId
Device.namedeviceNamedeviceName
Device.operatingSystemoperatingSystemoperatingSystem
Site.idsiteIdgroupId
Martini implementation pattern

Martini retrieves Companies and Sites before paginated Devices, normalizes operating-system and lifecycle values, reconciles stable identifiers, and marks decommissioned or inactive devices according to explicit rules. The workflow stores a synchronization cursor, limits concurrency, and supports controlled full reconciliation for initial loads or recovery.

Martini capabilities used
  • scheduled workflows
  • API consumption
  • pagination
  • data mapping
  • transformations
  • business rules
  • monitoring

Pattern 3: Enrich security alerts and escalate

When to use this pattern

Use this pattern when RMM Alerts need security context from Microsoft Defender or SentinelOne before being routed to a PSA, SIEM, or notification platform. Product-specific API support and identifiers must be verified separately.

Integration direction
Microsoft Defender
Martini
ConnectWise RMM
Example Mapping
ConnectWise RMM FieldCanonical FieldTarget Field
securityFinding.deviceIddeviceIdDevice.id
securityFinding.severitysecuritySeverityAlert.severity
securityFinding.detectionIdexternalDetectionIdAlert.externalReference
Company.idcustomerIdcustomerContext
Martini implementation pattern

Martini correlates security findings with ConnectWise Devices and Company context, applies severity and customer-routing rules, and sends an enriched incident to the selected target. Any RMM remediation call is gated by eligibility or approval rules and records the initiating system, reason, request identifier, outcome, and failure details.

Martini capabilities used
  • API orchestration
  • data mapping
  • correlation
  • business rules
  • approval controls
  • audit logging
  • error handling

Pattern 4: Orchestrate scheduled remediation

When to use this pattern

Use this pattern when qualifying Devices or Alerts should trigger a documented ConnectWise RMM script or operational action. The exact action must be supported by the tenant API and permissions.

Integration direction
Martini
ConnectWise RMM
ConnectWise PSA
Example Mapping
ConnectWise RMM FieldCanonical FieldTarget Field
Device.idtargetDeviceIddeviceId
Alert.idtriggerAlertIdticketReference
eligibility.approvedremediationApprovedactionAuthorization
action.resultremediationOutcometicketStatus
Martini implementation pattern

A scheduler-triggered workflow identifies eligible Devices or Alerts, validates approval and duplicate-execution controls, invokes the documented RMM action, and records the result in an audit or service-management system. The workflow distinguishes temporary failures from rejected or unauthorized actions and avoids retrying disruptive operations without an explicit policy.

Martini capabilities used
  • scheduler triggers
  • workflows
  • API consumption
  • validation
  • business rules
  • idempotency
  • auditability
  • retry handling

Applications commonly integrated with ConnectWise RMM

ConnectWise RMM data can be orchestrated into service management, security, endpoint-management, CRM, and notification platforms. These are typical enterprise architecture patterns; product-specific API permissions and capabilities should be verified independently for each adjacent application.

Application Scenario Direction Martini Pattern
ConnectWise PSA Convert RMM Alerts into service tickets and preserve Company, Site, Device, and technician context across operational workflows. ConnectWise RMM → Martini → ConnectWise PSA Martini polls or retrieves changed Alerts, enriches them with Company, Site, and Device data, applies severity and ownership rules, and creates or updates the corresponding PSA ticket idempotently.
ServiceNow Create incidents, enrich configuration or asset information, and route monitoring events into enterprise IT service-management processes. ConnectWise RMM → Martini → ServiceNow A scheduled Martini workflow retrieves incremental Alerts and Devices, maps them to ServiceNow incident or configuration models, correlates existing records, and retries transient API failures.
Jira Service Management Route RMM alerts to IT operations or development teams using Jira workflows and escalation rules. ConnectWise RMM → Martini → Jira Service Management Martini normalizes Alert severity, customer context, and lifecycle state before creating or updating Jira issues using the ConnectWise Alert identifier as the idempotency key.
Salesforce Associate managed-service events, Companies, and customer asset context with account and service processes. ConnectWise RMM → Martini → Salesforce Martini maps ConnectWise Companies and Devices to Salesforce accounts and assets, applies customer ownership rules, and sends selected Alerts to service processes without assuming a native RMM relationship.
Microsoft Intune Compare or reconcile endpoint inventory and management status across RMM and Microsoft endpoint-management environments. ConnectWise RMM → Martini → Microsoft Intune Martini retrieves paginated Devices, normalizes identifiers and lifecycle states, compares them with Intune data, and applies explicit ownership rules before updating either system.
Microsoft Defender Correlate endpoint security findings with RMM Devices and customer Sites for escalation or controlled remediation. Microsoft Defender → Martini → ConnectWise RMM Martini matches Defender findings to ConnectWise Devices, enriches Alerts with security context, applies approval and eligibility rules, and invokes only documented RMM actions supported by the tenant.
SentinelOne Enrich RMM alerts with endpoint detection information and coordinate remediation or escalation workflows. SentinelOne → Martini → ConnectWise RMM Martini correlates SentinelOne endpoint identifiers with ConnectWise Devices, applies severity and customer-routing rules, and records any supported remediation request and outcome for auditability.
Slack Notify operations teams about high-priority Alerts, remediation failures, and synchronization exceptions. ConnectWise RMM → Martini → Slack Martini polls or processes selected RMM Alerts, applies notification thresholds and deduplication, formats a concise operational message, and sends failures to a monitored exception path.

How to build a ConnectWise RMM integration in Martini

Objective

Establish the ConnectWise RMM application relationship and protect tenant-specific credentials and configuration.

Instructions in Martini

  • Register or obtain the required ConnectWise application credentials
  • Confirm OAuth scopes, tenant authorization, and service-account permissions
  • Store credentials and environment values in secure Martini configuration
  • Preserve partner, Company, Site, and tenant context in the integration model

Objective

Select a trigger based on confirmed RMM capabilities and the required freshness of the integration.

Instructions in Martini

  • Use a scheduled workflow when webhook coverage is not confirmed
  • Verify selected event notifications before relying on callbacks
  • Define synchronization frequency and prevent overlapping runs
  • Choose incremental filters or high-water marks where available

Objective

Call the RMM REST API and obtain the resources required for the business process.

Instructions in Martini

  • Retrieve Companies and Sites before dependent Devices or Alerts when context is needed
  • Use paginated requests and bounded concurrency
  • Load an overlapping time window to reduce missed updates
  • Capture request and synchronization metadata for troubleshooting

Objective

Coordinate retrieval, enrichment, routing, and downstream writes in a maintainable Martini workflow.

Instructions in Martini

  • Separate resource retrieval from transformation and target delivery
  • Enrich Alerts with Company, Site, and Device context
  • Apply conditional routing for severity, customer, and ownership
  • Persist cursors and correlation identifiers outside transient execution state

Objective

Convert ConnectWise RMM objects into stable canonical and target-specific models.

Instructions in Martini

  • Map stable identifiers before display names
  • Normalize severity, lifecycle, operating-system, and site-assignment values
  • Preserve unknown fields where practical for forward compatibility
  • Validate required fields before sending data downstream

Objective

Prevent incorrect routing, duplicate creation, cross-tenant leakage, and unauthorized remediation.

Instructions in Martini

  • Use stable object identifiers as idempotency keys
  • Retain Company and Site context throughout processing
  • Require eligibility or approval before disruptive actions
  • Distinguish alert creation, update, resolution, and reopening

Common ConnectWise RMM data objects used in integrations

ObjectTypical UseCommon target systemsMartini handling
CompaniesRepresent customer organizations managed by the MSP and provide the top-level customer context for inventory and alert processing.ConnectWise PSA, ServiceNow, Salesforce, reporting platformsMartini retrieves Companies, preserves stable identifiers and tenant context, and maps them to customer or account models.
SitesRepresent locations or logical customer sites associated with Companies.ConnectWise PSA, ServiceNow, Microsoft Intune, reporting platformsMartini synchronizes Site relationships after Companies, validates parent identifiers, and retains site assignment history where required.
DevicesRepresent monitored endpoints managed by ConnectWise RMM for inventory, status, security correlation, and remediation.ServiceNow, Microsoft Intune, Microsoft Defender, SentinelOne, asset platformsMartini processes Devices with pagination and incremental synchronization, normalizes operating-system and lifecycle fields, and correlates Company and Site context.
AlertsRepresent monitoring or management events requiring investigation, notification, ticketing, or remediation.ConnectWise PSA, ServiceNow, Jira Service Management, Slack, security platformsMartini uses Alert identifiers for idempotency, tracks lifecycle changes, enriches alerts with Device and customer context, and separates transient from persistent failures.
ScriptsRepresent automation or remediation scripts associated with managed Devices or operational workflows.Operational audit stores, ConnectWise PSA, security platformsMartini invokes only documented script or remediation actions, applies eligibility or approval rules, and records request identifiers, results, and failure reasons.
UsersRepresent users or technicians involved in permissions, routing, ownership, and operational responsibility.ConnectWise PSA, ServiceNow, identity or reporting systemsMartini can synchronize required user attributes and map technician ownership only when the relevant API permissions and fields are available.

Authentication and security considerations

OAuth and application permissions

ConnectWise RMM integrations should use the OAuth-based application authentication documented for the RMM API. Application registration, client credentials, scopes, tenant authorization, and service-account permissions must be confirmed for the relevant environment.

Tenant-aware access

MSP environments require careful preservation of partner, Company, Site, and Device relationships. Martini workflows should prevent data from one customer organization from being routed to another customer's systems.

Secrets and operational actions

  • Keep OAuth credentials and tenant configuration in secure environment configuration.
  • Use least-privilege scopes and permissions.
  • Validate eligibility and approval before invoking scripts or disruptive remediation actions.
  • Record the initiating system, reason, request identifier, result, and failure details for operational actions.

Operational considerations for ConnectWise RMM integrations

Pagination and rate limits

Assume list endpoints require pagination unless the endpoint documentation states otherwise. Use bounded concurrency, request limits confirmed for the tenant, and exponential backoff for transient failures.

Synchronization and idempotency

Store a durable cursor or high-water mark outside the workflow execution context. Use overlapping windows where appropriate, prevent overlapping scheduled runs, and use stable Company, Site, Device, Alert, and action identifiers to avoid duplicates.

Alert lifecycle and schema changes

Alerts may be created, updated, acknowledged, resolved, or reopened. Downstream systems should preserve lifecycle state rather than creating a new incident for every poll result. Treat response fields as versioned contracts, preserve unknown fields where practical, and test changes to severity, operating-system, and site-assignment fields.

Error handling and testing

  • Separate authentication, permission, validation, rate-limit, temporary service, and missing-object failures.
  • Retry only transient failures and route persistent errors to an operational queue or monitoring process.
  • Test initial loads, incremental synchronization, deleted objects, duplicate alerts, and tenant isolation.

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

Orchestrated integration logic

Martini centralizes REST API calls, scheduled synchronization, enrichment, mapping, business rules, and downstream delivery in maintainable workflows rather than scattering logic across scripts.

Reusable and controlled APIs

Martini can expose normalized APIs for internal consumers while encapsulating ConnectWise RMM OAuth handling, pagination, tenant context, and provider-specific response structures.

Reliability and operations

Durable cursors, idempotency, bounded concurrency, retry handling, validation, monitoring, and explicit remediation controls provide a stronger operational model than unmanaged point-to-point scripts.

Frequently asked questions

How can ConnectWise RMM be integrated with enterprise systems?

ConnectWise RMM can be integrated through its REST API using OAuth-based application authentication. Enterprise workflows can retrieve Companies, Sites, Devices, Alerts, Scripts, and Users, synchronize changes through pagination and incremental queries, and submit supported operational actions. Because universal webhook, bulk, GraphQL, SOAP, and direct database capabilities were not confirmed, scheduled API synchronization is an important design option.

Can Martini integrate with ConnectWise RMM?

Yes. Martini can integrate with ConnectWise RMM by consuming its documented REST API through workflows and APIs, securely managing OAuth configuration, mapping RMM objects, scheduling incremental synchronization, and applying validation, idempotency, retry, and tenant-isolation rules.

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

No. A dedicated ConnectWise RMM connector is not required. Martini can use ConnectWise RMM's confirmed native REST API and OAuth authentication mechanisms, with scheduled polling where webhook coverage is unavailable or not confirmed.

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

Lonti does not charge an additional per-connector or per-vendor fee to integrate ConnectWise RMM. The integration is subject to the provisioned capacity of the Martini environment. Separate costs may apply from ConnectWise, cloud infrastructure, or other third-party systems depending on subscription, usage, and deployment model.

Which ConnectWise RMM integration methods should be used?

The confirmed primary method is the ConnectWise RMM REST API with OAuth-based application authentication. Scheduled synchronization with pagination and incremental filters is appropriate when event delivery is unavailable. GraphQL and SOAP were not confirmed for the current RMM API, and direct database access should not be used.

Can Martini receive ConnectWise RMM webhooks or event callbacks?

A universal ConnectWise RMM webhook capability was not confirmed. Selected event notifications or callbacks may exist for particular tenants, subscriptions, API versions, or event types, but they must be verified before use. Martini can receive a documented callback; otherwise a scheduled polling workflow can provide incremental synchronization.

How should ConnectWise RMM data synchronization and duplicate handling work?

Use Companies and Sites to establish customer context before synchronizing Devices and Alerts. Store a durable cursor, high-water mark, or overlapping time window, and process paginated results. Stable ConnectWise identifiers should be used as idempotency keys, with a mapping to downstream tickets or assets so updates, resolutions, and reopenings are not treated as new objects.

Can Martini expose an API façade for ConnectWise RMM?

Yes. Martini can expose a controlled REST API that presents a normalized model for ConnectWise RMM data or invokes approved workflows. This can shield internal consumers from provider-specific authentication, pagination, tenant context, field mappings, and error-handling details while keeping operational actions subject to permission and approval rules.

Related Martini documentation

APIs

Workflows

Data

Security

Operations

Connect ConnectWise RMM to your enterprise systems

Use Martini to build reliable ConnectWise RMM integrations with REST APIs, scheduled workflows, secure authentication, data mapping, and operational controls.

EXPLORE MARTINI
BOOK A DEMO