.png)
Alfresco Content Services Integration Guide
Integrate Alfresco Content Services with enterprise applications through REST APIs, content endpoints, search, authentication services, and deployment-dependent repository events.
Alfresco Content Services integration options at a glance
Alfresco Content Services is primarily integrated through REST APIs for nodes, folders, documents, sites, people, groups, permissions, search, metadata, and renditions. Its content endpoints support multipart uploads and downloads, while CMIS provides a standards-based alternative for selected repository scenarios. Repository events and extension mechanisms can support selected event-driven flows, but availability depends on the ACS version and deployment, so scheduled polling is often used for reconciliation. Authentication may use Basic Authentication, repository tickets, or OAuth 2.0-style bearer tokens. Martini can orchestrate these calls, handle files and metadata separately, map content models, apply business rules, and expose controlled APIs for downstream applications.
| Integration point | Supported by Alfresco Content Services? | Common use cases | How Martini supports it |
|---|---|---|---|
| REST APIs | Yes | Repository discovery, node, folder, document, site, people, group, permission, search, metadata, rendition, and relationship operations. | Martini can consume ACS REST endpoints, map request and response fields, apply validation and business rules, and expose a separate API for downstream consumers. |
| File / attachment APIs | Yes | Multipart document uploads, content downloads, file metadata, folder creation, movement, copying, deletion, and rendition retrieval. | Martini workflows can handle metadata and binary content as separate logical stages, with bounded processing, content validation, and retry controls. |
| Search APIs | Yes | Full-text and metadata searches for incremental synchronization, discovery, reconciliation, and permission-filtered repository queries. | Martini can construct search requests, follow paging metadata, persist checkpoints, and account for indexing delay through overlap windows and reconciliation. |
| Authentication | Yes | Basic Authentication, repository authentication tickets, and OAuth 2.0-style bearer-token configurations depending on the ACS deployment and identity architecture. | Martini can store credentials, tokens, and client secrets in secure configuration and send the required authentication headers or token exchange requests. |
| CMIS | Yes | Standards-based content management access where an integration must work across repositories or an existing application already uses CMIS. | Martini can consume supported CMIS endpoints using standards-based API calls, while REST remains preferable for ACS-specific features such as aspects, sites, and renditions. |
| Webhooks / outbound callbacks | Limited | Selected repository events may be exposed through repository extensions, event listeners, or external event infrastructure, depending on version and deployment. | Martini can receive compatible HTTP notifications, but the ACS deployment must provide the outbound transport and event coverage. Scheduled reconciliation should complement event processing. |
| Bulk / async / batch APIs | Limited | Selected administrative import and bulk content scenarios; application integrations commonly use bounded batches over REST instead of assuming a universal bulk REST API. | Martini can orchestrate paginated and bounded batch workflows, queue work where appropriate, persist checkpoints, and retry individual operations. |
| SOAP APIs | Legacy | Older Alfresco integrations and remote API patterns may use legacy web-service approaches, although REST is preferred for new application-specific work. | Martini can consume SOAP services when a legacy ACS deployment requires them, but new designs should generally use the documented REST API. |
How Alfresco Content Services exposes data and business events
Alfresco REST APIs
ACS REST APIs provide the primary application integration surface for repository discovery, nodes, folders, documents, sites, people, groups, permissions, search, metadata, relationships, and renditions. REST is generally preferred for new ACS-specific integrations.
Martini implementation pattern
Martini implementation pattern: a workflow or Martini API authenticates to ACS, calls the required endpoint, validates and transforms the response, applies business rules, and writes the result to an external application or returns a controlled response. Reusable workflow logic can standardize pagination, error classification, and audit data.
Implementation sequence
Alfresco Content and File APIs
ACS content endpoints support multipart uploads, document downloads, file metadata, folder creation, movement, copying, deletion, version-related information, and rendition retrieval. Large files require attention to request limits, timeouts, and retry behavior.
Martini implementation pattern
Martini implementation pattern: the workflow resolves the target site and folder, validates document metadata, transfers the binary content through the ACS endpoint, applies aspects and properties, and stores the resulting node ID. Downloads can be streamed or bounded where supported, with duplicate checks before creating content.
Implementation sequence
Alfresco Search APIs
ACS search capabilities support full-text and metadata queries through the REST API, subject to the configured search infrastructure. Results can be permission-filtered and may lag behind recent repository transactions because of indexing behavior.
Martini implementation pattern
Martini implementation pattern: a scheduled or on-demand workflow submits a bounded search using modified-date filters or business properties, follows result paging, retrieves current node details, and processes each item idempotently. A checkpoint and overlap window support restartable incremental synchronization.
Implementation sequence
Alfresco Repository Events
ACS repository events, listeners, and extension mechanisms can expose selected repository changes, but event availability and delivery depend on the ACS version, extension model, and deployment. They should not be treated as universal webhooks for every operation.
Martini implementation pattern
Martini implementation pattern: an ACS extension or event subsystem sends a compatible HTTP callback or intermediary message to Martini. Martini validates the notification, records an event identifier where available, retrieves current ACS state, and performs an idempotent update. Scheduled reconciliation remains a safeguard for delayed or missed events.
Implementation sequence
CMIS
ACS supports CMIS for standards-based content management access. CMIS is useful for cross-repository scenarios or existing applications that already depend on the standard, while the ACS REST API is generally more suitable for Alfresco-specific features.
Martini implementation pattern
Martini implementation pattern: a workflow consumes the required CMIS operations, maps standard content objects to an internal model, and uses REST where the integration needs ACS-specific sites, aspects, renditions, or repository capabilities.
Implementation sequence
Common Alfresco Content Services integration patterns
Pattern 1: Ingest business documents into Alfresco Content Services
When to use this pattern
Use this pattern when Salesforce, ServiceNow, SAP, or another business application creates a document that must be stored in an ACS site or folder with governed metadata. The flow should validate the request, resolve repository placement, prevent duplicates, and return a durable repository reference.
Integration direction
Example Mapping
| Alfresco Content Services Field | Canonical Field | Target Field |
|---|---|---|
| externalDocumentId | sourceDocumentId | externalId property |
| fileName | documentName | name |
| mimeType | contentType | content MIME type |
| accountId | businessReference | custom business property |
Martini implementation pattern
A Martini API receives metadata and binary content, validates required fields, resolves or creates the ACS site and folder, checks the external identifier, uploads the document, applies aspects and properties, and returns the node ID and repository URL. Validation failures are rejected without retry; transient ACS failures are retried without creating duplicate content.
Martini capabilities used
- APIs
- workflows
- API consumption
- file handling
- data mapping
- business rules
- error handling
Pattern 2: Synchronize Alfresco documents to a business application
When to use this pattern
Use this pattern when an external application needs selected ACS documents or metadata, such as contracts, invoices, case evidence, or signed agreements. Search results may be delayed, so the workflow should use checkpoints, paging, an overlap window, and periodic reconciliation.
Integration direction
Example Mapping
| Alfresco Content Services Field | Canonical Field | Target Field |
|---|---|---|
| node.id | repositoryObjectId | externalDocumentId |
| node.name | documentName | fileName |
| node.properties.cm:modified | lastModifiedAt | modifiedDate |
| node.properties.custom:businessId | businessReference | accountOrCaseReference |
Martini implementation pattern
A scheduled Martini workflow searches ACS for recently modified nodes, follows paging metadata, retrieves current node details and content when required, maps properties to the target application, and upserts using the ACS node ID or stable external identifier. The workflow records a checkpoint, classifies failures, and runs reconciliation for deleted, moved, or missed content.
Martini capabilities used
- scheduled workflows
- API consumption
- pagination
- data mapping
- idempotency
- checkpointing
- error handling
Pattern 3: Route document approvals through an external workflow
When to use this pattern
Use this pattern when a document placed in an ACS site or folder must be approved through ServiceNow, Jira, or another external process. The integration should exchange a secure repository reference and retrieve current ACS state before applying the approval result.
Integration direction
Example Mapping
| Alfresco Content Services Field | Canonical Field | Target Field |
|---|---|---|
| node.id | repositoryObjectId | documentReference |
| node.name | documentName | requestDescription |
| node.properties.cm:creator | submittedBy | requestedFor |
| approval.status | approvalOutcome | workflowState |
Martini implementation pattern
A Martini workflow receives an ACS event or finds a changed node through scheduled search, sends metadata and a controlled document reference to the external workflow, and receives an API callback or result. Martini validates the response, checks permissions and current node state, then updates ACS metadata, aspects, permissions, or folder placement. Duplicate callbacks are ignored using an event or business identifier.
Martini capabilities used
- event-driven workflows
- webhook reception
- API exposure
- data mapping
- business rules
- idempotency
- error handling
Pattern 4: Migrate content between repositories
When to use this pattern
Use this pattern for a controlled migration between ACS repositories, sites, or content structures, or between ACS and Microsoft SharePoint. It is appropriate for large document sets where restartability, source-to-target mapping, metadata fidelity, and bounded processing are more important than a single bulk request.
Integration direction
Example Mapping
| Alfresco Content Services Field | Canonical Field | Target Field |
|---|---|---|
| source.id | sourceObjectId | externalSourceId property |
| source.parentPath | sourceFolderPath | ACS folder path |
| source.file | binaryContent | document content |
| source.metadata | contentMetadata | ACS properties and aspects |
Martini implementation pattern
Martini reads source content in pages, maps the folder structure, checks the source-to-target mapping, uploads content in bounded batches, applies properties and aspects, and records each outcome. Failed items can be replayed independently, while checkpoints and mappings make the migration restartable without duplicating documents.
Martini capabilities used
- workflows
- batch orchestration
- file handling
- data mapping
- checkpointing
- business rules
- retry handling
Applications commonly integrated with Alfresco Content Services
Alfresco Content Services can be integrated with business applications that create, govern, approve, archive, or retrieve enterprise documents. These pairings generally use both systems' APIs and require explicit mapping of identifiers, metadata, permissions, versions, and document links.
| Application | Scenario | Direction | Martini Pattern |
|---|---|---|---|
| Salesforce | Store customer documents, contracts, correspondence, and case attachments in ACS while returning repository links and metadata to Salesforce. | Salesforce → Martini → Alfresco Content Services | Martini receives document metadata and binary content from Salesforce, resolves the target ACS site and folder, uploads the document, applies aspects and properties, and returns the ACS node identifier and repository URL. A reverse workflow can synchronize document links and status back to Salesforce. |
| ServiceNow | Link controlled documents to incidents, requests, knowledge processes, or case records and synchronize approval status. | ServiceNow → Martini → Alfresco Content Services | A Martini API accepts a ServiceNow document request, validates metadata, creates or locates the ACS folder, uploads content, and returns a controlled reference. ACS metadata or approval results can be sent back to ServiceNow through a separate workflow. |
| SAP | Archive invoices, purchase documents, contracts, and operational records while synchronizing business identifiers and retention metadata. | SAP → Martini → Alfresco Content Services | Martini maps SAP document identifiers and business metadata to ACS nodes, folders, and aspects, then uploads content through ACS content endpoints. It records node IDs and repository references for retrieval and reconciliation. |
| Microsoft SharePoint | Migrate or synchronize selected document libraries, metadata, and governance content between repositories. | Microsoft SharePoint → Martini → Alfresco Content Services | Martini reads SharePoint content and metadata, maps library structures to ACS sites and folders, uploads documents in bounded batches, and persists source-to-target mappings. Idempotency checks and reconciliation protect against duplicate files and incomplete migrations. |
| Microsoft 365 | Store or retrieve documents associated with Microsoft business processes and synchronize content references. | Microsoft 365 → Martini → Alfresco Content Services | A Martini workflow exchanges document metadata and content between Microsoft 365 services and ACS, separating binary transfer from metadata mapping and applying repository permissions and external identifiers before recording the result. |
| Jira | Associate specifications, release documents, evidence, or attachments with Jira issues while keeping durable content in ACS. | Jira → Martini → Alfresco Content Services | Martini receives Jira issue or attachment data, stores the document in the appropriate ACS site or folder, and sends the ACS node link and metadata back to Jira. Retry and duplicate detection use the Jira issue and attachment identifiers. |
| Workday | Store HR-related documents or generated employment records in a governed repository subject to privacy and retention requirements. | Workday → Martini → Alfresco Content Services | Martini transfers approved Workday documents to ACS, applies restricted metadata and folder placement, and returns only the required repository reference. Access and retention rules are enforced through the ACS model and permissions. |
| Adobe Sign | Store completed agreements and signature artifacts in ACS and update related business records with document references. | Adobe Sign → Martini → Alfresco Content Services | Martini receives a completed agreement notification or retrieves the signed artifact, uploads it to the designated ACS location, applies agreement metadata, and forwards the resulting node reference to the originating business application. |
How to build a Alfresco Content Services integration in Martini
Objective
Establish a secure connection to the ACS deployment and define environment-specific repository, identity-provider, and endpoint configuration.
Instructions in Martini
- Select the ACS REST or CMIS interface required by the integration.
- Configure HTTPS endpoints and repository scope.
- Store passwords, tickets, bearer tokens, and client secrets in Martini secrets or secure configuration.
- Confirm that the service identity has the required site, folder, document, and permission access.
Objective
Choose the event, API, or schedule that starts the integration and define how missed or delayed repository changes are reconciled.
Instructions in Martini
- Use a Martini API for on-demand document operations.
- Use an ACS event callback only when the deployment exposes a compatible event mechanism.
- Use a scheduler with modified-date searches for predictable incremental synchronization.
- Define a checkpoint and overlap window for long-running or event-assisted flows.
Objective
Retrieve ACS nodes, metadata, search results, renditions, or binary content in a bounded and restartable manner.
Instructions in Martini
- Call the relevant ACS REST, content, search, or CMIS operation.
- Follow paging metadata instead of assuming a single response contains all results.
- Separate metadata retrieval from binary transfer where practical.
- Persist progress and source identifiers for replay and reconciliation.
Objective
Coordinate repository calls, target-system calls, conditional routing, and asynchronous processing in a Martini workflow.
Instructions in Martini
- Validate required site, folder, node, and business identifiers.
- Resolve repository placement before uploading content.
- Route large or independent work items through bounded batches or queues where appropriate.
- Keep external calls and content operations observable and restartable.
Objective
Map Alfresco nodes, properties, aspects, sites, permissions, and content metadata into the receiving application's model.
Instructions in Martini
- Map namespace-qualified and multi-valued ACS properties explicitly.
- Convert data types and normalize timestamps, identifiers, and MIME types.
- Apply target-specific naming and metadata rules.
- Preserve node IDs, source IDs, version information, and repository URLs needed for traceability.
Objective
Enforce validation, authorization, idempotency, versioning, and content-management business rules before changing either system.
Instructions in Martini
- Check permissions and site or folder membership.
- Use stable external identifiers or node IDs rather than file names as uniqueness keys.
- Decide whether an update creates a new version or replaces existing content.
- Classify validation, authorization, conflict, and transient server errors separately.
Common Alfresco Content Services data objects used in integrations
| Object | Typical Use | Common target systems | Martini handling |
|---|---|---|---|
| Nodes | General repository objects representing folders, documents, and other content- or metadata-bearing objects. | Salesforce, ServiceNow, SAP, Microsoft SharePoint, Jira | Martini maps node IDs, names, types, parent relationships, paths, and timestamps, then uses stable identifiers for idempotency and reconciliation. |
| Documents / content | Binary files with MIME type, size, version information, and repository metadata. | Salesforce, SAP, Microsoft 365, Jira, Adobe Sign | Martini transfers binary content through ACS content endpoints, validates size or checksums where available, and processes metadata separately from the file payload. |
| Folders | Hierarchical containers for documents and other nodes within sites or repository structures. | Microsoft SharePoint, SAP, Salesforce, ServiceNow | Martini resolves or creates target folders before uploading content and records folder IDs to avoid duplicate structures. |
| Sites | Collaborative content areas containing document libraries, members, permissions, and related site data. | ServiceNow, Salesforce, Microsoft SharePoint, Microsoft 365 | Martini maps external business areas to ACS sites, validates membership and permissions, and routes content to the appropriate site and library. |
| People and groups | Repository identities, memberships, and permission administration. | Workday, ServiceNow, Microsoft 365, identity-provider services | Martini can synchronize selected identity or membership attributes through ACS APIs while applying authorization and privacy rules. |
| Aspects and properties | Extensible metadata structures that add properties and behaviors to documents and folders. | SAP, Salesforce, ServiceNow, Microsoft SharePoint | Martini maps namespace-qualified and multi-valued properties, handles optional aspects, validates data types, and protects workflows against content-model changes. |
Authentication and security considerations
Authentication options
ACS deployments may use Basic Authentication, repository authentication tickets, or OAuth 2.0-style bearer tokens through Alfresco Identity Service or an external identity provider. Exact flows depend on the ACS version and deployment architecture.
Repository authorization
Authentication does not by itself grant access to repository objects. Service identities require appropriate permissions on sites, folders, documents, groups, and other nodes.
Secure transport and secrets
- Use HTTPS for credentials, tickets, bearer tokens, metadata, and content.
- Store credentials, client secrets, and environment-specific values in Martini secure configuration.
- Validate that returned node links are accessible to the intended consumer.
- Apply least-privilege permissions and account for content classification and retention requirements.
Operational considerations for Alfresco Content Services integrations
Paging, indexing, and checkpoints
ACS list and search operations are paginated, and search results may lag behind repository transactions. Use bounded page sizes, persisted checkpoints, overlap windows, and periodic reconciliation.
Content transfer
Large files require attention to multipart limits, memory use, network timeouts, connection capacity, and content validation. Separate metadata and binary stages where practical and prevent retries from creating duplicate documents.
Idempotency and concurrency
Use stable external identifiers or ACS node IDs. Define whether updates create new versions, how concurrent changes are detected, and which system is authoritative.
Errors and change management
- Treat 401, 403, 404, 409, 413, 429, and 5xx responses differently.
- Retry transient capacity, proxy, identity, and server failures with controlled backoff.
- Protect mappings against new, removed, mandatory, or type-changed properties and aspects.
- Assume event notifications can be delayed or duplicated unless the deployment guarantees otherwise.
Why use Martini instead of scripts or point-to-point integrations?
Orchestration beyond scripts
Martini coordinates ACS API calls, content transfers, search, external applications, schedules, callbacks, and asynchronous work in maintainable workflows rather than embedding all logic in one script.
Reusable integration behavior
Mappings, validation, business rules, authentication configuration, checkpointing, and error handling can be reused across document ingestion, synchronization, approval, and migration processes.
Controlled APIs and operational visibility
Martini can expose business-specific APIs over ACS, keep repository details behind a controlled contract, and provide structured logging and operational handling for retries, replay, and troubleshooting.
- Separate vendor capabilities from integration logic.
- Support REST, CMIS, files, schedules, and compatible event endpoints in one workflow design.
- Handle paging, idempotency, permissions, schema changes, and reconciliation consistently.
Frequently asked questions
ACS can be integrated primarily through its REST APIs for nodes, folders, documents, sites, people, groups, permissions, search, metadata, and renditions. Content endpoints support file uploads and downloads, CMIS provides a standards-based option, and selected deployments can expose repository events through extensions or external event infrastructure.
Yes. Martini can consume the ACS REST API, upload and download content, search repository data, map nodes and aspects, orchestrate synchronization workflows, and expose controlled APIs. Martini can also receive compatible event notifications when the ACS deployment provides an outbound HTTP or intermediary mechanism.
No. A dedicated Alfresco Content Services connector is not required. Martini can use ACS's confirmed native integration mechanisms, including REST APIs, content endpoints, CMIS where appropriate, configured authentication methods, and deployment-dependent event notifications.
Lonti does not charge an additional per-connector or per-vendor fee to integrate Alfresco Content Services. The integration is subject to the provisioned capacity of the Martini environment. Separate costs may apply from Alfresco, identity providers, cloud infrastructure, storage, or other third-party systems depending on subscriptions, usage, and deployment architecture.
The ACS REST API should generally be the primary choice for new application-specific integrations because it covers repository, content, search, site, identity, and metadata operations. CMIS is useful for standards-based or cross-repository scenarios, while legacy SOAP approaches should normally be retained only where required by an existing deployment.
Not as a universal webhook facility for every repository operation. ACS repository events and extension mechanisms can expose selected changes, but coverage and delivery depend on the version and deployment. A reliable design commonly combines event processing with scheduled search-based reconciliation.
Use stable node IDs, external document identifiers, business IDs, or source checksums rather than file names alone. Martini can map namespace-qualified properties, aspects, versions, MIME types, and folder relationships, then use checkpoints, paging, overlap windows, and upsert rules to support incremental synchronization.
Yes. Martini can expose a REST API that accepts a business-level request, validates it, calls ACS, maps the result, and returns a controlled response. This allows consumers to use a purpose-built contract without exposing the full ACS repository API.
Related Martini documentation
Workflows
Events
Operations
Integrate Alfresco Content Services with Martini
Use Martini to build governed, restartable integrations between Alfresco Content Services and the applications that create, approve, archive, and consume enterprise content.