.png)
Mural Integration Guide
Connect Mural workspaces and collaboration assets with enterprise applications through REST APIs, OAuth 2.0, and selected webhook notifications.
Mural integration options at a glance
Mural’s integration surface is centered on its public REST APIs and OAuth 2.0 authorization. Martini can consume documented Mural endpoints to list, retrieve, and update supported Workspaces, Rooms, Murals, Users, and Templates, subject to current API coverage and permissions. Mural also provides webhook-style notifications for selected events, allowing Martini to start workflows that validate an event and retrieve the latest resource state. For broader reconciliation, scheduled workflows can process paginated REST responses with checkpoints and idempotent writes. A dedicated bulk API, general file or attachment API, GraphQL API, SOAP API, and direct database access were not confirmed.
| Integration point | Supported by Mural? | Common use cases | How Martini supports it |
|---|---|---|---|
| REST APIs | Yes | Retrieve and, where supported, create or update Workspaces, Rooms, Murals, Users, and Templates. Endpoint coverage and operations should be confirmed against the current Mural API reference. | Martini can consume Mural REST endpoints, pass identifiers between workflow steps, transform responses, apply business rules, and write normalized data to downstream systems. |
| Webhooks / outbound callbacks | Limited | Receive webhook-style notifications for selected Mural changes. Coverage should not be assumed for every collaboration action or resource. | Martini can expose a webhook workflow, validate the request, extract the event and resource identifier, retrieve current state through REST, and handle retries or duplicate deliveries. |
| Authentication | Yes | Authorize applications through OAuth 2.0 with user consent, access tokens, configured permissions, and access constrained by the authenticated user’s Mural permissions. | Martini can keep OAuth client credentials and tokens in secrets configuration, attach authorization to API calls, and support token lifecycle and reauthorization handling. |
| Scheduled synchronization | Yes | Reconcile Mural resources when webhook coverage is incomplete or when an enterprise catalog requires periodic refreshes. | Martini can schedule workflows, paginate through REST responses, persist checkpoints, limit concurrency, and perform idempotent downstream upserts. |
| Bulk / async / batch APIs | Not confirmed | A dedicated Mural bulk or asynchronous API was not confirmed. Large jobs should use paginated REST calls unless the required bulk facility is documented. | Martini can orchestrate controlled batches and checkpoints through workflows without claiming a Mural bulk endpoint. |
| File / attachment APIs | Not confirmed | A general-purpose Mural file or attachment API was not confirmed; integrations should not assume that canvas assets, comments, or exports are available as files. | Martini can process files supplied by a confirmed endpoint or external system, but the required Mural export capability must first be verified. |
| GraphQL APIs | Not confirmed | No official Mural GraphQL API was confirmed in the supplied research. | Martini integrations should use the documented Mural REST API rather than infer GraphQL support. |
| SOAP APIs | Not confirmed | No official Mural SOAP API was confirmed in the supplied research. | Martini should consume Mural REST endpoints and webhook notifications instead of assuming SOAP availability. |
How Mural exposes data and business events
Mural REST APIs
Mural provides public REST APIs for application integration with supported Workspaces, Rooms, Murals, Users, and Templates. Exact fields, identifiers, relationships, and operations should be derived from the current Mural API reference rather than assumed from the product interface.
Martini implementation pattern
Martini uses a workflow to authenticate with OAuth 2.0, call the required Mural endpoint, handle pagination and response validation, map the result into a canonical model, and write or return the transformed data. The same workflow can apply business rules, preserve checkpoints, and route failures for retry or review.
Implementation sequence
Mural webhook notifications
Mural supports webhook-style notifications for selected events. These notifications are not a complete event stream for every Mural action, and the payload may provide an identifier rather than a complete current resource.
Martini implementation pattern
Martini exposes a webhook endpoint that validates the request and extracts the event details. The workflow then retrieves the latest Mural resource through REST before transforming it, which reduces dependence on the detail and completeness of the notification payload.
Implementation sequence
Scheduled Mural synchronization
Scheduled reconciliation is appropriate when webhook coverage is incomplete or an enterprise catalog requires periodic consistency checks. A dedicated Mural bulk API was not confirmed.
Martini implementation pattern
Martini schedules a workflow that retrieves paginated Mural resources, uses a checkpoint or last-processed value where available, limits concurrency, and performs idempotent upserts. Errors are isolated and retried without restarting the entire synchronization unnecessarily.
Implementation sequence
Common Mural integration patterns
Pattern 1: Synchronize Mural activity metadata to an enterprise catalog
When to use this pattern
Use this pattern when an organization needs a searchable inventory of Mural Workspaces, Rooms, Murals, or Users in a reporting database, governance repository, or collaboration directory. It is suitable for periodic reconciliation where complete event coverage is not available.
Integration direction
Example Mapping
| Mural Field | Canonical Field | Target Field |
|---|---|---|
| Mural identifier | collaborationAssetId | External ID |
| Mural name or title | collaborationAssetName | Name |
| Workspace or Room identifier | parentContainerId | Parent reference |
| Mural URL | collaborationUrl | Resource link |
Martini implementation pattern
A scheduled Martini workflow calls paginated Mural REST endpoints, applies permission-aware filtering, maps each supported object to a canonical catalog model, and performs idempotent upserts. Checkpoints prevent unnecessary rereads, while bounded retries and failure reporting protect the job from transient API or database errors.
Martini capabilities used
- Scheduling workflows
- REST API consumption
- Pagination and checkpoint orchestration
- Data mapping
- Business rules
- Error handling and retries
Pattern 2: Process selected Mural changes for team notifications
When to use this pattern
Use this pattern when selected Mural changes should notify Slack, Microsoft Teams, or another downstream application. It is appropriate when event coverage matches the required resource changes and the target needs links or metadata rather than full canvas extraction.
Integration direction
Example Mapping
| Mural Field | Canonical Field | Target Field |
|---|---|---|
| Event type | changeType | Notification category |
| Resource identifier | collaborationAssetId | Referenced resource |
| Mural URL | collaborationUrl | Message link |
| Event timestamp | changedAt | Notification time |
Martini implementation pattern
Martini receives the supported webhook notification, validates its authenticity, retrieves the latest Mural resource, and constructs a concise target notification. Duplicate event identifiers are tracked, transient failures are retried with bounded backoff, and unsupported event types are routed to a controlled no-op or review path.
Martini capabilities used
- Webhook consumption
- REST API consumption
- Request validation
- Data transformation
- Duplicate handling
- Error handling and retries
Pattern 3: Align Mural Rooms with Jira or ServiceNow work
When to use this pattern
Use this pattern when Mural collaboration spaces need to be associated with Jira projects or ServiceNow records. It supports bidirectional metadata reconciliation, but exact update operations must be validated against both application APIs and the authenticated user’s permissions.
Integration direction
Example Mapping
| Mural Field | Canonical Field | Target Field |
|---|---|---|
| Jira project key or ServiceNow record identifier | workReferenceId | Mural association reference |
| Mural Room identifier | collaborationContainerId | External collaboration ID |
| Mural name | collaborationContainerName | Display name |
| Mural URL | collaborationUrl | Collaboration link |
Martini implementation pattern
A Martini workflow loads identifiers from the delivery or service system, searches or retrieves the permitted Mural resources, detects existing associations, and applies only supported updates. Validation rules prevent ambiguous matches, and failed writes are retried or placed in a reconciliation queue without creating duplicate links.
Martini capabilities used
- Workflow orchestration
- REST API consumption
- Cross-system identifier mapping
- Validation and business rules
- Idempotent updates
- Error handling
Applications commonly integrated with Mural
Mural collaboration metadata can be connected with adjacent workplace, delivery, knowledge, and service-management applications. These patterns should be validated against the current Mural and target application APIs, especially when a use case requires more than links or metadata.
| Application | Scenario | Direction | Martini Pattern |
|---|---|---|---|
| Microsoft Teams | Surface Mural collaboration resources in team channels and coordinate workshops alongside existing Microsoft collaboration activity. | Mural → Martini → Microsoft Teams | Use Mural REST queries or selected webhook notifications to retrieve permitted Mural links and metadata, map them to Teams messages or channel content, and apply permission-aware filtering before publication. |
| Slack | Notify teams about selected Mural activity and provide links to relevant collaboration spaces. | Mural → Martini → Slack | Receive supported Mural notifications or run a scheduled reconciliation, transform the event into a concise Slack notification, and retry transient target API failures without duplicating messages. |
| Jira | Associate Murals with epics, projects, or delivery initiatives so engineering teams can access collaboration references. | Jira → Martini → Mural | Reconcile project identifiers with Mural Rooms or Murals, maintain a cross-reference, and perform only API operations permitted by both systems, with duplicate detection and retry handling. |
| Confluence | Link workshop outputs and visual collaboration assets to project or knowledge documentation. | Mural → Martini → Confluence | Retrieve Mural metadata and links, map them to Confluence page properties or content references, and avoid assuming that complete canvas or attachment export is available. |
| ServiceNow | Associate discovery or service-design Murals with incidents, requests, change records, or project work. | Mural → Martini → ServiceNow | Use scheduled or event-driven workflows to correlate Mural identifiers with ServiceNow records, validate access, and perform idempotent metadata updates where supported. |
| Google Drive | Link or catalog Mural-related assets alongside broader project documentation. | Mural → Martini → Google Drive | Publish Mural links and permitted metadata to a Drive-based catalog or document index; confirm export requirements before attempting content transfer because a general Mural file API was not confirmed. |
How to build a Mural integration in Martini
Objective
Establish OAuth 2.0 access to Mural and configure the target application credentials without exposing secrets in workflow definitions or logs.
Instructions in Martini
- Create or configure the Mural OAuth application and required permissions
- Store client credentials, access tokens, and refresh tokens in Martini secrets configuration
- Confirm that the authenticated user can access the required Workspaces, Rooms, Murals, Users, or Templates
- Configure target-system authentication separately
Objective
Select an event-driven or scheduled start based on the required Mural event coverage and synchronization consistency needs.
Instructions in Martini
- Use a webhook workflow for supported Mural notifications
- Use a scheduler for reconciliation and catalog refreshes
- Combine webhook processing with scheduled checks when event coverage is incomplete
- Define the event, time window, or checkpoint that starts processing
Objective
Obtain the current Mural resource state rather than relying on assumptions about notification payload completeness.
Instructions in Martini
- Validate webhook requests before processing them
- Call the relevant Mural REST endpoint
- Handle pagination for list responses
- Retrieve the current resource after a webhook notification
- Persist a checkpoint or processed-event identifier
Objective
Coordinate validation, enrichment, routing, and target writes in a maintainable Martini workflow.
Instructions in Martini
- Route unsupported or unauthorized resources to a controlled outcome
- Apply resource-specific business rules
- Separate Mural-specific API handling from canonical data processing
- Use reusable workflow logic for common retrieval and error paths
Objective
Translate Mural-specific responses into a stable model for downstream applications while preserving relevant identifiers and links.
Instructions in Martini
- Map Mural identifiers, names, relationships, and URLs to canonical fields
- Normalize timestamps and optional values where required
- Preserve source identifiers for reconciliation
- Do not assume that canvas elements, comments, files, or exports are available unless confirmed
Objective
Persist or publish the transformed result while preventing duplicate records and unauthorized data exposure.
Instructions in Martini
- Use idempotent upserts in catalogs, databases, or target applications
- Apply permission-aware filtering before exposing Mural data
- Publish only the metadata or links supported by the use case
- Record the source identifier and processing outcome
Common Mural data objects used in integrations
| Object | Typical Use | Common target systems | Martini handling |
|---|---|---|---|
| Murals | Collaborative visual canvases containing workshop and diagram content; commonly synchronized as metadata, links, or governance references. | Microsoft Teams, Slack, Confluence, ServiceNow, project catalogs | Martini retrieves supported Mural fields, maps identifiers and links to a canonical model, and avoids assuming that every visual element or export is exposed. |
| Rooms | Organizational areas that group related Murals and support project or team-level cataloging. | Jira, Confluence, ServiceNow, enterprise collaboration catalogs | Martini can reconcile Room identifiers, apply permission-aware filtering, and upsert normalized metadata into target systems. |
| Workspaces | Higher-level organizational containers for Users, Rooms, and Murals. | Governance repositories, collaboration directories, reporting databases | Martini processes paginated Workspace responses, stores checkpoints, and preserves Mural-specific mappings separately from downstream models. |
| Users | People who own, access, or collaborate in Workspaces and Murals. | Collaboration directories, identity-aware portals, governance systems | Martini maps permitted user attributes and applies access rules before exposing or synchronizing user-related data. |
| Templates | Reusable starting points for creating new collaborative canvases. | Project portals, delivery systems, internal collaboration applications | Martini retrieves supported Template metadata and exposes it through a controlled API or maps it to approved provisioning workflows. |
Authentication and security considerations
OAuth 2.0 authorization
Mural documents OAuth 2.0 as the primary authorization model for applications accessing Mural data on behalf of users or organizations. Access is limited by the authenticated user’s Mural permissions and configured scopes or permissions.
Secrets and access control
- Store Mural client credentials, access tokens, and refresh tokens in Martini secrets configuration.
- Request only the permissions required by each workflow.
- Plan for token expiration, revocation, rotation, and reauthorization.
- Do not expose collaboration data through a Martini API without validating the requesting user’s authorization.
Operational considerations for Mural integrations
Rate limits and pagination
Confirm Mural’s current quotas and pagination behavior in the developer documentation. Use bounded concurrency, checkpoints, and controlled scheduled processing for larger synchronizations.
Retries and duplicate events
Webhook deliveries may be retried or duplicated. Track event and resource identifiers, use idempotent writes, apply bounded exponential backoff for transient failures, and retrieve current resource state after notifications.
Schema and content limits
Keep Mural-specific mappings isolated from downstream models and handle optional fields defensively. Do not assume that all visual elements, comments, files, or export formats are available through the public API. Test deleted, archived, and inaccessible Murals.
Why use Martini instead of scripts or point-to-point integrations?
Orchestrated integration logic
Martini coordinates OAuth-authenticated API calls, selected webhook processing, scheduled reconciliation, validation, transformations, target writes, and error paths in maintainable workflows.
Separation of concerns
Unlike a point-to-point script, Martini can isolate Mural-specific mappings from canonical models and reuse integration logic across collaboration, delivery, service, and governance applications.
Operational control
- Apply checkpoints, idempotency, retries, and business rules consistently.
- Expose controlled APIs without bypassing Mural permissions.
- Monitor workflow outcomes and troubleshoot failures without embedding credentials in application code.
Frequently asked questions
Mural can be integrated through its public REST APIs, OAuth 2.0 authorization, and webhook-style notifications for selected events. Enterprise workflows can retrieve supported Workspaces, Rooms, Murals, Users, and Templates, then synchronize permitted metadata with other applications.
Yes. Martini can consume Mural REST APIs, receive supported Mural webhook notifications, manage OAuth-related secrets, transform JSON responses, orchestrate synchronization workflows, and expose controlled APIs for downstream applications.
No. A dedicated Mural connector is not required. Martini can integrate using Mural’s documented REST APIs, OAuth 2.0 authorization, selected webhook notifications, and workflow capabilities.
Lonti does not charge an additional per-connector or per-vendor fee to integrate Mural. The integration is subject to the provisioned capacity of the Martini environment. Separate costs may apply from Mural, cloud infrastructure, or other third-party systems depending on subscription, usage, and deployment model.
The primary method is Mural’s documented REST API with OAuth 2.0. Selected webhook notifications can support event-driven processing, while scheduled, paginated REST workflows provide reconciliation when event coverage is incomplete. GraphQL and SOAP were not confirmed.
Mural provides webhook-style notifications for selected events, but they should not be treated as a complete event stream for every Mural action. Martini can receive a notification, validate it, retrieve the latest resource through REST, and process duplicates or retries safely.
Access is constrained by the authenticated user’s Mural permissions and configured application scopes or permissions. Martini maps supported Mural objects into canonical models, preserves source identifiers, applies permission-aware filtering, and performs idempotent target updates.
Yes. Martini can expose a controlled REST API that retrieves supported Mural resources through OAuth-protected workflows and returns an enterprise-friendly response. The façade should enforce caller authorization and must not expose resources beyond the requesting user’s permitted access.
Related Martini documentation
Connect Mural with your enterprise systems
Use Martini to build secure, maintainable Mural integrations around REST APIs, OAuth 2.0, selected webhook notifications, scheduled synchronization, and reusable workflow logic.