.png)
Freshdesk Integration Guide
Connect Freshdesk with enterprise applications through its REST API, selected automation-rule webhooks, attachment operations, and scheduled synchronization workflows.
Freshdesk integration options at a glance
Freshdesk API v2 is the primary integration mechanism for Tickets, Contacts, Companies, Agents, Groups, Conversations, Products, and attachments. Freshdesk also supports selected webhook-style outbound requests through automation rules, allowing configured ticket conditions to notify a Martini API or workflow. Selected bulk ticket operations can reduce request volume, while pagination, filtering, and timestamps support incremental synchronization. API key authentication through HTTP Basic Authentication and OAuth 2.0 are documented options. Martini can consume these HTTP APIs, receive supported notifications, schedule synchronization workflows, map Freshdesk data to target applications, and apply validation, routing, retry, and error-handling logic.
| Integration point | Supported by Freshdesk? | Common use cases | How Martini supports it |
|---|---|---|---|
| REST APIs | Yes | Freshdesk API v2 supports Tickets, Contacts, Companies, Agents, Groups, Conversations, Products, attachments, searches, updates, assignments, and selected administrative operations. | Martini can consume Freshdesk REST endpoints, expose reusable APIs around integration workflows, map responses, and orchestrate writes to other systems. |
| Webhooks / outbound callbacks | Limited | Automation rules can send webhook-style outbound requests for selected ticket conditions and actions, such as configured creation or update scenarios. | Martini can expose a REST API or consume webhook input, validate the notification, retrieve the complete Freshdesk object, and process repeated notifications idempotently. |
| Bulk / async / batch APIs | Limited | Freshdesk documents selected bulk ticket operations, but this is narrower than a universal asynchronous export or batch-processing API. | Martini can use supported bulk operations where appropriate and control concurrency, checkpoint progress, and handle partial failures in workflows. |
| File / attachment APIs | Yes | Attachments can be handled with supported ticket, reply, and note operations, including uploads or downloads depending on the endpoint. | Martini can transfer files or references, perform metadata mapping, validate content types, and route attachment failures for retry or review. |
| Authentication | Yes | Freshdesk documents API key authentication through HTTP Basic Authentication and OAuth 2.0 for authorized applications. | Martini can store domains, API keys, OAuth credentials, and account-specific settings in protected environment configuration and secrets. |
| Pagination and incremental retrieval | Yes | Freshdesk collection APIs use pagination, while filtering, sorting, timestamps, and ticket update information can support incremental synchronization subject to endpoint and account plan. | Martini workflows can iterate pages, persist checkpoints, normalize timestamps, and resume after a failed synchronization unit. |
| SDKs | Limited | Freshdesk and Freshworks provide developer tooling, but the documented HTTP APIs are the direct integration surface for enterprise synchronization. | Martini can consume the HTTP APIs directly without requiring an SDK and can add custom JVM-compatible logic when transformation requirements demand it. |
How Freshdesk exposes data and business events
Freshdesk REST APIs
Freshdesk API v2 is the principal integration interface for Tickets, Contacts, Companies, Agents, Groups, Conversations, Products, and attachments. Collection responses are paginated, and account permissions constrain which objects and operations are available.
Martini implementation pattern
Martini implementation pattern: a workflow or API receives a request, calls the relevant Freshdesk endpoint with protected credentials, follows pagination or filtering rules, maps the response to a canonical model, and writes to downstream systems. For writes, the workflow validates required fields, records Freshdesk identifiers, and routes failures according to error type.
Implementation sequence
Freshdesk Webhook-Style Notifications
Freshdesk automation rules can send outbound webhook-style requests when selected ticket conditions and actions occur. Coverage is rule-driven and does not represent a universal event stream for every Freshdesk object or field change.
Martini implementation pattern
Martini implementation pattern: expose a protected Martini REST API or webhook workflow, validate the incoming request, identify the Freshdesk Ticket, and call Freshdesk to retrieve complete current data when the notification payload is insufficient. Processing should tolerate duplicate notifications and return an appropriate acknowledgment.
Implementation sequence
Freshdesk Bulk Ticket Operations
Freshdesk documents selected bulk ticket operations that can reduce request volume for supported ticket updates. Bulk support is narrower than a general asynchronous export or universal batch API, so endpoint limits and supported fields must be verified.
Martini implementation pattern
Martini implementation pattern: group compatible Ticket updates, validate that the requested fields and operation are supported, submit the bulk request, and reconcile the result. The workflow should isolate invalid items where possible and retain a checkpoint for reruns.
Implementation sequence
Freshdesk Attachments
Freshdesk supports attachment handling for relevant ticket, reply, and note operations. Depending on the endpoint, files may be uploaded through multipart requests or retrieved through attachment references or URLs.
Martini implementation pattern
Martini implementation pattern: retrieve attachment metadata or content, validate file type and size, transfer the file or reference to the target system, and preserve the relationship to the Ticket or Conversation. Secure temporary storage and retry controls are important for multipart operations.
Implementation sequence
Common Freshdesk integration patterns
Pattern 1: Synchronize Freshdesk customers and contacts
When to use this pattern
Use this pattern when Freshdesk Companies and Contacts must be aligned with a CRM or ERP. It supports scheduled synchronization, stable identifier matching, configurable field mappings, and operational replay when a target write fails.
Integration direction
Example Mapping
| Freshdesk Field | Canonical Field | Target Field |
|---|---|---|
| Companies.id | customer.externalId | Account.externalId |
| Companies.name | customer.name | Account.name |
| Contacts.email | contact.email | Contact.email |
| Contacts.company_id | contact.customerExternalId | Contact.accountExternalId |
Martini implementation pattern
A scheduled Martini workflow retrieves paginated Companies and Contacts using a stored watermark or supported filter, normalizes identity data, and matches records by Freshdesk ID or an approved external identifier. Business rules determine whether to create, update, or quarantine a record, while structured errors and checkpoints support replay.
Martini capabilities used
- workflows
- scheduled execution
- API consumption
- pagination and checkpointing
- data mapping
- business rules
- error handling
Pattern 2: Synchronize Freshdesk Tickets with a CRM or project platform
When to use this pattern
Use this pattern when support cases and correspondence must be visible in Salesforce, Jira, or another downstream application, or when selected downstream status changes must return to Freshdesk.
Integration direction
Example Mapping
| Freshdesk Field | Canonical Field | Target Field |
|---|---|---|
| Tickets.id | supportCase.externalId | Issue.externalId |
| Tickets.subject | supportCase.title | Issue.summary |
| Tickets.priority | supportCase.priority | Issue.priority |
| Tickets.status | supportCase.status | Issue.status |
Martini implementation pattern
Martini retrieves Tickets and related Conversations, maps public replies and private notes according to policy, enriches the payload with Company, Contact, Agent, and Group context, and creates or updates the target issue. Correlation keys prevent duplicate issue creation, while status mappings and retry classification govern reverse updates.
Martini capabilities used
- API consumption
- data mapping
- canonical models
- conditional routing
- idempotency
- error handling
- reusable workflows
Pattern 3: Route selected Freshdesk tickets from automation rules
When to use this pattern
Use this pattern when selected Freshdesk ticket conditions should initiate an immediate escalation, order lookup, entitlement request, or internal service process rather than waiting for a scheduled poll.
Integration direction
Example Mapping
| Freshdesk Field | Canonical Field | Target Field |
|---|---|---|
| Tickets.id | ticket.externalId | Incident.correlationId |
| Tickets.company_id | customer.externalId | Incident.accountId |
| Tickets.priority | support.priority | Incident.impact |
| Tickets.group_id | support.queue | Incident.assignmentGroup |
Martini implementation pattern
A Freshdesk automation rule sends a webhook-style request to a protected Martini API. Martini validates the request, retrieves the complete Ticket and related objects, applies routing based on Company, Product, Group, priority, tags, or custom fields, and creates or updates the target record. Duplicate notifications are handled through correlation and processing-state checks.
Martini capabilities used
- API exposure
- webhook consumption
- request validation
- API consumption
- business rules
- orchestration
- idempotent processing
Pattern 4: Synchronize Freshdesk conversations and attachments
When to use this pattern
Use this pattern when another application needs a durable copy of ticket correspondence or attachment references, such as during case consolidation, migration, or document retention workflows.
Integration direction
Example Mapping
| Freshdesk Field | Canonical Field | Target Field |
|---|---|---|
| Conversations.body | activity.content | CaseComment.body |
| Conversations.created_at | activity.createdAt | CaseComment.createdDate |
| Conversations.private | activity.visibility | CaseComment.visibility |
| Attachments.name | file.name | ContentVersion.title |
Martini implementation pattern
Martini retrieves Conversations and supported attachment data, distinguishes public replies from private notes, validates content and retention rules, and writes correspondence or files to the target system. File transfers are isolated from message synchronization so a failed attachment does not unnecessarily duplicate the Conversation.
Martini capabilities used
- API consumption
- file handling
- data mapping
- content validation
- workflow orchestration
- retry handling
- structured logging
Applications commonly integrated with Freshdesk
Freshdesk can be integrated with adjacent business applications when support data must be synchronized with customer, engineering, service operations, commerce, or enterprise records. The exact scope depends on the organization’s data model, Freshdesk permissions, and the APIs exposed by the target application.
| Application | Scenario | Direction | Martini Pattern |
|---|---|---|---|
| Salesforce | Synchronize customer and contact context, account ownership, support cases, and ticket activity between CRM and Freshdesk. | Salesforce → Martini → Freshdesk | Martini can retrieve Salesforce Accounts and Contacts, resolve Freshdesk Companies and Contacts, and create or update Freshdesk Tickets. A reverse workflow can publish ticket status, priority, assignment, and Conversations back to Salesforce using stable identifiers and idempotent upserts. |
| HubSpot | Align contacts, companies, lifecycle data, and support ticket activity across marketing, sales, and service operations. | HubSpot → Martini → Freshdesk | A scheduled or event-driven Martini workflow can map HubSpot contacts and companies to Freshdesk Contacts and Companies, then synchronize selected Ticket status or activity fields back to HubSpot. Configuration-driven mappings should accommodate account-specific custom fields. |
| Jira | Escalate technical Freshdesk Tickets into Jira issues and return issue status, comments, or resolution information to support teams. | Freshdesk → Martini → Jira | Freshdesk automation rules can notify a Martini API when selected ticket conditions occur. Martini retrieves the full Ticket and Conversations, applies routing rules, creates or updates a Jira issue, and uses a correlation key to prevent duplicate escalations. |
| ServiceNow | Transfer selected customer support tickets into ServiceNow incidents, requests, or tasks for internal service operations. | Freshdesk → Martini → ServiceNow | Martini can receive a Freshdesk webhook-style notification, retrieve the related Ticket and requester or Company data, create a ServiceNow record, and send status or resolution changes back to Freshdesk after validating permissions and field mappings. |
| NetSuite | Provide support agents with customer, order, subscription, or billing context and associate support activity with ERP accounts or transactions. | NetSuite → Martini → Freshdesk | A Martini workflow can retrieve NetSuite customer or transaction context, resolve the related Freshdesk Company or Contact, and enrich support workflows. Selected Freshdesk Ticket outcomes can be transformed into NetSuite updates or escalation records. |
| Shopify | Give support agents order and customer context and allow ticket workflows to reference commerce transactions. | Shopify → Martini → Freshdesk | Martini can use customer or order identifiers to retrieve Shopify context, map it into Freshdesk Ticket fields or Conversations, and optionally propagate selected support outcomes or tags back to Shopify through its available APIs. |
| Workday | Route employee or HR-related support requests between Freshdesk and Workday-adjacent service processes where Freshdesk is used as an external support channel. | Freshdesk → Martini → Workday | Martini can classify selected Freshdesk Tickets by Product, Group, tags, or custom fields, transform the request into the target Workday-related process, and return controlled status information to Freshdesk. The precise objects depend on the Workday modules in use. |
| Zendesk | Migrate or consolidate tickets, contacts, organizations, comments, and attachments between customer-support platforms. | Zendesk → Martini → Freshdesk | A staged Martini workflow can extract supported Zendesk objects, normalize them into a canonical support model, create Freshdesk Contacts, Companies, Tickets, Conversations, and attachments where supported, and retain source identifiers for reconciliation. |
How to build a Freshdesk integration in Martini
Objective
Establish secure access to Freshdesk and the target applications without embedding credentials in workflow definitions.
Instructions in Martini
- Store the Freshdesk domain, API key or OAuth configuration, and target credentials in Martini secrets or protected environment configuration.
- Confirm Freshdesk permissions for Tickets, Contacts, Companies, Agents, Groups, Conversations, Products, and attachments required by the workflow.
- Configure target API authentication and restrict access to the resources used by the integration.
Objective
Select an event-driven or scheduled entry point that matches Freshdesk coverage and synchronization requirements.
Instructions in Martini
- Use a Freshdesk automation-rule webhook-style notification for selected ticket conditions when near-real-time processing is required.
- Use a scheduler-triggered workflow for broader synchronization, incremental retrieval, or objects without suitable notification coverage.
- Define the watermark, filtering strategy, and checkpoint behavior before processing collection endpoints.
Objective
Obtain the complete Freshdesk data required for routing and transformation rather than relying on an incomplete notification payload.
Instructions in Martini
- Call Freshdesk API v2 endpoints for the Ticket, Contact, Company, Agent, Group, Conversation, Product, or attachment data required by the use case.
- Follow pagination until the collection is complete and preserve the last successful checkpoint.
- Use identifiers and supported timestamps or filters for incremental synchronization.
Objective
Coordinate retrieval, enrichment, business decisions, target writes, and status recording in a maintainable Martini workflow.
Instructions in Martini
- Separate transport, transformation, business rules, and target-system operations into clear workflow stages.
- Route tickets using Company, Product, Group, priority, tags, status, and custom fields where configured.
- Persist correlation identifiers and processing state so repeated notifications can be recognized.
Objective
Transform Freshdesk objects into the target application model while accounting for account-specific fields and support semantics.
Instructions in Martini
- Map Ticket status, priority, type, source, tags, custom fields, requester, Company, Agent, and Group values through configurable mappings.
- Distinguish public Conversations from private notes and normalize timestamps and time zones.
- Validate required target fields and preserve source identifiers for reconciliation.
Objective
Create or update target objects and, where required, return controlled updates to Freshdesk.
Instructions in Martini
- Use idempotent create-or-update logic based on Freshdesk IDs, external identifiers, or approved custom fields.
- Update Freshdesk Tickets, replies, notes, assignments, or statuses only when the configured credentials have the required permissions.
- Handle attachments separately when multipart operations, file-size limits, or secure storage requirements apply.
Common Freshdesk data objects used in integrations
| Object | Typical Use | Common target systems | Martini handling |
|---|---|---|---|
| Tickets | Primary support cases that can be created, updated, assigned, searched, merged, closed, and synchronized. | Salesforce, Jira, ServiceNow, HubSpot, NetSuite | Martini retrieves or receives ticket identifiers, maps status, priority, source, type, tags, custom fields, Agent, Group, requester, and Company data, then applies correlation and idempotent write rules. |
| Contacts | Requesters and customer contacts associated with Tickets and Companies. | Salesforce, HubSpot, NetSuite, Shopify | Martini resolves stable Freshdesk IDs or external identifiers, normalizes identity fields, and creates or updates target contacts while handling duplicate and permission scenarios. |
| Companies | Organizations associated with Contacts and Tickets and used for account-level routing. | Salesforce, HubSpot, NetSuite, ServiceNow | Martini synchronizes organization identifiers and account attributes, applies configurable matching rules, and uses Company data to enrich ticket routing. |
| Agents | Freshdesk support users who can be assigned Tickets or used in routing logic. | Salesforce, ServiceNow, internal directories | Martini maps Agent identifiers and assignment information when permissions allow, while avoiding assumptions that Freshdesk and target user directories share the same identities. |
| Groups | Support teams used for assignment, escalation, and queue management. | ServiceNow, Jira, Salesforce | Martini translates Group identifiers into target ownership or routing values through configuration-driven mappings and validates destination assignments before writing. |
| Conversations | Ticket replies, private notes, and other ticket-level correspondence used to synchronize support activity. | Salesforce, Jira, ServiceNow, document repositories | Martini distinguishes public replies from private notes, maps timestamps and authors, preserves Ticket correlation, and handles duplicate conversation creation separately from transport retries. |
Authentication and security considerations
Credentials and authorization
Freshdesk API v2 supports API keys through HTTP Basic Authentication and also documents OAuth 2.0 for authorized applications. The appropriate option depends on whether the integration is a controlled server-to-server workflow or requires delegated authorization.
Martini security controls
- Store Freshdesk domains, API keys, OAuth credentials, and target credentials in Martini secrets or protected environment configuration.
- Grant only the Freshdesk permissions required for Tickets, Contacts, Companies, Conversations, attachments, and related operations.
- Protect Martini APIs receiving Freshdesk automation notifications and validate inbound requests before performing writes.
- Avoid logging credentials, tokens, or unnecessary sensitive ticket content.
Operational considerations for Freshdesk integrations
Rate limits and pagination
Freshdesk rate limits vary by account plan and API level. Workflows should detect HTTP 429 responses, respect Retry-After guidance when provided, use backoff, control concurrency, and follow collection pagination until processing is complete.
Synchronization and idempotency
Use a defined watermark, stable Freshdesk identifiers, external references, and checkpoints for incremental synchronization. Treat webhook-style notifications as potentially repeated and separate transport retries from business retries.
Schema and file handling
Freshdesk custom fields, statuses, Groups, Products, and automation rules can vary by account. Keep mappings configurable, validate required fields, and test changes against representative Tickets. Attachment workflows should address file size, content type, temporary URLs, secure storage, and multipart retry behavior.
Testing and observability
Test authentication, permissions, pagination, rate-limit behavior, duplicate notifications, public versus private Conversations, and failed target writes. Martini can record structured logs, route errors, preserve checkpoints, and support operational replay.
Why use Martini instead of scripts or point-to-point integrations?
Orchestration beyond point-to-point calls
Freshdesk integrations often require more than a single API request. Martini can combine webhook-style notifications, scheduled retrieval, related-object lookups, transformations, business rules, target writes, and controlled updates to Freshdesk in one maintainable workflow.
Reusable integration assets
Martini enables teams to expose APIs, consume Freshdesk REST endpoints, reuse workflow logic, and apply consistent mappings and validation across multiple support processes without embedding the entire integration in a bespoke script.
Operational reliability
- Handle pagination, rate limits, checkpoints, retries, and duplicate notifications explicitly.
- Keep credentials and account-specific mappings outside workflow logic where appropriate.
- Separate transient transport failures from validation, permission, and business-rule failures.
- Centralize logging and error handling so failed synchronization units can be investigated and replayed.
Frequently asked questions
Freshdesk can be integrated through its versioned REST API v2, selected webhook-style outbound requests configured through automation rules, supported bulk ticket operations, and attachment APIs. Scheduled workflows can use pagination, filtering, identifiers, and timestamps for incremental synchronization. API keys through HTTP Basic Authentication and OAuth 2.0 are documented authentication options.
Yes. Martini can consume the Freshdesk REST API, receive supported webhook-style notifications through a Martini API or workflow, schedule incremental synchronization, map Freshdesk objects, and orchestrate writes to CRM, project, service-management, ERP, or document applications.
No. A dedicated Freshdesk connector is not required. Martini can use Freshdesk’s documented REST APIs, selected automation-rule webhook notifications, attachment operations, and authentication methods directly. No native Martini Freshdesk connector is verified in the supplied context.
Lonti does not charge an additional per-connector or per-vendor fee to integrate Freshdesk with Martini. The integration is subject to the provisioned capacity of the Martini environment. Separate costs may apply from Freshdesk, infrastructure providers, or other third-party systems based on subscriptions, usage, and deployment models.
Freshdesk API v2 is the primary method for reading and writing Tickets, Contacts, Companies, Agents, Groups, Conversations, Products, and attachments. Use automation-rule webhook-style requests for selected event-driven ticket scenarios, supported bulk operations for compatible ticket updates, and scheduled API synchronization for broader or unsupported event coverage. No official Freshdesk GraphQL or current SOAP API was confirmed.
Freshdesk supports webhook-style outbound requests through automation rules for selected conditions and actions. Coverage is rule-driven rather than a universal event stream, so the integration should verify available account conditions and retrieve the full Ticket from the REST API when the notification payload is incomplete.
Use Freshdesk IDs, external identifiers, or dedicated custom fields as correlation keys. Martini can paginate collections, maintain checkpoints, map account-specific statuses and custom fields, distinguish public replies from private notes, and apply idempotent create-or-update rules. Repeated webhook notifications should be expected and safely reprocessed.
Martini workflows can classify authentication, permission, validation, missing-object, attachment, rate-limit, and temporary service errors. They can respect HTTP 429 responses and Retry-After guidance, use backoff and controlled concurrency, persist checkpoints, log structured failures, and support replay without duplicating successful writes.
Related Martini documentation
APIs
Workflows
Operations
Connect Freshdesk with your enterprise systems
Use Martini to build secure, maintainable Freshdesk integrations across APIs, webhook-style notifications, scheduled synchronization, data mapping, and workflow orchestration.