.png)
Front Integration Guide
Integrate Front’s shared customer communications with enterprise systems through REST APIs, selective webhooks, message handling, and secure Martini workflows.
Front integration options at a glance
Front provides a REST API as its primary integration mechanism for conversations, messages, contacts, inboxes, teammates, tags, channels, and related resources. Its webhook capability provides notifications for documented conversation and message events, but should be treated as selective event coverage rather than a complete event stream. Message endpoints can expose bodies, recipients, metadata, and attachments where permissions allow. Front collection endpoints use pagination, so larger synchronizations should run as controlled batches with stored cursors or timestamps. API tokens and OAuth 2.0 support secure access. Martini can consume these APIs, receive webhook notifications, transform data, apply business rules, and coordinate downstream updates.
| Integration point | Supported by Front? | Common use cases | How Martini supports it |
|---|---|---|---|
| REST APIs | Yes | Front’s primary interface for reading and modifying Conversations, Messages, Contacts, Inboxes, Teammates, Tags, Channels, and related resources. | Martini can consume Front REST endpoints from workflows, paginate collection responses, transform payloads, and coordinate writes to downstream systems. |
| Webhooks / outbound callbacks | Yes | Front provides notifications for documented event types, including selected conversation or message changes. | Martini can receive Front webhook notifications through an API or webhook-triggered workflow, deduplicate events, retrieve authoritative resources, and process them asynchronously. |
| File / attachment APIs | Limited | Front messages can contain bodies, recipients, metadata, and attachments. Attachment retrieval and forwarding depend on the endpoint, permissions, file size, and retention behavior. | Martini can retrieve and transform attachment data, validate content, and transfer files to downstream systems when the relevant Front operation permits it. |
| Authentication | Yes | Front documents API tokens sent through the Authorization header and OAuth 2.0 for delegated application access, with permissions and scopes governing access. | Martini can store credentials in protected environment configuration or secrets management and use the appropriate authenticated REST request pattern. |
| Pagination and incremental retrieval | Yes | Front collection endpoints use pagination. Synchronizations can use documented filtering or pagination behavior together with a stored cursor or timestamp. | Martini can implement scheduled or event-assisted workflows that persist checkpoints, process controlled pages, and resume after failures. |
| Bulk / asynchronous APIs | Not confirmed | Collection endpoints and pagination are documented, but a general-purpose bulk or asynchronous import/export API was not confirmed. | Martini can process controlled batches of REST requests, throttle concurrency, and isolate failures without claiming a Front bulk API. |
| GraphQL APIs | Not confirmed | No official Front GraphQL API documentation was confirmed in the reviewed research. | Martini can consume Front’s documented REST API instead; a GraphQL interface should not be assumed for Front. |
| SOAP APIs | Not confirmed | No official Front SOAP API documentation was confirmed in the reviewed research. | Martini can use the documented REST and webhook mechanisms rather than assuming a Front SOAP service. |
How Front exposes data and business events
Front REST APIs
Front’s REST API is the primary programmatic interface for conversations, messages, contacts, inboxes, teammates, tags, channels, and related resources. It supports both resource retrieval and modification, with collection responses handled through pagination.
Martini implementation pattern
Martini implementation pattern: a workflow authenticates to Front, calls the required REST endpoint, follows pagination or retrieves the resource referenced by an event, maps the response into a canonical model, applies business rules, and writes to one or more target systems.
Implementation sequence
Front webhooks
Front supports webhook-style notifications for documented event types, including selected conversation or message changes. Coverage is selective, so an event should be treated as a notification rather than a complete source of truth.
Martini implementation pattern
Martini implementation pattern: a Martini API or webhook-triggered workflow accepts the event, validates and records an idempotency key, acknowledges promptly where applicable, retrieves the current Front resource, and processes the downstream update asynchronously.
Implementation sequence
Front messages and attachments
Front message resources can include message bodies, recipients, metadata, and attachments. Processing scope depends on the selected message endpoint, permissions, file behavior, and the capabilities of the receiving system.
Martini implementation pattern
Martini implementation pattern: a workflow retrieves message content and attachment metadata, validates content type and size, optionally downloads or forwards approved files, maps message activity to the target application, and keeps sensitive content out of routine logs.
Implementation sequence
Common Front integration patterns
Pattern 1: Sync Front conversations to a CRM
When to use this pattern
Use this pattern when customer communications in Front need to appear in Salesforce or HubSpot as contact activity, cases, or engagement history. Event-driven processing provides near-real-time updates, while scheduled reconciliation protects against missed notifications.
Integration direction
Example Mapping
| Front Field | Canonical Field | Target Field |
|---|---|---|
| contact.id | customer.externalId | Contact.Front_Contact_ID__c |
| conversation.id | interaction.externalId | Case.Front_Conversation_ID__c |
| conversation.subject | interaction.subject | Case.Subject |
| teammate.id | owner.externalId | Case.OwnerId |
Martini implementation pattern
Martini receives a selected conversation or message event, retrieves the authoritative conversation, enriches it with contact and teammate data, maps tags and messages into the CRM model, and upserts using the Front conversation ID. Transient failures are retried and non-retryable mappings are routed for review.
Martini capabilities used
- workflows
- API consumption
- data mapping
- business rules
- error handling
- scheduled reconciliation
Pattern 2: Enrich Front conversations with order context
When to use this pattern
Use this pattern when support teams need order, billing, fulfillment, or account information while handling Front conversations. The workflow can query NetSuite or Shopify, apply matching rules, and update supported Front conversation information or routing metadata.
Integration direction
Example Mapping
| Front Field | Canonical Field | Target Field |
|---|---|---|
| contact.email | customer.lookupKey | Customer.email |
| conversation.id | conversation.externalId | CustomerService.frontConversationId |
| order.status | order.currentStatus | Conversation.customField.orderStatus |
| order.number | order.reference | Conversation.customField.orderNumber |
Martini implementation pattern
Martini uses a Front event as the trigger, retrieves the current conversation and contact, queries the business system for a matching customer or order, and applies a no-match path when confidence is insufficient. Approved context is then mapped to supported Front operations, with retries for temporary API failures.
Martini capabilities used
- workflows
- API consumption
- data enrichment
- mapping and transformation
- conditional routing
- retry handling
Pattern 3: Escalate Front conversations to ServiceNow
When to use this pattern
Use this pattern when a Front conversation with a qualifying tag, inbox, or priority must become an operational incident or customer-service work item in ServiceNow. It provides controlled escalation without requiring agents to recreate conversation details manually.
Integration direction
Example Mapping
| Front Field | Canonical Field | Target Field |
|---|---|---|
| conversation.id | sourceConversationId | Incident.u_front_conversation_id |
| conversation.subject | incident.summary | Incident.short_description |
| conversation.status | sourceStatus | Incident.description |
| tags | classification | Incident.category |
Martini implementation pattern
A Martini webhook workflow retrieves the complete Front conversation, evaluates escalation rules, maps the relevant message summary and identifiers, and creates or updates the ServiceNow record. The Front ID is used as an external key so duplicate events do not create duplicate incidents; transient failures are retried.
Martini capabilities used
- webhook-triggered workflows
- API consumption
- data mapping
- business rules
- idempotency
- error handling
Pattern 4: Reconcile Front data to a database
When to use this pattern
Use this pattern for historical reporting, retention, data quality checks, archival, or recovery after webhook interruptions. It is appropriate when conversations, messages, contacts, or tags must be normalized outside Front.
Integration direction
Example Mapping
| Front Field | Canonical Field | Target Field |
|---|---|---|
| conversation.id | conversationId | front_conversations.front_id |
| message.id | messageId | front_messages.front_id |
| contact.id | contactId | front_contacts.front_id |
| conversation.updated_at | lastChangedAt | front_conversations.updated_at |
Martini implementation pattern
A scheduled Martini workflow reads Front collection endpoints page by page, persists a cursor or timestamp, transforms nested resources into relational structures, and uses stable Front IDs for upserts. Rate limits, partial failures, and schema changes are logged and isolated so the run can resume without duplicating data.
Martini capabilities used
- scheduled workflows
- API consumption
- pagination handling
- mapping and transformation
- SQL database access
- monitoring and error handling
Applications commonly integrated with Front
Front can be integrated with named customer, operational, commerce, and collaboration applications to connect shared conversations with customer context, escalations, order data, and internal notifications. These are practical architecture patterns rather than claims of native Front partnerships.
| Application | Scenario | Direction | Martini Pattern |
|---|---|---|---|
| Salesforce | Synchronize Front conversations and messages with Salesforce Accounts, Contacts, Cases, and customer activity history while using CRM context for routing or enrichment. | Front → Martini → Salesforce | Martini receives selected Front events, retrieves the authoritative conversation, maps contacts and messages to Salesforce activity or case data, applies duplicate-prevention rules, and routes failures for retry or review. |
| HubSpot | Connect Front communications with HubSpot Contacts, Companies, Deals, and engagement history to provide broader customer lifecycle context. | Front → Martini → HubSpot | A Martini workflow consumes Front REST resources, matches contacts using stable identifiers or controlled business rules, transforms conversation activity into HubSpot objects, and records processing state for reconciliation. |
| Zendesk | Coordinate shared Front conversations with Zendesk support tickets and escalation workflows when customer-service work spans both platforms. | Front → Martini → Zendesk | Martini creates or updates Zendesk tickets from qualifying Front conversations, maps tags and assignments, and optionally sends status references back through Front APIs where the required permissions and endpoints allow. |
| ServiceNow | Create ServiceNow incidents or customer-service work items when a Front conversation requires operational escalation. | Front → Martini → ServiceNow | Martini receives a Front webhook, retrieves current conversation details, evaluates priority and tags, creates a ServiceNow record, and tracks the Front identifier to prevent duplicate incidents. |
| Jira | Convert product defects or engineering requests identified in Front conversations into Jira issues and associate subsequent status information with the customer interaction. | Front → Martini → Jira | A workflow classifies Front conversations, maps relevant message content and attachments to Jira fields, applies project and priority rules, and stores the Jira key for controlled status synchronization. |
| NetSuite | Add order, account, billing, or fulfillment context from NetSuite to Front conversations and support selected customer-service updates back to business systems. | NetSuite → Martini → Front | Martini matches Front contacts or conversation context to NetSuite records, transforms order and account data, and updates Front metadata, tags, or internal conversation information where supported. |
| Shopify | Relate Front messages to Shopify customers, orders, refunds, and fulfillment information so support teams can work with commerce context. | Shopify → Martini → Front | Martini retrieves Shopify context after a Front event, applies customer and order matching rules, and exposes the approved context to Front through supported API operations while handling missing matches safely. |
| Slack | Notify internal teams about escalated Front conversations, operational exceptions, or customer-impacting events. | Front → Martini → Slack | Martini filters Front webhook events by tags, inbox, or priority, formats a concise notification, sends it to Slack through an approved endpoint, and retries transient delivery failures. |
How to build a Front integration in Martini
Objective
Establish authenticated access to Front and configure the Martini environment without embedding credentials in workflow logic.
Instructions in Martini
- Choose a Front API token or OAuth 2.0 approach based on the access model.
- Store credentials and environment-specific values in Martini secrets or secure configuration.
- Limit Front permissions and scopes to the integration’s required objects and operations.
Objective
Select an event-driven, scheduled, or API-led entry point that matches the synchronization and responsiveness requirements.
Instructions in Martini
- Use a Martini webhook or API-triggered workflow for documented Front events.
- Use a scheduler for reconciliation, exports, and incremental retrieval.
- Separate high-priority event processing from larger batch workloads.
Objective
Obtain the authoritative Front resource rather than relying solely on a webhook payload or a single collection response.
Instructions in Martini
- Validate incoming event data and record an idempotency key.
- Retrieve the current Conversation, Message, Contact, or related resource through the Front REST API.
- Handle pagination and persist cursor or timestamp state for collection synchronization.
Objective
Coordinate Front calls, enrichment requests, business rules, and target-system operations in a maintainable Martini workflow.
Instructions in Martini
- Add conditional paths for missing matches, invalid data, and unsupported operations.
- Enrich Front data from approved downstream APIs where the use case requires context.
- Keep event acknowledgement and longer downstream processing appropriately separated.
Objective
Convert Front’s communication-oriented objects into the canonical model required by each target system.
Instructions in Martini
- Map Front identifiers, contacts, conversations, messages, inboxes, teammates, and tags.
- Normalize timestamps, statuses, ownership, message content, and attachment metadata.
- Preserve source identifiers and relevant unmapped values for traceability.
Objective
Control routing, escalation, matching, and duplicate prevention before writing to external systems.
Instructions in Martini
- Use stable Front conversation and message IDs as external keys.
- Apply tag, inbox, teammate, priority, and data-quality rules.
- Validate required target fields before creating or updating downstream records.
Common Front data objects used in integrations
| Object | Typical Use | Common target systems | Martini handling |
|---|---|---|---|
| Conversations | Represent customer interactions grouped into shared conversation threads and support routing, escalation, and activity synchronization. | Salesforce, HubSpot, Zendesk, ServiceNow, Jira, SQL databases | Martini retrieves the current conversation after relevant events, maps identifiers, status, inbox, teammate, tags, and timestamps, and applies idempotent upsert rules. |
| Messages | Store inbound and outbound communication, including message bodies, recipients, metadata, and possible attachments. | Salesforce, HubSpot, Zendesk, data warehouses, file stores | Martini retrieves message details when thread content is required, transforms message content and metadata, validates attachments, and limits sensitive data in logs. |
| Contacts | Associate people or organizations with customer communications and support matching with external customer records. | Salesforce, HubSpot, NetSuite, Shopify, SQL databases | Martini maps Front contact identifiers and attributes to target customer models, applies matching rules, and handles optional or changed fields conservatively. |
| Inboxes | Represent shared or team-managed locations used to organize and route conversations. | Salesforce, ServiceNow, reporting databases, internal routing services | Martini can cache relatively stable inbox reference data and use inbox identifiers in routing, filtering, and downstream ownership rules. |
| Teammates | Represent Front users who can be assigned conversations or participate in handling them. | Salesforce, ServiceNow, Slack, internal identity or reporting systems | Martini maps teammate identifiers to downstream owners or notification recipients and refreshes reference data when assignments change. |
| Tags | Classify, route, prioritize, and report on Front conversations. | Salesforce, Zendesk, ServiceNow, Jira, Slack, reporting databases | Martini translates tags into downstream categories, priorities, or workflow conditions and preserves unmapped values for review when appropriate. |
Authentication and security considerations
Authentication options
Front documents API tokens sent through the Authorization header and OAuth 2.0 for delegated application access. Permissions and scopes should be limited to the objects and operations required by the integration.
Protecting customer communications
- Store Front credentials in Martini secrets or protected environment configuration.
- Use HTTPS for API requests and webhook processing.
- Apply least-privilege access and restrict Martini environment access.
- Avoid writing complete message bodies or sensitive attachments to routine logs.
Operational considerations for Front integrations
Reliability and scale
- Respect Front rate limits with controlled concurrency, backoff, and workload separation.
- Process collection endpoints with pagination and persist cursors or timestamps.
- Treat webhook payloads as notifications, retrieve current resources, and reconcile periodically.
- Use Front conversation and message IDs for idempotency and duplicate prevention.
- Account for delayed or out-of-order events by comparing timestamps or re-reading resource state.
Data and change management
- Validate attachment size, content type, retention, and security requirements before forwarding files.
- Tolerate optional fields and schema changes while validating required target fields.
- Classify authentication, validation, throttling, network, and downstream failures for appropriate retry behavior.
- Test representative conversations containing multiple messages, tags, assignments, and attachments.
Why use Martini instead of scripts or point-to-point integrations?
Maintainable orchestration
Martini separates Front API consumption, webhook intake, transformation, business rules, target-system writes, and operational handling into reusable workflows and APIs. This is more maintainable than duplicating logic across scripts or point-to-point integrations.
Reliable enterprise processing
- Combine event-driven Front processing with scheduled reconciliation.
- Centralize authentication, secrets, mappings, validation, retries, and logging.
- Support CRM, service management, databases, commerce platforms, and notification systems in one integration flow.
- Expose a controlled API façade when applications should not access Front directly.
Frequently asked questions
Front can be integrated primarily through its REST API, which exposes Conversations, Messages, Contacts, Inboxes, Teammates, Tags, Channels, and related resources. Front also supports webhook notifications for selected conversation and message events, while message endpoints can provide attachment data where permitted. API tokens and OAuth 2.0 support authenticated access, and pagination supports controlled synchronization.
Yes. Martini can integrate with Front by consuming its REST API, receiving documented Front webhook events, processing messages and attachments where the relevant endpoints and permissions allow, and orchestrating mappings and updates to downstream applications.
No. A dedicated Front connector is not required. Martini can use Front’s native REST APIs, documented webhook notifications, API tokens or OAuth 2.0 authentication, and supported message or attachment endpoints through workflows and APIs.
Lonti does not charge an additional per-connector or per-vendor fee to integrate Front. The integration is subject to the provisioned capacity of the Martini environment. Separate costs may apply from Front, cloud infrastructure, or other third-party systems based on subscription, usage, and deployment model.
Use Front’s REST API as the primary integration method and use webhooks for documented conversation or message events where near-real-time processing is needed. Webhook payloads should trigger retrieval of the authoritative resource, while scheduled paginated REST synchronization provides reconciliation and recovery.
Front supports webhook-style notifications for documented event types, but coverage is selective rather than universal. No official Front GraphQL or SOAP API was confirmed in the reviewed research, so new integrations should use the REST API and documented webhooks.
Martini can combine Front webhook processing with scheduled reconciliation. Workflows record event or resource identifiers, retrieve current resources, follow pagination, persist cursors or timestamps, and use stable Front IDs to prevent duplicate downstream records. Retries, backoff, and exception handling address transient failures and rate limits.
Yes. Martini can expose a controlled API that abstracts Front operations for internal applications or partners. The façade can authenticate callers, validate requests, apply business rules, invoke Front REST endpoints, normalize responses, and centralize error handling without exposing Front credentials directly.
Related Martini documentation
Workflows
Connect Front with your enterprise systems
Use Martini to build secure, maintainable Front integrations that synchronize customer communications, orchestrate escalations, and connect shared inbox activity with the systems your teams rely on.