.png)
4me Integration Guide
Integrate 4me service-management data with enterprise applications through its REST API, selected webhook notifications, and secure authenticated workflows.
4me integration options at a glance
4me provides a versioned REST API for creating, reading, updating, deleting, searching, and synchronizing service-management resources such as Requests, Problems, Changes, People, Organizations, and Services. It also supports webhook-style notifications for selected events and configured use cases, although coverage is not universal across every object or field. API tokens and OAuth 2.0 support authenticated access, with account context and permissions affecting each request. Martini can consume the REST API, receive webhook notifications, expose an API façade, schedule paginated synchronization workflows, transform JSON payloads, and route supported attachments or file content.
| Integration point | Supported by 4me? | Common use cases | How Martini supports it |
|---|---|---|---|
| REST APIs | Yes | The 4me REST API is the primary mechanism for managing Requests, Problems, Changes, People, Organizations, Services, and other supported resources. It supports resource-specific operations, searches, filters, and service-management orchestration. | Martini can consume the versioned 4me REST API, expose controlled APIs that abstract 4me operations, map JSON payloads, and orchestrate multi-step workflows. |
| Webhooks / outbound callbacks | Limited | 4me supports webhook-style notifications and webhook integrations for selected resources and events. Coverage depends on the configured use case and should not be assumed for every object or field change. | Martini can receive the HTTP notification, validate and deduplicate it, retrieve the current 4me resource when needed, and invoke downstream workflows or APIs. |
| Authentication | Yes | 4me supports API tokens sent as Bearer tokens and OAuth 2.0 for delegated application authorization. Account context, roles, permissions, and OAuth scopes affect access. | Martini can store tokens, OAuth credentials, refresh tokens, and account identifiers in secrets or protected environment configuration and apply them to outbound requests. |
| File / attachment APIs | Limited | Requests and other resources may contain attachments or related file data, but attachment operations and payloads are resource-specific and must be verified for the target endpoint. | Martini can retrieve or send supported attachment content through HTTP workflows and route or transform file data as part of a larger integration process. |
| Scheduled synchronization | Yes | Scheduled API calls can synchronize resources not covered by webhook events or provide reconciliation for missed notifications. Pagination, filtering, checkpoints, and overlap windows are important for reliable processing. | Martini can run scheduler-triggered workflows, paginate through results, maintain checkpoints, apply incremental filters where available, and reconcile duplicates. |
| Bulk / asynchronous APIs | Not confirmed | A universal bulk or asynchronous API for all 4me resources was not confirmed. Large synchronizations should not assume that a general bulk endpoint exists. | Martini can implement controlled batching, queues, pagination, and scheduled API calls using ordinary 4me requests where appropriate. |
| GraphQL APIs | Not confirmed | No official 4me GraphQL API was confirmed in the reviewed documentation. | Martini can use REST-based integration for 4me; a GraphQL approach should not be designed unless 4me documents a supported endpoint for the target account. |
| SOAP APIs | Not confirmed | No official 4me SOAP API was confirmed in the reviewed documentation. | Martini can integrate with 4me through the confirmed REST and webhook mechanisms rather than assuming SOAP support. |
How 4me exposes data and business events
4me REST APIs
The 4me REST API is the primary integration interface for service-management resources. It supports resource-specific operations for objects such as Requests, Problems, Changes, People, Organizations, and Services, including searches and filters where documented.
Martini implementation pattern
Martini implementation pattern: a workflow or Martini API receives or retrieves data, authenticates to 4me with an API token or OAuth configuration, calls the relevant versioned endpoint, transforms the JSON response, and writes the result to another system. The workflow can apply validation, correlation, retries, and account-specific business rules.
Implementation sequence
4me Webhooks
4me supports webhook-style notifications for selected resources and events. Notifications are configuration- and event-specific, and the payload may contain only event metadata or an identifier rather than a complete resource representation.
Martini implementation pattern
Martini implementation pattern: expose a secured HTTP endpoint or webhook workflow, validate and persist the notification, deduplicate it, and retrieve the current 4me resource when the notification is incomplete. The workflow then routes the normalized event to downstream systems or a reusable service-management process.
Implementation sequence
4me Attachments
4me resources such as Requests may include attachments or related file data. Attachment operations are resource-specific, so the applicable endpoint, permissions, and payload format must be confirmed before implementation.
Martini implementation pattern
Martini implementation pattern: retrieve or submit supported attachment content through the relevant 4me HTTP endpoint, preserve the relationship to the parent Request or Change, and route the file to the target application or storage process. The workflow should treat attachment failures separately from parent-resource failures.
Implementation sequence
Common 4me integration patterns
Pattern 1: Synchronize people and organizations to 4me
When to use this pattern
Use this pattern when an identity, HR, CRM, or customer-management application is the source of truth for users and organizational structures. Scheduled synchronization is appropriate because webhook coverage may not exist for every relevant 4me object or event.
Integration direction
Example Mapping
| 4me Field | Canonical Field | Target Field |
|---|---|---|
| user.email | person.email | People.email |
| user.displayName | person.name | People.name |
| department.id | organization.externalId | Organizations.externalId |
| user.department | person.organization | People.organization |
Martini implementation pattern
A scheduler-triggered Martini workflow retrieves source users and organizations with pagination, resolves existing 4me IDs using stable identifiers, and creates or updates supported People and Organizations. It protects 4me-owned fields, applies account-specific validation, stores checkpoints, and sends failed items to a reconciliation path with bounded retries.
Martini capabilities used
- scheduled workflows
- API consumption
- pagination and checkpointing
- data mapping
- business rules
- idempotency
- error handling
Pattern 2: Create 4me Requests from an internal application
When to use this pattern
Use this pattern when an internal application should submit service requests without holding 4me credentials or implementing 4me-specific field rules. Martini provides a controlled API façade and centralizes validation and orchestration.
Integration direction
Example Mapping
| 4me Field | Canonical Field | Target Field |
|---|---|---|
| requesterEmail | request.requester | Requests.requester |
| serviceCode | request.service | Requests.service |
| urgency | request.urgency | Requests.urgency |
| description | request.description | Requests.description |
Martini implementation pattern
A Martini REST API accepts the internal payload, validates required fields, resolves the requester, organization, and service in 4me, and creates the Request through the authenticated REST API. The workflow uses an external correlation ID to prevent duplicates, returns the 4me identifier, and handles validation, authorization, throttling, and transient failures separately.
Martini capabilities used
- API exposure
- API consumption
- JSON handling
- validation
- data mapping
- business rules
- idempotency
- error handling
Pattern 3: Propagate selected Request updates to collaboration tools
When to use this pattern
Use this pattern when operational teams need timely notifications for selected Request status, priority, assignment, or comment changes. It is suitable for events supported by the configured 4me webhook capability, with scheduled reconciliation for missed events.
Integration direction
Example Mapping
| 4me Field | Canonical Field | Target Field |
|---|---|---|
| Request.subject | notification.title | Microsoft Teams.title |
| Request.priority | notification.severity | Microsoft Teams.text |
| Request.status | notification.status | Microsoft Teams.text |
| Request.assignee | notification.owner | Microsoft Teams.text |
Martini implementation pattern
A Martini webhook workflow receives the selected 4me notification, validates and deduplicates it, retrieves the current Request, and applies routing rules for priority or status. It formats a Teams notification, suppresses irrelevant changes, records delivery status, and retries transient downstream errors without sending duplicate messages.
Martini capabilities used
- webhook consumption
- workflow orchestration
- API consumption
- data mapping
- conditional routing
- deduplication
- retry handling
Pattern 4: Coordinate approved Changes with enterprise systems
When to use this pattern
Use this pattern when a Change approved or scheduled in 4me must create or update an implementation record in another service-management or operational platform.
Integration direction
Example Mapping
| 4me Field | Canonical Field | Target Field |
|---|---|---|
| Change.id | change.sourceId | change.u_4me_id |
| Change.subject | change.title | change.short_description |
| Change.status | change.approvalState | change.state |
| Change.scheduledStartAt | change.startTime | change.start_date |
Martini implementation pattern
Martini receives a supported Change notification or identifies the Change during scheduled polling, retrieves the current resource, and checks approval and scheduling rules before calling the target API. It stores both system identifiers, updates 4me with the external reference where supported, and routes authorization, validation, and target-system failures for review.
Martini capabilities used
- webhook or scheduled triggers
- API orchestration
- data mapping
- business rules
- correlation management
- retries
- exception routing
Applications commonly integrated with 4me
4me can be integrated with identity directories, service-management platforms, collaboration tools, CRM systems, and business applications. These are typically API-led integrations rather than evidence of a packaged Martini connector. Martini can coordinate the relevant APIs, apply account-specific rules, and maintain reusable mappings and error-handling workflows.
| Application | Scenario | Direction | Martini Pattern |
|---|---|---|---|
| Microsoft Entra ID | Synchronize users, departments, and organizational attributes so that 4me People and Organizations remain aligned with the identity directory. | Microsoft Entra ID → Martini → 4me | Run a scheduled workflow that retrieves users and organizational data from Microsoft Entra ID, resolves existing 4me People and Organizations, applies account-specific mapping rules, and creates or updates only approved fields. Store correlation identifiers and route permission or validation failures for review. |
| Okta | Reconcile identity attributes used by 4me and coordinate identity-related service requests with the enterprise identity platform. | Okta → Martini → 4me | Use scheduled REST calls to retrieve Okta users and groups, map them to 4me People, Organizations, or Teams where appropriate, and apply idempotent upsert logic. Keep 4me-managed fields protected and record synchronization outcomes. |
| Jira | Link 4me Requests or Problems with development and engineering work so operational issues can create or update Jira issues. | 4me → Martini → Jira | Receive a selected 4me webhook or poll for qualifying Requests and Problems, retrieve the current resource, map priority, status, description, comments, and correlation identifiers, and call the Jira API. Use duplicate detection and bounded retries for downstream failures. |
| ServiceNow | Coordinate service-management data during coexistence, consolidation, migration, or controlled synchronization between platforms. | 4me → Martini → ServiceNow | Orchestrate 4me and ServiceNow REST calls in a workflow that maps Requests, Problems, Changes, People, and external identifiers. Define a system of record for each field, preserve both platform IDs, and route conflicting updates or authorization failures to an exception process. |
| Microsoft Teams | Notify operational teams about selected high-priority Requests, Changes, or other configured 4me events. | 4me → Martini → Microsoft Teams | Accept a supported 4me webhook, validate and deduplicate the notification, retrieve the current resource when necessary, and format a concise Teams message with status, priority, ownership, and a 4me link. Suppress notifications for irrelevant changes. |
| Slack | Publish selected 4me Request or Change updates to operational channels and optionally route controlled actions back through Martini. | 4me → Martini → Slack | Use a 4me webhook or scheduled workflow to identify relevant updates, map them to Slack message content, and deliver them through the appropriate Slack endpoint. If commands are accepted, expose a secured Martini API and validate authorization before calling 4me. |
| Salesforce | Align customer, organization, and service-request context between Salesforce and 4me. | Salesforce → Martini → 4me | Retrieve changed Salesforce accounts, contacts, or service activity, resolve corresponding 4me Organizations and People, and create or update Requests when business rules are met. Persist cross-system IDs and avoid overwriting fields owned by 4me. |
| NetSuite | Connect 4me service requests and customer context with finance and operations processes such as account synchronization or service follow-up. | NetSuite → Martini → 4me | Schedule API-based synchronization between NetSuite and 4me, map customer and organization identifiers, and use workflow conditions to determine when a Request or related update should be created. Apply reconciliation, retry, and exception handling for mismatched master data. |
How to build a 4me integration in Martini
Objective
Establish authenticated access to 4me and any target systems without embedding credentials in workflows or source code.
Instructions in Martini
- Choose an API token or OAuth 2.0 flow based on the authorization model.
- Store tokens, client secrets, refresh tokens, and X-4me-Account values in Martini secrets or protected environment configuration.
- Confirm the 4me account, role, permissions, and applicable OAuth scopes.
Objective
Select an event-driven or scheduled entry point based on the 4me capability and synchronization requirement.
Instructions in Martini
- Use a Martini webhook or HTTP trigger for supported 4me events.
- Use a scheduler trigger for resources or events without suitable webhook coverage.
- Define reconciliation timing for missed, duplicate, or out-of-order notifications.
Objective
Obtain the current 4me resource representation rather than relying on incomplete event payloads.
Instructions in Martini
- Call the documented 4me REST endpoint for Requests, Problems, Changes, People, Organizations, or Services.
- Use pagination and supported filters for scheduled synchronization.
- Retrieve attachments separately when the resource-specific API supports them.
Objective
Coordinate calls, lookups, routing, and downstream writes in a maintainable Martini workflow.
Instructions in Martini
- Resolve related People, Organizations, Services, Teams, or external identifiers before writing dependent objects.
- Separate transient API failures from authentication, authorization, and validation failures.
- Use reusable workflow logic for common 4me request and reconciliation operations.
Objective
Convert 4me JSON structures and account-specific values into a canonical or target-system model.
Instructions in Martini
- Map identifiers, status, priority, requester, assignee, organization, service, comments, and timestamps explicitly.
- Normalize dates, enumerations, and optional fields according to target-system requirements.
- Keep mappings isolated so resource or API-version changes can be updated without redesigning orchestration.
Objective
Enforce system-of-record, authorization, idempotency, and notification rules before making changes.
Instructions in Martini
- Search for an existing object or use a stable external correlation ID before creating a 4me Request.
- Protect fields managed by 4me or the designated source system.
- Restrict notifications and downstream writes to approved statuses, priorities, events, and accounts.
Common 4me data objects used in integrations
| Object | Typical Use | Common target systems | Martini handling |
|---|---|---|---|
| Requests | Manage incidents, service requests, user-reported work items, comments, assignments, status, priority, and related service-management information. | Jira, ServiceNow, Microsoft Teams, Slack, Salesforce | Martini can create, retrieve, update, and synchronize Requests through authenticated REST calls, webhook-triggered retrieval, field mapping, correlation IDs, and business-rule validation. |
| Problems | Track root-cause investigations and coordinate problem-management work with operational or engineering teams. | Jira, ServiceNow, collaboration platforms | Martini can poll or receive selected notifications for Problems, map status and ownership, create downstream work items, and apply retries and duplicate detection. |
| Changes | Coordinate planned changes requiring approval, scheduling, execution, and implementation tracking. | ServiceNow, Jira, Microsoft Teams, Slack | Martini can orchestrate approved or scheduled Change processes, preserve 4me and target identifiers, update implementation status, and route failures for operational review. |
| Organizations | Represent companies, departments, customers, or other organizational units associated with People and Requests. | Microsoft Entra ID, Okta, Salesforce, NetSuite, ServiceNow | Martini can synchronize Organizations using scheduled pagination and reconciliation, while applying system-of-record rules and protecting 4me-managed fields. |
| People | Represent end users, agents, and other individuals associated with service-management activity. | Microsoft Entra ID, Okta, Salesforce, ServiceNow | Martini can map identity and customer attributes to People, resolve existing IDs, and create or update supported fields through idempotent workflows. |
| Services | Classify and manage business or technical services associated with Requests and other service-management processes. | ServiceNow, Jira, internal service catalogs | Martini can retrieve Services to resolve valid service references, map service identifiers into inbound Requests, and avoid hard-coding account-specific values. |
Authentication and security considerations
Authenticated API access
4me supports API tokens sent as Bearer tokens and OAuth 2.0 for delegated application authorization. Requests may also require the relevant 4me account context, and successful authentication does not guarantee permission to access every resource.
Credential protection
Store API tokens, OAuth client credentials, refresh tokens, account identifiers, and related configuration in Martini secrets or protected environment configuration. Do not embed credentials in mappings, source code, or logs.
Least privilege
- Use an account and role with only the permissions required by the workflow.
- Confirm resource permissions, OAuth scopes, and account selection before production deployment.
- Sanitize Request content and response details in operational logs.
Operational considerations for 4me integrations
Reliability and throughput
Respect 4me response and rate-limit behavior, avoid unrestricted parallel calls, and use bounded retries with backoff for transient failures. Scheduled workflows should use pagination, checkpoints, and a small overlap between polling windows.
Events and idempotency
Webhook coverage is selected and configuration-specific. Validate each notification, retrieve the current resource when necessary, handle duplicate or out-of-order delivery, and maintain a reconciliation path for missed events. Use stable external identifiers when creating 4me objects.
Schema and account configuration
Status, priority, category, service, team, requester, assignee, and organization values may depend on the 4me account. Keep mappings configurable, verify resource-specific fields, and monitor API-version or vendor schema changes.
Testing and observability
- Test authentication, account context, permissions, pagination, webhook payloads, attachments, and failure responses in a non-production context.
- Capture resource type, 4me object ID, correlation ID, HTTP status, retry count, and last attempt time.
- Do not log API tokens, OAuth secrets, or unnecessary sensitive Request content.
Why use Martini instead of scripts or point-to-point integrations?
Orchestration beyond point-to-point calls
Martini separates API consumption, triggers, mappings, business rules, downstream writes, and error handling into maintainable workflows. This is useful when a 4me integration must coordinate identity, service-management, collaboration, CRM, or operational systems.
Reusable integration assets
Teams can expose controlled APIs that abstract 4me operations, reuse transformation and validation logic, and isolate account-specific mappings from the broader orchestration flow.
Operational control
- Support webhook-driven processing alongside scheduled synchronization and reconciliation.
- Centralize secrets and environment configuration instead of duplicating credentials across scripts.
- Apply consistent retry, deduplication, monitoring, and exception-routing practices across integrations.
Frequently asked questions
4me can be integrated through its versioned REST API, authenticated with API tokens or OAuth 2.0, and through webhook-style notifications for selected configured events. Scheduled API workflows can support synchronization, reconciliation, pagination, and resources without suitable webhook coverage.
Yes. Martini can consume the 4me REST API, receive supported 4me webhook notifications, expose an API façade for internal applications, transform JSON data, and orchestrate workflows that connect 4me with enterprise systems.
No. A dedicated 4me connector is not required. Martini can integrate using 4me's confirmed native mechanisms, including its REST API, supported webhook notifications, API-token or OAuth authentication, and resource-specific attachment endpoints.
Lonti does not charge an additional per-connector or per-vendor fee to integrate 4me. The integration is subject to the provisioned capacity of the Martini environment. Separate costs may apply from 4me, cloud infrastructure, or other third-party systems based on subscription, usage, and deployment model.
The 4me REST API is the primary method for reading and writing service-management data. Webhook-style notifications are useful for selected configured events, while scheduled REST workflows provide synchronization and reconciliation for objects or events without suitable webhook coverage. No official 4me GraphQL or SOAP API was confirmed.
Yes, where the relevant 4me webhook capability supports the required resource and event. Martini can receive and validate the notification, retrieve the current resource if the payload is incomplete, apply routing rules, and invoke downstream systems. Coverage should be confirmed for each event because it is not universal.
Martini can run scheduled or webhook-triggered workflows that retrieve 4me resources, paginate through results, maintain checkpoints, and map objects such as Requests, People, Organizations, Problems, Changes, and Services to target schemas. Transformations, lookups, validations, and system-of-record rules can be applied before writing the result.
A robust integration uses bounded retries with backoff for transient failures, separates authentication and validation errors from throttling, and logs correlation details without exposing credentials. Stable external identifiers, stored 4me IDs, deduplication, overlap windows, and reconciliation workflows help handle duplicate, missed, or out-of-order notifications.
Related Martini documentation
API Integration
Events & Workflows
Integrate 4me with Martini
Use Martini to connect 4me service-management data with enterprise applications through REST APIs, selected webhook notifications, scheduled synchronization, secure authentication, and maintainable workflows.