.png)
UpKeep Integration Guide
Integrate UpKeep maintenance data with enterprise systems through its REST API, API-key authentication, scheduled workflows, and selected webhook-style notifications.
UpKeep integration options at a glance
UpKeep’s primary integration mechanism is its REST API, which can be used to read, create, update, and synchronize Work Orders, Requests, Assets, Locations, Parts, and Users, subject to account permissions and endpoint coverage. API-key authentication is the documented access pattern. Webhook-style notifications may be available for selected events, but coverage should be confirmed before designing real-time processing. For larger data sets, Martini can use paginated REST requests, incremental filters where supported, scheduled workflows, checkpoints, throttling, and retries. Attachment availability also requires object-level verification. Martini can consume the API, expose a standardized API, map data, and orchestrate downstream writes.
| Integration point | Supported by UpKeep? | Common use cases | How Martini supports it |
|---|---|---|---|
| REST APIs | Yes | Retrieve, create, update, and synchronize Work Orders, Requests, Assets, Locations, Parts, and Users, subject to endpoint and permission coverage. | Martini can consume the UpKeep REST API from workflows, transform responses, apply business rules, and expose a controlled API façade for selected operations. |
| Webhooks / outbound callbacks | Limited | Receive notifications for selected UpKeep events if the account and event types support webhook-style delivery. | Martini can expose a receiving API or workflow trigger, validate requests, deduplicate events, and route them to downstream systems. Coverage must be confirmed for each object and event. |
| Authentication | Yes | Authenticate public API requests with an UpKeep API key supplied in an HTTP request header. | Martini can store the key as a secret and inject it into REST requests, using separate environment credentials and protecting it from mappings and logs. |
| File / attachment APIs | Limited | Synchronize maintenance photographs or documents when the relevant UpKeep object and attachment endpoint are supported. | Martini can orchestrate metadata or binary retrieval and downstream delivery after endpoint coverage, file limits, access behavior, and URL lifetime are confirmed. |
| Scheduled synchronization | Yes | Poll paginated REST collections for updated Work Orders, Requests, Assets, Locations, Parts, or Users when event coverage is unavailable or incomplete. | Martini scheduler-triggered workflows can maintain checkpoints, overlap windows, throttling, retries, and incremental synchronization. |
| Pagination and incremental retrieval | Yes | Process large collections page by page and use updated timestamps or date filters where supported. | Martini can preserve pagination state, apply overlap windows, deduplicate by UpKeep identifiers, and resume interrupted jobs. |
| Bulk / asynchronous APIs | Not confirmed | No confirmed public bulk or asynchronous UpKeep API was identified; large loads should use paginated REST requests. | Martini can implement controlled batch-style workflows over the REST API without assuming a vendor bulk endpoint. |
| Database / analytics access | No | No public direct customer database access was confirmed for UpKeep. | Martini should use the UpKeep API or a vendor-supported reporting or export mechanism rather than direct database connectivity. |
How UpKeep exposes data and business events
UpKeep REST APIs
UpKeep’s documented primary integration mechanism is a REST API for accessing maintenance-management data and operations. Endpoint coverage, permissions, filtering, and available fields should be confirmed for the target UpKeep account.
Martini implementation pattern
Martini implementation pattern: a workflow authenticates with an UpKeep API key, calls the required resource, handles pagination and response validation, maps the result to a canonical model, and writes it to one or more target systems. The workflow can also expose a controlled Martini API that abstracts selected UpKeep operations.
Implementation sequence
UpKeep webhook-style notifications
UpKeep may provide webhook-style notifications for selected events or account capabilities, but complete coverage for Work Orders, Requests, Assets, and Parts should not be assumed.
Martini implementation pattern
Martini implementation pattern: expose a receiving API or workflow trigger, validate the notification, apply idempotency checks, retrieve the current UpKeep resource when necessary, and route a normalized event to downstream systems. Scheduled polling remains the fallback for unsupported events.
Implementation sequence
UpKeep scheduled synchronization
Scheduled REST polling is appropriate when webhook coverage is unavailable or when enterprise systems require controlled periodic synchronization. Pagination, incremental filters where supported, checkpoints, and throttling are important for large collections.
Martini implementation pattern
Martini implementation pattern: a scheduler starts a workflow that reads the last successful checkpoint, requests changed pages with a small overlap window, deduplicates by UpKeep object ID, writes downstream updates, and advances the checkpoint only after successful processing.
Implementation sequence
Common UpKeep integration patterns
Pattern 1: Sync Work Orders to an ERP
When to use this pattern
Use this pattern when UpKeep is the operational maintenance system and an ERP or finance platform needs completed or updated maintenance transactions. The workflow can combine labor, Parts, asset, location, and cost information while validating required accounting fields before posting.
Integration direction
Example Mapping
| UpKeep Field | Canonical Field | Target Field |
|---|---|---|
| Work Order ID | sourceMaintenanceId | externalId |
| Status | maintenanceStatus | transactionStatus |
| Asset ID | assetReference | assetId |
| Parts and labor cost | maintenanceCost | costLines |
Martini implementation pattern
A scheduled Martini workflow retrieves changed Work Orders using pagination and supported incremental filters, enriches them with related Parts and asset data, maps status and cost values, validates ERP-required dimensions, and performs an idempotent write. Transient API failures are retried with backoff, while validation failures are logged and routed for correction.
Martini capabilities used
- scheduled workflows
- REST API consumption
- pagination and checkpointing
- data mapping
- business rules
- error handling and retry
Pattern 2: Synchronize Assets and Locations to ServiceNow
When to use this pattern
Use this pattern when UpKeep manages operational maintenance but ServiceNow provides a broader enterprise service-management or asset-governance view. It is useful for normalizing location hierarchies, asset identifiers, ownership, and status values.
Integration direction
Example Mapping
| UpKeep Field | Canonical Field | Target Field |
|---|---|---|
| Asset ID | assetId | asset_tag |
| Asset status | assetStatus | install_status |
| Location ID | locationId | location |
| Location name | locationName | name |
Martini implementation pattern
Martini polls changed Assets and Locations, resolves parent-child relationships, converts UpKeep status values to ServiceNow values, and upserts records using stable source identifiers. Missing parent locations, invalid statuses, and API conflicts are handled through validation and retry branches rather than silently discarded.
Martini capabilities used
- scheduled workflows
- REST API consumption
- hierarchical data mapping
- validation
- business rules
- idempotent upserts
Pattern 3: Route maintenance Requests to Jira
When to use this pattern
Use this pattern when maintenance findings require engineering or product investigation in Jira. Business rules can select high-priority or failure-related Requests, enrich them with Asset and Location context, and maintain a cross-system reference.
Integration direction
Example Mapping
| UpKeep Field | Canonical Field | Target Field |
|---|---|---|
| Request ID | requestId | externalReference |
| Description | issueSummary | summary |
| Priority | priority | priority |
| Asset and Location | maintenanceContext | description |
Martini implementation pattern
A Martini workflow uses scheduled polling or a confirmed UpKeep notification to identify qualifying Requests, maps the maintenance context into a Jira issue, stores the Jira identifier against the UpKeep source ID, and processes subsequent status changes as updates. Duplicate checks prevent repeated issue creation.
Martini capabilities used
- workflow triggers
- REST API consumption
- conditional routing
- data transformation
- idempotency
- error handling
Pattern 4: Publish overdue Work Order alerts
When to use this pattern
Use this pattern when facilities teams need timely notifications for overdue Work Orders, unassigned high-priority Requests, repeated asset failures, or low Parts thresholds. It is suitable when selected event coverage is unavailable and periodic evaluation is acceptable.
Integration direction
Example Mapping
| UpKeep Field | Canonical Field | Target Field |
|---|---|---|
| Work Order due date | dueAt | alertTime |
| Work Order priority | priority | severity |
| Assigned User | assignee | owner |
| Work Order ID | sourceId | reference |
Martini implementation pattern
A scheduler-triggered workflow retrieves relevant UpKeep objects, applies overdue and assignment rules, formats a concise notification, and sends it to Microsoft Teams. Martini records the evaluated source IDs so repeated scheduler runs do not generate duplicate alerts and retries transient delivery failures.
Martini capabilities used
- scheduler triggers
- REST API consumption
- business rules
- data mapping
- deduplication
- retry handling
Applications commonly integrated with UpKeep
UpKeep data can be incorporated into accounting, CRM, service-management, collaboration, issue-tracking, ERP, and scheduling processes. These are common enterprise architecture patterns rather than confirmation of native UpKeep connectors; endpoint, permission, and event coverage should be verified for each implementation.
| Application | Scenario | Direction | Martini Pattern |
|---|---|---|---|
| QuickBooks Online | Transfer maintenance-related costs, vendor charges, or purchasing information into accounting workflows. | UpKeep → Martini → QuickBooks Online | A scheduled Martini workflow retrieves completed Work Orders and relevant Parts or cost fields, validates accounting dimensions, maps them to QuickBooks Online objects, and retries transient failures without duplicating previously posted transactions. |
| Salesforce | Associate maintenance activity, customer-site Assets, and Requests with customer or account records. | UpKeep → Martini → Salesforce | Martini synchronizes UpKeep identifiers, Locations, Assets, and Requests into Salesforce using stable external IDs, applies account and site matching rules, and routes unmatched records for review. |
| ServiceNow | Synchronize maintenance Requests and Work Orders with broader facilities, IT, or enterprise service-management processes. | UpKeep → Martini → ServiceNow | Martini polls or receives eligible UpKeep changes, maps status, priority, assignment, and location values into ServiceNow, and supports controlled reverse updates where ServiceNow is authorized to initiate maintenance work. |
| Jira | Create and track engineering or product issues arising from equipment failures or maintenance findings. | UpKeep → Martini → Jira | A Martini workflow identifies qualifying high-priority Requests or Work Orders, creates Jira issues with normalized asset and location context, stores cross-system identifiers, and processes status updates idempotently. |
| Slack | Notify maintenance teams about high-priority Requests, overdue Work Orders, or completed maintenance. | UpKeep → Martini → Slack | Martini evaluates scheduled UpKeep data or selected inbound events against business rules, formats concise notifications, and sends only actionable changes while recording delivery failures for retry. |
| Microsoft Teams | Distribute maintenance alerts and operational updates to facilities or field-service teams. | UpKeep → Martini → Microsoft Teams | A workflow retrieves or receives qualifying UpKeep changes, transforms them into Teams notification payloads, applies routing rules by Location or priority, and logs unsuccessful deliveries. |
| NetSuite | Synchronize maintenance costs, Parts, suppliers, and asset-related financial information with ERP processes. | UpKeep → Martini → NetSuite | Martini retrieves changed Work Orders and Parts, enriches them with canonical asset and location identifiers, validates ERP-required fields, and writes idempotent transactions to NetSuite. |
| Google Calendar | Publish scheduled maintenance activities or technician appointments to calendars. | UpKeep → Martini → Google Calendar | A scheduled workflow reads eligible Work Orders, converts UpKeep scheduling and time-zone values into calendar events, tracks source identifiers, and updates rather than recreates events when schedules change. |
How to build a UpKeep integration in Martini
Objective
Establish UpKeep access using the documented API-key pattern without embedding credentials in workflows or source code.
Instructions in Martini
- Store the UpKeep API key in a Martini secret
- Configure the REST API request to inject the required header
- Use separate credentials for development, testing, and production
- Confirm account permissions and endpoint coverage
Objective
Select real-time or scheduled initiation based on the specific UpKeep object and event coverage required.
Instructions in Martini
- Use a confirmed UpKeep notification with a Martini receiving API when appropriate
- Use a scheduler for unsupported or uncertain event coverage
- Define the polling interval and overlap window
- Record the source object and event assumptions
Objective
Read current UpKeep objects reliably, including large collections and related information needed by the target system.
Instructions in Martini
- Request Work Orders, Requests, Assets, Locations, Parts, or Users from the REST API
- Process paginated responses until no page remains
- Use updated-time filters where supported
- Persist a checkpoint for restartable synchronization
Objective
Coordinate API calls, enrichment, conditional routing, and target writes in a maintainable Martini workflow.
Instructions in Martini
- Separate retrieval, transformation, validation, and delivery stages
- Retrieve related objects only when required
- Route invalid or unmatched data to an explicit exception path
- Preserve correlation and source identifiers
Objective
Convert UpKeep fields and relationships into a canonical model and target-specific representation.
Instructions in Martini
- Map statuses, priorities, users, Assets, Locations, quantities, and time zones
- Validate required fields before downstream writes
- Use stable UpKeep IDs rather than display names as keys
- Handle optional and newly introduced fields explicitly
Objective
Deliver normalized data to enterprise applications while avoiding duplicate creates and uncontrolled side effects.
Instructions in Martini
- Use upsert or update semantics where supported
- Store cross-system identifiers
- Apply business rules before posting financial or operational transactions
- Handle target validation and authorization errors separately
Common UpKeep data objects used in integrations
| Object | Typical Use | Common target systems | Martini handling |
|---|---|---|---|
| Work Orders | Represent planned or reactive maintenance tasks, including status, priority, assignment, scheduling, labor, and completion information. | ERP, QuickBooks Online, NetSuite, ServiceNow, Salesforce, reporting platforms | Martini retrieves changed Work Orders, validates required asset, location, status, and cost data, maps them to target models, and upserts them using stable UpKeep identifiers. |
| Requests | Capture maintenance requests for review, triage, and possible conversion into Work Orders. | ServiceNow, Salesforce, Jira, Slack, Microsoft Teams | Martini can poll or receive selected event notifications, apply routing and priority rules, and create or update downstream service and collaboration items. |
| Assets | Identify equipment and other maintained items, including location, operational information, and maintenance history. | Enterprise asset repositories, Salesforce, ServiceNow, reporting platforms | Martini normalizes asset identifiers, status values, ownership, and relationships before synchronizing them to a governed target model. |
| Locations | Represent sites, buildings, rooms, or other physical locations associated with maintenance activity. | ServiceNow, Salesforce, ERP, reporting platforms | Martini maps location hierarchies and time-zone or ownership data, preserves source identifiers, and handles unmatched parent locations through validation branches. |
| Parts | Represent inventory items and spare parts used during maintenance activities. | NetSuite, QuickBooks Online, ERP, inventory platforms | Martini maps part identifiers, quantities, units, and cost information, validates target requirements, and prevents duplicate downstream postings. |
| Users | Identify technicians, requesters, administrators, and other UpKeep participants. | Salesforce, ServiceNow, identity or reporting platforms | Martini synchronizes user references where required for assignment and ownership mappings, while preserving source IDs and handling inactive or unmatched users explicitly. |
Authentication and security considerations
API-key authentication
UpKeep’s documented public integration pattern uses an API key supplied in an HTTP request header. OAuth 2.0, JWT bearer tokens, and granular OAuth scopes were not confirmed for the public API.
Martini secret management
- Store UpKeep API keys in Martini secrets or protected environment configuration.
- Use separate credentials for development, testing, and production.
- Restrict access to workflows that require UpKeep data.
- Prevent authentication headers and sensitive maintenance information from appearing in logs.
Operational considerations for UpKeep integrations
Rate limits and retries
Confirm UpKeep request limits, response headers, and throttling behavior. Use controlled request rates, bounded retries, exponential backoff, and separate handling for authentication, validation, throttling, and server failures.
Pagination and checkpoints
Process collections page by page and persist synchronization state. Use updated-time filters where supported, account for time zones and timestamp precision, and retain a small overlap window for late-arriving updates.
Idempotency and schema changes
Use stable UpKeep object identifiers for upserts and duplicate detection. Validate enum values, required fields, nested structures, and pagination behavior so API changes produce visible exceptions rather than silent data loss.
Attachments and testing
Confirm attachment endpoints, supported objects, file limits, access controls, and URL expiration before synchronizing photographs or documents. Test representative status, assignment, location, and error scenarios in a non-production environment.
Why use Martini instead of scripts or point-to-point integrations?
Reusable orchestration
Scripts often combine authentication, pagination, transformation, retries, and target-specific behavior in code that becomes difficult to govern. Martini separates these concerns into reusable workflows, mappings, validation, and error paths.
Reliable synchronization
Martini can coordinate scheduled polling or confirmed inbound notifications, preserve checkpoints, apply idempotency rules, and route failures for retry or investigation.
Controlled enterprise APIs
Instead of creating many point-to-point dependencies, Martini can expose a governed API façade for selected UpKeep operations and standardize data for multiple downstream systems.
Frequently asked questions
UpKeep can be integrated primarily through its REST API using API-key authentication. Enterprise workflows can retrieve, create, update, and synchronize Work Orders, Requests, Assets, Locations, Parts, and Users. Selected webhook-style notifications may be available, but event coverage should be confirmed; scheduled REST polling is the fallback for unsupported events.
Yes. Martini can consume the UpKeep REST API, authenticate with an UpKeep API key, orchestrate scheduled synchronization, map and transform maintenance data, and expose APIs or receive webhook-style notifications when the required UpKeep capability is available.
No. A dedicated UpKeep connector is not required. Martini can integrate with UpKeep using its confirmed native REST API and API-key authentication, with scheduled workflows and selected webhook-style inbound processing where supported.
Lonti does not charge an additional per-connector or per-vendor fee to integrate UpKeep. The integration is subject to the provisioned capacity of the Martini environment. Separate costs may apply from UpKeep, cloud infrastructure, or other third-party services based on subscriptions, usage, and deployment model.
The UpKeep REST API is the primary recommended method for new integrations. Use API-key authentication, pagination, incremental filters where supported, and scheduled workflows for synchronization. Webhook-style notifications should be used only for confirmed event types. No public GraphQL or SOAP API was confirmed.
UpKeep may support webhook-style notifications for selected events or account capabilities, but complete coverage should not be assumed for every Work Order, Request, Asset, or Part change. Martini can receive confirmed notifications; otherwise, scheduled REST polling provides a controlled alternative.
Martini can synchronize UpKeep data through paginated, incremental REST requests, persisted checkpoints, and a small overlap window. Stable UpKeep identifiers should be used as idempotency keys so downstream writes update existing objects or safely ignore duplicate deliveries.
Yes. Martini can expose a controlled REST API that standardizes selected UpKeep operations, applies authorization and business rules, hides vendor-specific details, and orchestrates calls to the UpKeep REST API. This does not require a native UpKeep connector.
Related Martini documentation
APIs
Integrate UpKeep with Martini
Use Martini to connect UpKeep maintenance data with enterprise applications through secure API consumption, scheduled workflows, mapping, validation, and controlled automation.