.png)
Stampli Integration Guide
Integrate Stampli’s accounts payable workflows with ERP and accounting systems through confirmed APIs, scheduled synchronization, and customer-specific callbacks.
Stampli integration options at a glance
Stampli integrations are primarily designed to connect accounts payable processes with ERP and accounting platforms. Stampli supports enterprise integrations through application APIs, although the precise REST API surface and object coverage should be confirmed for each tenant. Customer-specific credentials and authentication requirements must also be verified. If Stampli provides webhook-style callbacks, Martini can expose an endpoint and start workflows from supported notifications; otherwise, scheduled polling can retrieve changed invoices, vendors, purchase orders, approvals, or payment information. Attachment operations, bulk processing, and asynchronous APIs are not publicly confirmed, so Martini workflows should use documented pagination, filtering, validation, retries, and idempotent updates.
| Integration point | Supported by Stampli? | Common use cases | How Martini supports it |
|---|---|---|---|
| REST APIs | Limited | Stampli is commonly integrated with ERP and accounting platforms through application APIs. The available operations and object coverage must be confirmed for the customer’s tenant. | Martini can consume a confirmed Stampli REST API, configure authentication, transform JSON payloads, apply business rules, and expose APIs for downstream systems. |
| Webhooks and outbound callbacks | Not confirmed | A comprehensive public Stampli webhook catalog was not verified. Customer-specific callbacks may be available for selected invoice, approval, vendor, purchase-order, or payment events. | If callbacks are supplied, Martini can expose a REST endpoint, validate the notification, retrieve current Stampli data, and start a workflow. Scheduled polling remains the fallback. |
| Bulk or asynchronous APIs | Not confirmed | Bulk and asynchronous processing behavior was not verified. Large synchronizations should be based on documented pagination, filtering, and rate limits rather than an assumed bulk endpoint. | Martini can orchestrate batched workflow executions, checkpoints, retries, and reconciliation when the confirmed Stampli API supports those request patterns. |
| File and attachment APIs | Limited | Invoices may include supporting documents, but public Stampli attachment operations were not verified. Confirm whether files are returned as binary content, URLs, or metadata. | Martini can process supported file or URL-based exchanges, map document metadata, and apply size, type, security, and duplicate-handling rules. |
| Authentication | Limited | Stampli integration credentials are required, but the precise public scheme was not verified. API keys, bearer tokens, OAuth 2.0, scopes, and tenant-specific headers must be confirmed. | Martini can store confirmed credentials in secrets and environment configuration and apply the required authentication to API requests without embedding credentials in workflows. |
| Scheduled synchronization | Yes | Polling can retrieve invoices, vendors, purchase orders, approvals, or payment information changed since a prior synchronization when callbacks are unavailable or incomplete. | Martini can trigger workflows on a schedule, maintain a watermark, use overlapping time windows, and reconcile results with idempotent writes. |
| Database access | No | Direct access to Stampli-managed customer data is not presented as a supported integration method. | Martini should use Stampli-approved APIs, callbacks, file exchange, or vendor-supported integration services rather than direct database access. |
| SDKs | Not confirmed | A vendor-maintained public Stampli SDK was not verified. Direct HTTP API consumption should be planned around confirmed documentation. | Martini can consume documented HTTP APIs directly and does not require a vendor SDK to orchestrate the integration. |
How Stampli exposes data and business events
Stampli REST APIs
Stampli is commonly integrated with ERP and accounting platforms through application APIs. The exact public API surface, object coverage, identifiers, filters, pagination model, and write operations should be confirmed for each tenant.
Martini implementation pattern
Martini implementation pattern: Martini stores the confirmed Stampli base URL and credentials in environment configuration, invokes the required API from a workflow, validates the response, maps Stampli objects to a canonical model, applies business rules, and writes to the target application. The workflow records a watermark or correlation reference for reconciliation.
Implementation sequence
Scheduled Stampli synchronization
Scheduled polling is the principal fallback when Stampli callbacks are unavailable or do not cover the required invoice, vendor, purchase-order, approval, or payment event.
Martini implementation pattern
Martini implementation pattern: a scheduler starts a workflow that queries documented modified-date or status filters, uses pagination, processes each object idempotently, and advances the watermark only after successful target processing. Overlapping windows and reconciliation help account for changes during a run.
Implementation sequence
Stampli webhook-style callbacks
A public, comprehensive Stampli webhook catalog was not verified. A customer account may nevertheless provide callback notifications for selected events, which must be confirmed before designing a real-time flow.
Martini implementation pattern
Martini implementation pattern: Martini exposes a controlled REST endpoint for the confirmed callback, authenticates and validates the notification, retrieves the current Stampli resource when possible, and invokes downstream processing. A scheduled reconciliation workflow remains necessary when event coverage is partial.
Implementation sequence
Stampli file and attachment exchange
Invoice documents are central to Stampli workflows, but public attachment API operations were not verified. Confirm whether documents can be downloaded or uploaded and whether responses contain binary content, temporary URLs, or metadata.
Martini implementation pattern
Martini implementation pattern: when supported, Martini retrieves the document or URL alongside invoice metadata, applies file validation and security controls, and delivers it to the target system without exposing sensitive contents in logs. If attachment operations are unavailable, the workflow transfers metadata only.
Implementation sequence
Common Stampli integration patterns
Pattern 1: Synchronize Stampli invoices to an ERP
When to use this pattern
Use this pattern when approved or changed Stampli invoices must be posted or reconciled in an ERP such as NetSuite, SAP S/4HANA, or Microsoft Dynamics 365 Finance. It supports incremental processing without assuming that approval and payment are the same state.
Integration direction
Example Mapping
| Stampli Field | Canonical Field | Target Field |
|---|---|---|
| invoiceId | externalInvoiceId | externalReference |
| vendorId | supplierExternalId | vendor |
| amount | grossAmount | total |
| approvalStatus | approvalState | approvalStatus |
Martini implementation pattern
A scheduled Martini workflow retrieves changed invoices using documented filters and pagination, applies a time overlap around the stored watermark, validates vendor and purchase-order references, and maps the invoice to the ERP model. It uses stable external identifiers, distinguishes approval from posting and payment status, retries transient failures, and routes validation or authorization errors to an exception process.
Martini capabilities used
- workflows
- scheduled triggers
- API consumption
- data mapping
- business rules
- error handling
Pattern 2: Synchronize ERP vendors and purchase orders to Stampli
When to use this pattern
Use this pattern when Stampli requires current supplier and purchase-order reference data for invoice matching, supplier onboarding, or coding consistency. The exact create and update operations must be confirmed in the Stampli tenant API.
Integration direction
Example Mapping
| Stampli Field | Canonical Field | Target Field |
|---|---|---|
| supplierNumber | supplierExternalId | vendorId |
| supplierName | supplierName | name |
| purchaseOrderNumber | purchaseOrderExternalId | purchaseOrderNumber |
| purchaseOrderTotal | orderTotal | amount |
Martini implementation pattern
Martini retrieves modified vendors and purchase orders from the ERP, validates required identifiers and fields, applies deterministic matching, and submits only supported Stampli operations. The workflow preserves source IDs, prevents duplicate creation after timeouts, records correlation IDs, and sends rejected records to a review queue or operational exception path.
Martini capabilities used
- workflows
- API consumption
- data mapping
- validation
- business rules
- retry handling
Pattern 3: Propagate Stampli approval outcomes
When to use this pattern
Use this pattern when procurement, finance, or ERP systems need invoice approval, rejection, hold, or review outcomes from Stampli. It can be event-driven only where the customer’s Stampli configuration exposes the required callback events.
Integration direction
Example Mapping
| Stampli Field | Canonical Field | Target Field |
|---|---|---|
| invoiceId | invoiceExternalId | invoiceNumber |
| approvalStatus | approvalState | workflowStatus |
| approvalDecisionDate | decisionTimestamp | approvalDate |
| exceptionReason | reviewReason | holdReason |
Martini implementation pattern
Martini receives a supported callback or polls for changed approvals, retrieves current invoice details when necessary, and maps the outcome to the target workflow state. Business rules distinguish rejected, held, approved, posted, and paid states. The workflow acknowledges notifications safely, retries downstream writes, and runs reconciliation for missed or incomplete events.
Martini capabilities used
- API exposure
- webhook consumption
- scheduled workflows
- data mapping
- conditional routing
- error handling
Pattern 4: Export approved invoices and documents
When to use this pattern
Use this pattern when approved Stampli invoice data and, where supported, invoice documents must be delivered to an accounting or records process. Attachment availability and permissions must be confirmed before including files in the design.
Integration direction
Example Mapping
| Stampli Field | Canonical Field | Target Field |
|---|---|---|
| invoiceId | invoiceExternalId | invoiceReference |
| invoiceDocument | documentContent | attachment |
| coding | accountingDimensions | distributionLines |
| paymentStatus | settlementState | paymentStatus |
Martini implementation pattern
Martini retrieves approved invoice data and conditionally retrieves its document through the confirmed attachment operation. It validates file type and size, transforms accounting dimensions, submits the target payload, and maintains an external-reference mapping. Missing documents, expired URLs, duplicate files, and downstream failures are handled separately from invoice data errors.
Martini capabilities used
- workflows
- API consumption
- file handling
- data mapping
- validation
- error handling
Applications commonly integrated with Stampli
Stampli typically sits alongside an organization’s ERP, accounting, procurement, or financial management platform. The applications below are realistic integration targets based on Stampli’s accounts payable role and common enterprise architecture patterns; the exact endpoints, packaging, and commercial availability should be confirmed with Stampli and the adjacent application vendor.
| Application | Scenario | Direction | Martini Pattern |
|---|---|---|---|
| NetSuite | Synchronize vendors, purchase orders, invoices, approval outcomes, coding, and payment information between Stampli and the ERP. | NetSuite → Martini → Stampli | Use scheduled or customer-supported event-driven workflows to retrieve NetSuite master data, validate vendor and purchase-order references, transform the payload to Stampli’s documented model, and reconcile invoice and approval status back to NetSuite using stable external identifiers. |
| SAP S/4HANA | Connect accounts payable invoice processing and approval outcomes with SAP financial accounting and procurement data. | SAP S/4HANA → Martini → Stampli | Orchestrate bidirectional API workflows that exchange supplier, purchase-order, invoice, coding, and status data, with validation, correlation IDs, bounded retries, and exception routing for rejected or held invoices. |
| Microsoft Dynamics 365 Finance | Exchange vendor, purchase-order, invoice, coding, approval, and payment-status information with the finance platform. | Microsoft Dynamics 365 Finance → Martini → Stampli | Use Martini to consume the documented APIs available in each environment, map fields between the two financial models, apply deterministic vendor matching, and preserve source identifiers to prevent duplicate invoice creation. |
| Oracle Fusion Cloud ERP | Synchronize supplier and purchasing data with invoice approval, posting, and payment-related information. | Oracle Fusion Cloud ERP → Martini → Stampli | Build reusable workflows for supplier and purchase-order reference data, incremental invoice synchronization, status propagation, and reconciliation. Keep attachment processing conditional on Stampli’s confirmed document operations. |
| Sage Intacct | Transfer invoices, vendors, account codes, and approval or payment status for accounting operations. | Sage Intacct → Martini → Stampli | Map Stampli invoice and vendor objects to Sage Intacct’s documented API model, validate required accounting dimensions before submission, and retry transient failures without advancing the synchronization watermark prematurely. |
| QuickBooks Online | Send approved invoice and vendor data to accounting and return posting or payment status where supported. | Stampli → Martini → QuickBooks Online | Poll or receive supported Stampli changes, transform approved invoice data for QuickBooks Online, store external references, and route unsupported status transitions or document operations to an exception workflow. |
| Coupa | Coordinate purchase orders, supplier data, invoices, and procure-to-pay status across procurement and accounts payable processes. | Coupa → Martini → Stampli | Use Martini workflows to reconcile purchase-order and supplier identifiers, map invoice and approval states, apply matching rules, and maintain a compensating or reconciliation path when either platform reports an exception. |
| Workday Financial Management | Exchange supplier, invoice, accounting, and payment information with a financial management platform. | Workday Financial Management → Martini → Stampli | Expose controlled Martini APIs or consume vendor APIs as appropriate, normalize financial payloads, validate required dimensions and status values, and process incremental updates with correlation and operational monitoring. |
How to build a Stampli integration in Martini
Objective
Establish the Stampli integration boundary and confirm the tenant-specific API, callback, file, and authentication capabilities before implementation.
Instructions in Martini
- Obtain Stampli’s applicable API or integration documentation and credentials
- Confirm the base URL, tenant headers, permissions, object coverage, and supported operations
- Store credentials and environment-specific values in Martini secrets and configuration
- Define target-system credentials and external identifier strategy
Objective
Select a trigger that matches the confirmed Stampli capabilities and the required freshness of the integration.
Instructions in Martini
- Use a Stampli callback only when the required event type and security model are confirmed
- Use a scheduler for incremental polling when callbacks are unavailable or incomplete
- Define polling filters, pagination behavior, overlap windows, and reconciliation frequency
- Use a controlled API endpoint when another system must initiate processing
Objective
Retrieve current Stampli objects and related details without assuming unsupported bulk, attachment, or event capabilities.
Instructions in Martini
- Call documented Stampli endpoints with the configured authentication method
- Process pagination or continuation tokens according to tenant documentation
- Retrieve current resources after callback notifications where required
- Persist watermarks and correlation identifiers outside individual request payloads
Objective
Implement the end-to-end Martini workflow that coordinates Stampli, target systems, validation, and exception handling.
Instructions in Martini
- Separate invoice, vendor, purchase-order, approval, payment, and user processing as appropriate
- Apply conditional routing for approved, rejected, held, posted, and paid states
- Use reusable workflow logic for common authentication, mapping, and reconciliation behavior
- Keep attachment handling conditional on confirmed Stampli operations
Objective
Transform Stampli payloads into canonical and target-specific financial models while preserving traceability.
Instructions in Martini
- Map stable Stampli and source-system identifiers
- Validate required fields, status values, dates, amounts, and accounting dimensions
- Apply deterministic vendor and purchase-order matching rules
- Preserve source references and correlation IDs across writes
Objective
Create or update the receiving ERP, accounting, procurement, or reporting system safely and idempotently.
Instructions in Martini
- Use external references to avoid duplicate invoices and vendors
- Distinguish approval, posting, payment, and exception states
- Use idempotency keys when the target or Stampli API supports them
- Do not advance the watermark until the required target operation succeeds
Common Stampli data objects used in integrations
| Object | Typical Use | Common target systems | Martini handling |
|---|---|---|---|
| Invoices | Exchange supplier invoice metadata, amounts, coding, approval status, payment status, and related references. | NetSuite, SAP S/4HANA, Microsoft Dynamics 365 Finance, Oracle Fusion Cloud ERP, Sage Intacct | Martini retrieves or receives supported invoice changes, validates required fields, maps financial data, applies status rules, and writes idempotently using Stampli and source-system identifiers. |
| Vendors | Synchronize supplier master data and stable vendor identifiers used for invoice matching. | ERP, accounting, procurement, and financial management applications | Martini applies deterministic matching using documented IDs, tax identifiers, or supplier numbers rather than names alone, then creates or updates only when the confirmed API permits it. |
| Purchase Orders | Support purchase-order matching, procurement processing, and invoice validation. | SAP S/4HANA, Oracle Fusion Cloud ERP, Microsoft Dynamics 365 Finance, Coupa | Martini maps purchase-order numbers, line references, supplier identifiers, and amounts, validates relationships, and routes mismatches to exception handling. |
| Approvals | Exchange approval assignments, decisions, workflow status, and invoice review outcomes. | ERP, procurement platforms, notification services, and reporting stores | Martini distinguishes approval status from posting and payment status, propagates supported transitions, and uses reconciliation when event coverage is incomplete. |
| Payments | Exchange payment status or payment-related information where enabled by the customer configuration. | ERP, accounting platforms, treasury processes, and reporting systems | Martini processes only fields and operations exposed by the confirmed API, preserving status provenance and avoiding assumptions that approval means payment is complete. |
| Users | Represent Stampli users and participants involved in invoice approval or accounts payable workflows. | Identity, HR, ERP, and administrative systems | Martini can synchronize supported user attributes or references after confirming permissions and available operations; sensitive user information is minimized in logs. |
Authentication and security considerations
Tenant-specific authentication
Stampli’s precise public authentication scheme was not verified. Confirm whether the customer integration uses API keys, bearer tokens, OAuth 2.0, client credentials, scopes, or tenant-specific headers before implementation.
Credential protection
Store Stampli credentials, base URLs, tenant identifiers, and target-system secrets in Martini secrets and environment configuration rather than in workflow definitions or payloads.
Least privilege and data protection
- Request only the permissions required for invoices, vendors, purchase orders, approvals, payments, or users.
- Redact invoice amounts, tax information, bank details, and document contents from diagnostic logs where appropriate.
- Validate callback authenticity and authorization when Stampli provides outbound notifications.
Operational considerations for Stampli integrations
Pagination and incremental retrieval
Confirm Stampli’s pagination model, filters, rate limits, and status semantics. Use modified-date or status filters, overlapping windows, persisted watermarks, and reconciliation rather than assuming bulk APIs.
Idempotency and matching
Use stable Stampli and source-system IDs. Do not match vendors using names alone, and do not advance a synchronization watermark until required target writes succeed.
Retries and failures
Apply bounded exponential backoff for transient failures and separate validation, authorization, and business-rule errors. Preserve correlation IDs and route persistent failures to an operational exception process.
Schema and document lifecycle
Monitor changes to status values, date formats, identifiers, pagination, and required fields. Confirm attachment permissions, file limits, temporary URL behavior, retention, and duplicate-document rules before processing invoice files.
Testing
Test approved, rejected, held, posted, and paid states, timeouts after successful writes, duplicate deliveries, partial event coverage, pagination boundaries, and API unavailability in a non-production environment.
Why use Martini instead of scripts or point-to-point integrations?
Centralized orchestration
Martini provides a maintainable workflow layer between Stampli, ERP platforms, accounting applications, and procurement systems instead of embedding separate scripts in each connection.
Reusable integration logic
Authentication, validation, mapping, matching, status propagation, retry, and reconciliation behavior can be implemented as reusable integration assets and applied across multiple Stampli workflows.
Controlled APIs and workflows
Martini can consume confirmed Stampli APIs, expose controlled APIs for related systems, receive supported callbacks, and run scheduled synchronization when real-time events are unavailable.
Operational reliability
Workflows can preserve watermarks and correlation IDs, apply business rules, handle errors, and provide a consistent operational model for invoice and supplier data exchanges.
Frequently asked questions
Stampli is commonly integrated with ERP and accounting platforms through application APIs. Depending on the customer configuration, integrations may also use scheduled polling, supported callbacks, and file or attachment operations. The exact API objects, authentication scheme, event coverage, and document capabilities should be confirmed with Stampli.
Yes. Martini can integrate with Stampli through a confirmed Stampli REST API, scheduled workflows, customer-supported callbacks, and supported file or attachment exchanges. Martini can map invoices, vendors, purchase orders, approvals, payments, and related data to ERP or accounting systems.
No. A dedicated Stampli connector is not required. Martini can use Stampli’s confirmed native integration mechanisms, including documented APIs, supported callbacks, authentication methods, scheduled workflows, and file exchanges where available.
Lonti does not charge an additional per-connector or per-vendor fee to integrate Stampli. The integration is subject to the provisioned capacity of the Martini environment. Separate costs may apply from Stampli, cloud infrastructure, or other third-party systems based on subscription, usage, and deployment model.
Use a confirmed Stampli REST API as the primary method where it exposes the required objects and operations. Use scheduled synchronization when callbacks are unavailable or incomplete. Webhook-style callbacks, bulk APIs, asynchronous processing, and attachment operations should be treated as customer-specific or unconfirmed until Stampli documents them.
Only if the customer’s Stampli account and API product provide supported callback events for the required objects and event types. Because a comprehensive public webhook catalog was not verified, scheduled polling and reconciliation should remain the fallback for invoices, approvals, vendors, purchase orders, and payments.
Martini workflows retrieve or receive Stampli objects, validate required fields, map them to canonical and target models, apply business rules, and write to ERP or accounting systems. Incremental synchronization can use documented modification filters, pagination, stable external identifiers, watermarks, overlapping time windows, and reconciliation.
Martini can separate transient API failures from validation, authorization, and business-rule errors, then apply bounded retries with backoff. Stable Stampli and source-system IDs, external-reference mappings, correlation IDs, and idempotency keys where supported help prevent duplicate invoices or vendors. Persistent failures can be routed to operational exception handling.
Related Martini documentation
Workflows
Connect Stampli with your enterprise systems
Use Martini to design reliable Stampli integrations across invoices, vendors, purchase orders, approvals, payments, and related ERP or accounting workflows.