Ellipse Gradient for Header

Corrigo Integration Guide

Connect Corrigo facilities operations data with enterprise systems through REST APIs, tenant-configured callbacks, scheduled workflows, and secure data synchronization.

Corrigo integration options at a glance

Corrigo provides an official developer portal and REST APIs as the primary mechanism for accessing Work Orders, Properties, Locations, Assets, Service Providers, and financial information, subject to tenant permissions. Some Corrigo environments may support webhook-style event notifications, but coverage must be confirmed for the required resources. Large exchanges should use paginated, incremental polling with checkpoints rather than assuming a bulk API. Authentication is tenant-specific and is expected to use OAuth 2.0-style authorization. Martini can securely consume Corrigo APIs, receive supported callbacks, schedule reconciliation workflows, map and validate data, and route results to property, service-management, ERP, procurement, or reporting applications.

Integration pointSupported by Corrigo?Common use casesHow Martini supports it
REST APIsYesRead and create Work Orders; update status, scheduling, assignment, and completion details; synchronize Properties, Locations, Assets, Service Providers, and invoice information.Martini can consume Corrigo REST endpoints, paginate collection responses, transform payloads, apply validation and business rules, and call downstream APIs.
Webhooks / outbound callbacksLimitedSelected Corrigo tenants or API products may provide event notifications for operational resources such as Work Orders. Coverage must be confirmed for each required event.Martini can expose an API or receive a webhook workflow, validate notifications, apply idempotency checks, retrieve the current resource, and route the event.
Bulk / async / batch APIsNot confirmedNo generally available public Corrigo bulk or asynchronous API was verified. Large exchanges should use incremental, paginated synchronization.Martini can orchestrate scheduled batches, checkpoints, overlap windows, throttling, and retry policies without assuming a Corrigo bulk endpoint.
File / attachment APIsLimitedWork Orders and invoices may contain documents, but general attachment upload, download, and metadata endpoints were not publicly verified.Martini can process confirmed attachment endpoints or URLs when available, while separating file handling from ordinary transactional payloads.
AuthenticationYesCorrigo API access is tenant- and program-dependent, with OAuth 2.0-style client authorization expected for modern access. Scopes, grant type, token URLs, and permissions require confirmation.Martini can store client credentials, secrets, tokens, and environment URLs securely and apply configured authentication to Corrigo API requests.
Database / analytics accessNot confirmedDirect customer database access was not verified. Approved exports or reporting arrangements may exist but should not be treated as transactional database integration.Martini should consume supported Corrigo APIs or approved exports rather than connecting directly to Corrigo databases.

How Corrigo exposes data and business events

Corrigo REST APIs

Corrigo provides an official developer/API portal, and REST is the primary mechanism for programmatic access where the required resources and tenant permissions are enabled. REST use cases include Work Orders, Properties, Locations, Assets, Service Providers, and invoice information.

Martini implementation pattern

Martini implementation pattern: a workflow authenticates to Corrigo, retrieves or writes the required resources, maps the response to a canonical model, applies tenant-specific business rules, and calls downstream APIs. Scheduled incremental retrieval is the default where event coverage is unavailable.

Implementation sequence

Authenticate with the tenant-provisioned Corrigo credentials
Retrieve a paginated or filtered Corrigo collection
Normalize the resource into the integration model
Apply validation, state, and ownership rules
Write the mapped result to the target system
Store the checkpoint and processing outcome

Corrigo webhook-style callbacks

Some Corrigo API products or tenant configurations may support event notifications for selected resources. Coverage for Work Orders, Properties, Assets, or Invoices must be confirmed rather than assumed.

Martini implementation pattern

Martini implementation pattern: expose a controlled Martini API or webhook workflow, validate the callback, deduplicate the notification, and retrieve the current Corrigo resource when the event contains only an identifier or incomplete data. Scheduled reconciliation should supplement callbacks.

Implementation sequence

Receive the Corrigo callback notification
Authenticate and validate the callback payload
Check the event or resource against the idempotency store
Retrieve the current Corrigo resource when required
Map and route the event to downstream systems
Record the outcome and retry transient delivery failures

Corrigo scheduled synchronization

When callbacks are unavailable or incomplete, Corrigo collections can be synchronized through scheduled polling using pagination, update timestamps, time windows, or other filters supported by the tenant's API.

Martini implementation pattern

Martini implementation pattern: a scheduler starts a workflow that reads the last successful checkpoint, applies an overlap window, pages through changed resources, and persists progress only after successful target processing.

Implementation sequence

Start the scheduled synchronization workflow
Load the tenant and resource checkpoint
Request changed resources using supported filters
Process each page with bounded concurrency
Persist cross-references and the new checkpoint
Run reconciliation and route persistent failures

Common Corrigo integration patterns

Pattern 1: Synchronize Work Orders with a service-management platform

When to use this pattern

Use this pattern when Corrigo is the operational system for maintenance execution and another platform needs a synchronized ticket or work-item view. It supports incremental retrieval, bidirectional status updates where permissions allow, and durable cross-references.

Integration direction
Corrigo
Martini
ServiceNow
Example Mapping
Corrigo FieldCanonical FieldTarget Field
WorkOrderIdexternalWorkOrderIdcorrelation_id
StatusworkStatusstate
PropertyIdpropertyReferencelocation
ServiceProviderIdassignedProviderassignment_group
Martini implementation pattern

A scheduled Martini workflow retrieves Work Orders changed since the checkpoint, matches each record by Corrigo Work Order ID, and creates or updates the target ticket. It validates allowed state transitions, records the cross-reference, sends selected target changes back to Corrigo, and retries transient failures while routing validation conflicts for review.

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

Pattern 2: Synchronize Corrigo master data

When to use this pattern

Use this pattern when property, location, asset, or provider data must be shared with a property, ERP, procurement, or reporting application. Define a system of record for each object before enabling bidirectional updates.

Integration direction
Corrigo
Martini
SAP S/4HANA
Example Mapping
Corrigo FieldCanonical FieldTarget Field
PropertyIdpropertyExternalIdExternalPropertyID
LocationNameoperationalLocationNameLocationDescription
AssetIdassetExternalIdEquipmentID
ServiceProviderIdproviderExternalIdSupplierID
Martini implementation pattern

Martini pages through Corrigo master-data resources, maps hierarchy and identifiers into the target model, validates required references, and writes only approved changes. A durable checkpoint and reconciliation report identify missing, changed, or conflicting objects without relying on direct database access.

Martini capabilities used
  • REST API consumption
  • workflow orchestration
  • mapping and transformation
  • validation
  • checkpointing
  • monitoring

Pattern 3: Send approved Work Orders and invoices to an ERP

When to use this pattern

Use this pattern when completed or approved Corrigo work must enter financial and procurement processes. It is appropriate for transferring costs, Service Providers, purchase-order references, and invoice information while preventing duplicate posting.

Integration direction
Corrigo
Martini
Oracle NetSuite
Example Mapping
Corrigo FieldCanonical FieldTarget Field
InvoiceIdinvoiceExternalIdexternalid
WorkOrderIdsourceWorkOrderIdcustbody_corrigo_work_order
ServiceProviderIdsupplierExternalIdvendor
TotalAmountapprovedAmounttotal
Martini implementation pattern

The workflow retrieves eligible completed or approved Work Orders and Invoices, validates Property, Service Provider, cost-center, and purchase-order references, transforms the payload to the ERP model, and submits it using a stable external identifier. ERP rejection responses are recorded and routed for correction rather than endlessly retried.

Martini capabilities used
  • scheduled workflows
  • REST API consumption
  • data transformation
  • validation
  • business rules
  • retry and error routing

Pattern 4: Process event-driven maintenance notifications

When to use this pattern

Use this pattern when the Corrigo tenant provides callbacks for the Work Order events required by the business. It provides faster downstream notification while scheduled reconciliation protects against missed, delayed, or out-of-order events.

Integration direction
Corrigo
Martini
Salesforce
Example Mapping
Corrigo FieldCanonical FieldTarget Field
EventTypemaintenanceEventTypeevent_type
WorkOrderIdexternalWorkOrderIdCorrigo_Work_Order__c
StatusworkStatusStatus__c
PropertyIdpropertyReferenceProperty__c
Martini implementation pattern

Martini receives and validates the callback, checks the event identifier or resource key for duplicates, retrieves the current Work Order when necessary, and routes the normalized event to Salesforce. It applies state-transition rules, retries temporary failures, and runs scheduled reconciliation for events that were not delivered.

Martini capabilities used
  • API exposure
  • webhook consumption
  • idempotency
  • data mapping
  • conditional routing
  • error handling

Applications commonly integrated with Corrigo

Corrigo can be integrated with adjacent property, service-management, customer, ERP, procurement, and finance applications. The exact interface, object coverage, and direction depend on the Corrigo tenant and the other product's APIs; Martini can orchestrate the relationship without requiring a dedicated Corrigo connector.

Application Scenario Direction Martini Pattern
Yardi Voyager Synchronize property context, units, service requests, Work Orders, vendors, and financial information between property management and facilities operations. Yardi Voyager → Martini → Corrigo Use REST workflows to exchange property and operational data, maintain Corrigo-to-Yardi cross-references, apply system-of-record rules, and reconcile changes on a schedule.
MRI Software Coordinate property data, maintenance requests, Service Providers, Work Orders, and invoice processing. MRI Software → Martini → Corrigo Consume each platform's APIs, normalize Properties, Locations, Work Orders, and invoice data, validate identifiers, and route rejected transactions for operational review.
RealPage Exchange property, resident or occupant service-request context, maintenance Work Orders, and completion status. RealPage → Martini → Corrigo Use scheduled or event-assisted workflows to correlate service requests with Corrigo Work Orders, map status transitions, and prevent duplicate creation through durable external keys.
ServiceNow Synchronize facilities cases or facilities tickets with Corrigo Work Orders and status updates. ServiceNow → Martini → Corrigo Expose or consume REST endpoints on both sides, map ServiceNow cases to Work Orders, apply status and assignment rules, and retry transient downstream failures.
Salesforce Expose maintenance and service activity to account, customer, property, or field-service teams. Corrigo → Martini → Salesforce Poll or receive eligible Corrigo changes, enrich them with property and Service Provider context, map them to Salesforce objects, and return selected updates when Corrigo permissions allow.
SAP S/4HANA Transfer approved maintenance costs, vendors, purchase-order references, and invoice information into finance and procurement processes. Corrigo → Martini → SAP S/4HANA Process only approved or completed Work Orders, validate financial references, transform invoices and costs to SAP's API model, and retain rejection details for reprocessing.
Oracle NetSuite Synchronize Service Providers, purchase orders, invoices, and cost information. Corrigo → Martini → Oracle NetSuite Use incremental Corrigo retrieval, stable invoice identifiers, validation rules, and target-side response handling to avoid duplicate financial posting.
Microsoft Dynamics 365 Connect property or customer service operations with Corrigo Work Orders and Service Provider execution data. Microsoft Dynamics 365 → Martini → Corrigo Coordinate APIs through reusable workflows, map Work Order and customer context, enforce allowed state transitions, and reconcile records when notifications are incomplete.

How to build a Corrigo integration in Martini

Objective

Establish tenant-specific Corrigo access and protect credentials throughout the integration lifecycle.

Instructions in Martini

  • Confirm the Corrigo API product, tenant, scopes, token endpoint, grant type, and permissions.
  • Store client secrets, access tokens, refresh details, and environment URLs in Martini secrets or secure configuration.
  • Test access to only the Corrigo resources required by the workflow.

Objective

Select event-driven or scheduled execution based on the Corrigo tenant's confirmed capabilities.

Instructions in Martini

  • Use a Corrigo callback only after event coverage is confirmed for the required resource.
  • Use a scheduler for incremental polling when callbacks are unavailable or incomplete.
  • Define an overlap window and checkpoint strategy for scheduled retrieval.

Objective

Read Corrigo resources reliably while respecting pagination, filtering, and tenant-specific behavior.

Instructions in Martini

  • Retrieve Work Orders, Properties, Locations, Assets, Service Providers, or Invoices through confirmed REST endpoints.
  • Follow pagination and supported updated-since, cursor, status, or time-window filters.
  • Limit concurrency and handle rate-limit responses with backoff.

Objective

Coordinate retrieval, enrichment, validation, target writes, checkpointing, and failure routing in a maintainable Martini workflow.

Instructions in Martini

  • Separate authentication, retrieval, transformation, target delivery, and reconciliation stages.
  • Use reusable workflow logic for cross-references, idempotency, and common error handling.
  • Persist progress only after the relevant target operation succeeds.

Objective

Translate Corrigo's tenant-specific object model into a canonical model and target application structure.

Instructions in Martini

  • Map actual Corrigo objects such as Work Orders, Properties, Locations, Assets, Service Providers, and Invoices.
  • Normalize timestamps while retaining property-local time-zone context.
  • Keep custom fields, statuses, identifiers, and hierarchy mappings configurable.

Objective

Prevent invalid operational or financial changes before they reach Corrigo or downstream systems.

Instructions in Martini

  • Validate required references, approval states, allowed status transitions, and duplicate keys.
  • Define the system of record for each master-data object.
  • Route business-state conflicts and validation failures for review instead of repeated retry.

Common Corrigo data objects used in integrations

ObjectTypical UseCommon target systemsMartini handling
Work OrdersRepresent maintenance or service requests through creation, assignment, scheduling, dispatch, completion, and closure.ServiceNow, Salesforce, Yardi Voyager, MRI Software, RealPage, Microsoft Dynamics 365Martini retrieves changed Work Orders, correlates them with target records, maps status and assignment fields, applies state rules, and writes updates idempotently.
PropertiesIdentify buildings, sites, or managed locations where work is performed.Yardi Voyager, MRI Software, RealPage, SAP S/4HANA, reporting platformsMartini synchronizes property identifiers and attributes, preserves system-of-record ownership, and validates references before processing Work Orders.
LocationsDescribe operational areas, units, rooms, or more specific sites associated with a Property.Yardi Voyager, RealPage, ServiceNow, reporting platformsMartini maps the Property-to-Location hierarchy and retains tenant-specific identifiers and time-zone information.
Service ProvidersRepresent contractors, vendors, or technicians responsible for fulfilling Work Orders.SAP S/4HANA, Oracle NetSuite, Yardi Voyager, MRI SoftwareMartini normalizes provider identifiers and status, validates vendor references, and prevents duplicate vendor creation in target systems.
AssetsIdentify maintainable equipment or facility assets associated with Properties or Locations.ServiceNow, SAP S/4HANA, Microsoft Dynamics 365, reporting platformsMartini maps asset identity and location relationships, enriches Work Orders with asset context, and reconciles updates incrementally.
InvoicesRepresent financial documents associated with completed work, Service Providers, or Work Orders.SAP S/4HANA, Oracle NetSuite, Yardi Voyager, MRI SoftwareMartini validates approval state, cost-center and purchase-order references, uses stable identifiers for idempotency, and routes rejected invoices for review.

Authentication and security considerations

Tenant-specific authorization

Corrigo API access varies by tenant, program, product edition, and role. Confirm the grant type, scopes, token endpoint, refresh behavior, resource permissions, and environment URLs with the Corrigo implementation team.

Secure configuration

Store Corrigo client credentials, secrets, access tokens, and environment-specific settings in Martini secrets or secure environment configuration rather than embedding them in workflows.

  • Limit access to required Corrigo resources and operations.
  • Use separate credentials and configuration for development, testing, and production.
  • Protect any Martini API used to receive Corrigo callbacks with appropriate authentication and authorization.

Operational considerations for Corrigo integrations

Reliability and scale

Use pagination, incremental filters, checkpoints, and overlap windows for collection synchronization. Confirm tenant-specific rate limits, honor Retry-After when supplied, limit concurrency, and use exponential backoff for temporary failures.

Data integrity

Use durable Corrigo identifiers and cross-references to prevent duplicate Work Orders or Invoices. Treat callback events as potentially duplicated, delayed, or out of order, and retrieve the current resource when the notification is incomplete.

Tenant variation

Fields, statuses, required values, custom fields, object availability, hierarchies, and financial approval states can vary. Keep mappings and business rules configurable and test against representative tenant data.

Attachments and time zones

Confirm attachment endpoints, file limits, content types, download authentication, and retention before designing document flows. Preserve Corrigo timestamps and property-local time zones for facilities scheduling and dispatch logic.

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

Beyond point-to-point scripts

Martini separates Corrigo connectivity from orchestration, mapping, validation, business rules, and downstream delivery. This makes Work Order, master-data, invoice, and callback flows easier to maintain as tenant requirements change.

  • Consume Corrigo REST APIs and expose controlled Martini APIs without requiring a dedicated connector.
  • Combine callbacks with scheduled reconciliation, checkpoints, idempotency, and retry handling.
  • Reuse transformations and validation across property, service-management, ERP, and procurement integrations.
  • Keep credentials and environment differences outside workflow logic through secure configuration.
  • Centralize operational logging, error routing, and monitoring instead of duplicating these concerns across scripts.

Frequently asked questions

How can Corrigo be integrated with enterprise systems?

Corrigo can be integrated primarily through its tenant-configured REST APIs for Work Orders, Properties, Locations, Assets, Service Providers, and financial information. Some environments may support selected webhook-style callbacks, while scheduled incremental polling is the safer general pattern when event coverage is unavailable. Authentication, resources, scopes, and permissions must be confirmed for the specific Corrigo tenant.

Can Martini integrate with Corrigo?

Yes. Martini can consume Corrigo REST APIs, run scheduled synchronization workflows, receive supported Corrigo callbacks, map and validate Corrigo objects, and deliver results to enterprise applications. The Corrigo tenant must provide the required endpoints and permissions.

Do I need a connector to integrate Corrigo with Martini?

No. A dedicated Corrigo connector is not required. Martini can use Corrigo's confirmed native REST APIs, tenant-supported callbacks, and authentication mechanisms, then orchestrate the surrounding workflow and downstream integrations.

Is there any extra Lonti cost to integrate Corrigo with Martini?

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

Which Corrigo integration methods should new implementations use?

REST APIs should be the primary approach because Corrigo provides an official developer/API portal for programmatic access. Use tenant-confirmed webhook-style callbacks only for supported events, and use scheduled, paginated, incremental synchronization for reconciliation or when notifications are unavailable. GraphQL and current SOAP support were not verified.

Can Corrigo send events or webhooks to Martini?

Possibly, depending on the Corrigo API product and tenant configuration. Event coverage should be confirmed for the specific Work Order or operational events required. Martini can receive and validate supported callbacks, but scheduled reconciliation should supplement them because notifications may be limited, duplicated, delayed, or out of order.

How does Martini synchronize and transform Corrigo data?

Martini retrieves or receives Corrigo objects, maps them into a canonical or target model, applies validation and business rules, and writes them through the destination application's API. Work Orders should use durable Corrigo identifiers and cross-references, while pagination, checkpoints, overlap windows, and idempotency support reliable incremental synchronization.

How are Corrigo errors, retries, and duplicates handled?

Martini can classify authentication, validation, rate-limit, network, missing-object, business-state, and downstream failures. Transient failures can be retried with backoff, while persistent errors can be routed for review. Durable Work Order or Invoice identifiers, event keys, and cross-reference records help prevent duplicate processing. Martini can also expose an API façade for upstream systems when a controlled integration endpoint is needed.

Related Martini documentation

Corrigo APIs

Triggers

Workflows

Security

Operations

Connect Corrigo with your enterprise systems

Use Martini to orchestrate Corrigo REST APIs, tenant-supported callbacks, scheduled synchronization, data mapping, and secure workflows across facilities, property, service-management, ERP, and procurement applications.

EXPLORE MARTINI
BOOK A DEMO