.png)
Laserfiche Integration Guide
Connect Laserfiche Cloud repositories, documents, metadata, and process automation with enterprise systems through REST APIs, document-content transfers, OAuth 2.0, and selected event notifications.
Laserfiche integration options at a glance
Laserfiche Cloud integrations primarily use REST APIs to search repositories, manage folders and documents, transfer document content, and read or update metadata. OAuth 2.0, application authorization, repository permissions, and resource permissions control access. Document files can be uploaded or downloaded through supported repository endpoints. Selected Laserfiche services may provide webhook-style event notifications, although coverage is service- and event-specific and should be verified before implementation. Batch or asynchronous behavior may be available for selected operations. Martini can consume these APIs, expose callback endpoints, schedule polling workflows, transform JSON and file content, apply validation and business rules, and coordinate Laserfiche with enterprise applications.
| Integration point | Supported by Laserfiche? | Common use cases | How Martini supports it |
|---|---|---|---|
| REST APIs | Yes | Laserfiche Cloud REST APIs support repository, folder, document, search, metadata, template, and selected process automation operations. | Martini can consume Laserfiche REST endpoints from workflows, transform responses, apply business rules, and expose APIs that coordinate Laserfiche with other systems. |
| File / document content APIs | Yes | Supported repository APIs can upload, download, and process document content, subject to endpoint, file-size, type, and permission constraints. | Martini can transfer binary content separately from metadata, validate MIME types, map filenames and fields, and coordinate document movement between systems. |
| Authentication | Yes | Laserfiche Cloud uses OAuth 2.0 and application authorization, with access further controlled by user, repository, folder, document, field, template, and process permissions. | Martini can store OAuth client credentials and tokens in secrets or environment configuration, request scoped access, and handle token refresh and authorization failures. |
| Webhooks / outbound callbacks | Limited | Selected Laserfiche services and events may provide notifications, but coverage is not universal and must be verified for the target API and tenant. | Martini can expose an API endpoint to receive supported callbacks, validate notifications, deduplicate them, and start a workflow; polling can cover unsupported events. |
| Bulk / async / batch APIs | Limited | Batch or asynchronous behavior may be available for selected Laserfiche operations. Job status, partial failures, and retry behavior are endpoint-specific. | Martini can orchestrate submission and status-check workflows, persist checkpoints, throttle throughput, and route partial failures for recovery. |
| Scheduled synchronization | Yes | Scheduled API polling can detect document, metadata, or process changes when the required event notification is unavailable. | Martini can run scheduled workflows with timestamps, versions, continuation tokens, overlapping windows, and stored watermarks where supported. |
| SOAP APIs | Legacy | Older Laserfiche products or SDKs may expose service-based integration options, but REST APIs are preferred for new Cloud integrations. | Martini can consume SOAP services when a product-specific legacy endpoint is confirmed, while keeping the integration isolated and migration-ready. |
| Database / analytics access | No | Direct access to internal Laserfiche databases was not confirmed as a supported public integration mechanism. | Martini should use documented Laserfiche APIs rather than direct database access. |
How Laserfiche exposes data and business events
Laserfiche REST APIs
Laserfiche REST APIs are the primary integration mechanism for Cloud services. They can locate repositories, folders, and documents; create folders; upload and download content; search repository content; read and update metadata; apply templates and fields; and interact with selected process automation functions.
Martini implementation pattern
Martini implementation pattern: a workflow authenticates with OAuth 2.0, calls the required Laserfiche endpoints, handles pagination and response validation, transforms Laserfiche JSON into a canonical model, and writes the result to an enterprise target or returns it through a Martini API.
Implementation sequence
Laserfiche document content APIs
Laserfiche repository APIs support document-content transfers such as uploading a file as a new Document, downloading content, and updating content or versions where the endpoint permits it. File type, size, and permission constraints apply.
Martini implementation pattern
Martini implementation pattern: the workflow separates binary content from JSON metadata, validates the file and source correlation key, resolves the target Folder and Template, uploads or downloads content, and records the Laserfiche Document identifier for idempotency.
Implementation sequence
Laserfiche webhook-style notifications
Laserfiche may provide event notifications for selected services and use cases, but notification coverage is service- and event-specific. Repository operations, metadata changes, and process state changes should not be assumed to generate notifications universally.
Martini implementation pattern
Martini implementation pattern: expose a secured API endpoint for a confirmed callback, validate the notification and correlation data, retrieve the current Laserfiche resource rather than trusting a partial payload, and make downstream actions repeat-safe. Use scheduled polling when the required event is unavailable.
Implementation sequence
Laserfiche scheduled synchronization
Scheduled polling is an alternative when the required Laserfiche event is unavailable. A workflow can search for changes using a timestamp, version, continuation token, or other endpoint-supported change-tracking value.
Martini implementation pattern
Martini implementation pattern: a scheduler starts a workflow that reads the last successful watermark, queries Laserfiche with server-side filters, processes each page, persists successful identifiers, and advances the watermark only after downstream writes complete.
Implementation sequence
Laserfiche batch or asynchronous operations
Selected Laserfiche operations may support batch or asynchronous behavior. Availability, job status, partial-failure reporting, and retry safety must be confirmed for each endpoint.
Martini implementation pattern
Martini implementation pattern: submit the confirmed batch operation, store its job or correlation identifier, poll status with bounded intervals, process successful and failed items separately, and avoid repeating non-idempotent actions without a deduplication strategy.
Implementation sequence
Common Laserfiche integration patterns
Pattern 1: Capture approved documents in Laserfiche
When to use this pattern
Use this pattern when a business application produces a signed, approved, or generated document that must be retained in a structured Laserfiche repository with searchable business metadata.
Integration direction
Example Mapping
| Laserfiche Field | Canonical Field | Target Field |
|---|---|---|
| sourceDocumentId | sourceDocumentId | Laserfiche Field: Source Document ID |
| documentType | documentType | Laserfiche Template |
| customerId | customerId | Laserfiche Field: Customer ID |
| approvedAt | approvedAt | Laserfiche Field: Approval Date |
Martini implementation pattern
A Martini API receives the file and metadata, validates identifiers and document type, checks for an existing source correlation key, locates or creates the destination Folder, uploads the content, applies the Template and Fields, and returns the Laserfiche Document identifier. Validation failures are rejected immediately; transient API failures are retried and non-idempotent uploads are protected against duplication.
Martini capabilities used
- APIs
- workflows
- OAuth 2.0 authentication
- file handling
- data mapping
- business rules
- error handling
Pattern 2: Synchronize Laserfiche documents with Salesforce
When to use this pattern
Use this pattern when Laserfiche is the governed content repository and Salesforce needs document references, or when Salesforce-generated contracts and account documents must be archived in Laserfiche.
Integration direction
Example Mapping
| Laserfiche Field | Canonical Field | Target Field |
|---|---|---|
| Document.id | documentId | Salesforce ContentDocument or related file reference |
| Document.name | fileName | Salesforce Title |
| Fields.customerId | accountId | Salesforce Account |
| Document.version | contentVersion | Salesforce version or correlation metadata |
Martini implementation pattern
A scheduled Martini workflow searches Laserfiche for changed Documents, follows pagination, maps Fields to Salesforce identifiers, and creates or updates the supported Salesforce document reference. The reverse flow retrieves Salesforce content and archives it in Laserfiche. Watermarks, source identifiers, and repeat-safe writes prevent duplicates; permission and rate-limit failures follow separate recovery paths.
Martini capabilities used
- scheduled workflows
- API consumption
- pagination and checkpoints
- data mapping
- business rules
- idempotency
- retry handling
Pattern 3: Archive ServiceNow case documents
When to use this pattern
Use this pattern when incidents, requests, or cases reach a defined state and their attachments and metadata must be stored in Laserfiche under consistent folder, template, and retention rules.
Integration direction
Example Mapping
| Laserfiche Field | Canonical Field | Target Field |
|---|---|---|
| number | caseNumber | Laserfiche Field: Case Number |
| short_description | documentDescription | Laserfiche Field: Description |
| attachment.content | documentContent | Laserfiche Document content |
| state | caseState | Laserfiche Field: Source State |
Martini implementation pattern
Martini receives a ServiceNow event or polls eligible cases, retrieves attachment content, validates the case state and file type, resolves the Laserfiche Folder, uploads the Document, applies the appropriate Template and Fields, and writes the Laserfiche identifier back to ServiceNow. Duplicate prevention uses the case and attachment identifiers; transient failures are retried with bounded backoff.
Martini capabilities used
- event-driven workflows
- scheduled polling
- file transfer
- data transformation
- validation
- correlation and idempotency
- error routing
Pattern 4: Route Laserfiche process outcomes downstream
When to use this pattern
Use this pattern when a Laserfiche process or approval produces an approved, rejected, or completed outcome that must update an ERP, CRM, HR, or case-management application.
Integration direction
Example Mapping
| Laserfiche Field | Canonical Field | Target Field |
|---|---|---|
| processId | processId | Target workflow or transaction ID |
| processStatus | status | Target approval status |
| documentId | documentReference | Target document reference |
| completedAt | completedAt | Target completion timestamp |
Martini implementation pattern
Where a supported callback exists, Martini receives the notification and retrieves the current process or Document state. Otherwise, a scheduled workflow polls using a stored watermark. Martini applies outcome-specific rules, updates the downstream system, records the Laserfiche identifiers, and routes permission, validation, and transient failures independently.
Martini capabilities used
- webhook reception
- scheduled workflows
- API orchestration
- state mapping
- business rules
- checkpointing
- monitoring and retries
Applications commonly integrated with Laserfiche
Laserfiche commonly participates in enterprise content, retention, process, and document-archiving architectures. The following applications can be integrated with Laserfiche using their respective APIs and supported Laserfiche endpoints; these are not claims of native Laserfiche integrations.
| Application | Scenario | Direction | Martini Pattern |
|---|---|---|---|
| Salesforce | Archive contracts, customer correspondence, case documents, and account files in Laserfiche while returning document references to Salesforce. | Salesforce → Martini → Laserfiche | Martini receives Salesforce data or retrieves it through the Salesforce API, validates the business identifier, locates or creates the Laserfiche folder, uploads the document, applies the required template and fields, and returns the Laserfiche identifier. A reverse workflow can retrieve Laserfiche content for Salesforce where the target API supports it. |
| ServiceNow | Archive incident, request, case, and attachment content in Laserfiche and make governed document references available to service users. | ServiceNow → Martini → Laserfiche | A ServiceNow event, API request, or scheduled workflow starts Martini. Martini retrieves attachments and case metadata, validates retention and classification rules, uploads content to the appropriate repository folder, and writes the Laserfiche document identifier back to ServiceNow. |
| Microsoft SharePoint | Transfer or consolidate documents between collaboration repositories and Laserfiche for governance, retention, or repository ownership requirements. | Microsoft SharePoint → Martini → Laserfiche | Martini retrieves SharePoint documents and metadata through the available SharePoint API, maps classification fields to Laserfiche templates and fields, transfers the file, and records a correlation key to support repeat-safe synchronization. |
| NetSuite | Archive invoices, purchase documents, vendor records, and financial correspondence with transaction identifiers and document metadata. | NetSuite → Martini → Laserfiche | Martini receives or polls NetSuite transactions, validates the transaction and document type, resolves the target Laserfiche folder, uploads the content, applies metadata, and routes permission or validation failures for review. |
| Workday | Store employee documents, HR forms, and completed personnel records in Laserfiche under controlled access and retention policies. | Workday → Martini → Laserfiche | Martini retrieves approved Workday documents, minimizes sensitive fields, applies HR-specific business rules, uploads content to the correct repository structure, and records the source employee or transaction identifier without exposing secrets in workflow data. |
| SAP S/4HANA | Archive invoices, orders, shipping documents, and transaction-related content in a governed repository. | SAP S/4HANA → Martini → Laserfiche | Martini orchestrates SAP API calls and Laserfiche REST operations, transforms transaction metadata into template fields, transfers binary content separately from JSON metadata, and retries transient failures without duplicating non-idempotent uploads. |
| Adobe Acrobat Sign | Store completed agreements and signature metadata in Laserfiche for centralized retention and retrieval. | Adobe Acrobat Sign → Martini → Laserfiche | Martini receives or retrieves completed agreement data, verifies the signing status, downloads the signed file, maps agreement metadata to Laserfiche fields, and uploads it using a deterministic agreement correlation key. |
| Jira | Archive project approvals, technical documents, or issue attachments when formal retention or enterprise content governance is required. | Jira → Martini → Laserfiche | Martini retrieves eligible Jira issue attachments and metadata, applies project and issue business rules, transfers files to the appropriate Laserfiche folder, and stores the source issue key to prevent duplicate archival. |
How to build a Laserfiche integration in Martini
Objective
Establish a controlled connection to Laserfiche Cloud and the required adjacent systems.
Instructions in Martini
- Register or configure the Laserfiche application and required OAuth 2.0 scopes.
- Store client credentials, tokens, repository identifiers, and environment values in Martini secrets or configuration.
- Confirm repository, folder, document, field, template, and process permissions for the service identity.
Objective
Select an event-driven, API-led, or scheduled entry point based on confirmed Laserfiche capabilities.
Instructions in Martini
- Use a Martini API for inbound document submissions or confirmed Laserfiche callbacks.
- Use a scheduled trigger when the required repository or process event is not available.
- Define the polling watermark, version, continuation token, or other supported change-tracking value.
Objective
Retrieve current Laserfiche resources and document content in a way that supports pagination and large files.
Instructions in Martini
- Call the required REST endpoints and follow page or continuation information.
- Separate binary document transfer from JSON metadata processing.
- Persist source identifiers and checkpoints only after successful processing.
Objective
Coordinate Laserfiche operations with validation, enrichment, target-system calls, and recovery paths.
Instructions in Martini
- Resolve repositories, folders, templates, and fields before writing content.
- Use conditional routing for approved, rejected, missing, or unauthorized resources.
- Separate validation, permission, rate-limit, transient network, and permanent API failures.
Objective
Transform Laserfiche Documents, Fields, Templates, and process outcomes into the target system model.
Instructions in Martini
- Create explicit mappings for required metadata and identifiers.
- Normalize filenames, MIME types, dates, enumerations, and source correlation keys.
- Validate required fields and allowed values before upload or downstream writes.
Objective
Apply business, retention, classification, and duplicate-prevention rules before changing either system.
Instructions in Martini
- Check whether a source identifier or document version has already been processed.
- Route sensitive HR, legal, and financial content according to access and retention rules.
- Use deterministic folder and template selection rather than arbitrary metadata pass-through.
Common Laserfiche data objects used in integrations
| Object | Typical Use | Common target systems | Martini handling |
|---|---|---|---|
| Repositories | Identify the Laserfiche content repository that contains folders, documents, and metadata. | Salesforce, ServiceNow, SAP S/4HANA, SharePoint | Martini resolves repository identifiers from configuration or API discovery and validates access before processing content. |
| Documents | Represent stored electronic documents, including content, pages, versions, and metadata. | Salesforce, ServiceNow, NetSuite, Workday, SAP S/4HANA | Martini searches, creates, downloads, updates where supported, and correlates Documents with source-system identifiers. |
| Folders | Organize Documents and other Folders in a repository hierarchy. | Salesforce, ServiceNow, SharePoint, ERP platforms | Martini locates or creates the target Folder, applies deterministic routing rules, and records identifiers for repeat-safe processing. |
| Fields | Store metadata values associated with Documents or Folders. | Salesforce, ServiceNow, NetSuite, Workday | Martini validates, transforms, and maps source attributes to required Laserfiche Fields before upload or update. |
| Templates | Group Fields and describe document types for consistent classification. | Salesforce, ServiceNow, HR and finance applications | Martini selects Templates using document-type and business rules, then validates required Fields and allowed values. |
| Processes / workflows | Represent automated business processes and process outcomes that may be initiated or monitored through supported capabilities. | ERP, CRM, HR, and case-management applications | Martini invokes or polls supported process operations, maps outcomes, and routes approved, rejected, or completed states downstream. |
Authentication and security considerations
OAuth 2.0 and application authorization
Laserfiche Cloud integrations use OAuth 2.0, application authorization, and scopes. Store client IDs, client secrets, access tokens, and refresh tokens in Martini secrets or environment configuration rather than workflow source.
Repository and resource permissions
Authentication does not by itself grant access to content. The authenticated identity must have the required repository, folder, document, field, template, and process permissions.
Environment separation
Keep tenant, repository, API environment, scopes, and service identities configurable between development, test, and production. Request only the access required by each workflow.
Operational considerations for Laserfiche integrations
Throughput and pagination
Confirm Laserfiche rate limits, quotas, upload limits, file-size restrictions, pagination behavior, and endpoint-specific asynchronous processing. Use server-side filters, bounded concurrency, throttling, and persisted checkpoints for large synchronizations.
Idempotency and files
Use a source document ID, transaction and document-type combination, or deterministic correlation key to prevent duplicate uploads. Validate MIME types, filenames, encoding, temporary storage, and content inspection requirements before transfer.
Schema and event changes
Treat Laserfiche Templates and Fields as an integration contract. Validate required fields and allowed values, and do not assume all repository or process events produce notifications. Make callback handling repeat-safe and use polling when necessary.
Monitoring and recovery
Log repository, folder, document, source-system, HTTP status, correlation, retry, and process identifiers. Route authentication, permission, rate-limit, transient, and permanent errors to distinct recovery paths.
Why use Martini instead of scripts or point-to-point integrations?
Reusable orchestration
Scripts often combine authentication, pagination, file transfer, mapping, retries, and business rules in one code path. Martini separates these concerns into reusable workflows and APIs that can coordinate Laserfiche with multiple enterprise systems.
Controlled transformation
Martini provides explicit mapping, validation, conditional routing, and custom logic where needed. This supports consistent handling of Laserfiche Documents, Fields, Templates, content, and process outcomes across integrations.
Operational reliability
Centralized workflow error handling, checkpoints, logging, scheduling, and callback processing make it easier to monitor synchronization, recover transient failures, and evolve integrations as Laserfiche schemas or target applications change.
Frequently asked questions
Laserfiche can be integrated primarily through its Cloud REST APIs for repositories, folders, Documents, metadata, Templates, Fields, document content, and selected process automation functions. OAuth 2.0 controls API access, while selected services may provide event notifications. Scheduled API polling is an alternative when the required event is unavailable.
Yes. Martini can integrate with Laserfiche by consuming its REST APIs, authenticating with OAuth 2.0, transferring document content, mapping repository metadata, exposing APIs for inbound submissions or supported callbacks, and orchestrating Laserfiche with enterprise applications.
No. A dedicated Laserfiche connector is not required. Martini can use Laserfiche's confirmed native integration mechanisms, including REST APIs, OAuth 2.0, document-content endpoints, selected callbacks, and scheduled API polling.
Lonti does not charge an additional per-connector or per-vendor fee to integrate Laserfiche. The integration is subject to the provisioned capacity of the Martini environment. Separate costs may apply from Laserfiche, cloud infrastructure, or other third-party systems depending on subscription, usage, and deployment model.
REST APIs, document-content APIs, and OAuth 2.0 are the preferred mechanisms for new Laserfiche Cloud integrations. Selected webhook-style notifications can support event-driven designs after service-specific verification. Legacy SOAP options should be considered only when a product-specific endpoint is confirmed.
Laserfiche provides event-notification capabilities for selected services and use cases, but coverage is not universal. Verify the product, event type, payload, retry behavior, and tenant configuration. Martini can receive confirmed callbacks; otherwise, a scheduled workflow can poll Laserfiche for changes.
Martini can retrieve paginated Laserfiche results, transfer document content separately from JSON metadata, map Documents, Fields, Templates, and folder identifiers to a canonical model, and write to target systems. Watermarks, versions, continuation tokens, and deterministic source identifiers can support incremental and repeat-safe synchronization.
Martini can separate validation, authentication, permission, rate-limit, transient network, and permanent API failures. Workflows can retry transient failures with bounded backoff, persist checkpoints, and use source document IDs, transaction keys, or Laserfiche Fields to detect duplicates before non-idempotent uploads.
Related Martini documentation
Mapping
Operations
Connect Laserfiche with your enterprise systems
Use Martini to build maintainable Laserfiche integrations for document transfer, metadata synchronization, process outcomes, and governed content workflows.