Ellipse Gradient for Header

ServiceTitan Integration Guide

Connect ServiceTitan operational, dispatch, customer, and financial data with enterprise systems through REST APIs, selected webhook events, and OAuth 2.0.

ServiceTitan integration options at a glance

ServiceTitan provides versioned REST APIs over HTTPS with JSON responses across CRM, dispatch, accounting, marketing, inventory, settings, and payroll domains. OAuth 2.0 application authentication is used with access tokens, tenant identification, application identification, and appropriate permissions. ServiceTitan also provides webhook-style notifications for selected business events, although event coverage and delivery behavior must be verified for each tenant and API version. Martini can consume these APIs, receive supported notifications through an API or workflow trigger, process paginated responses, apply mappings and business rules, and write results to enterprise applications, databases, or analytics platforms.

Integration pointSupported by ServiceTitan?Common use casesHow Martini supports it
REST APIsYesRetrieve and update Customers, Locations, Jobs, Appointments, Technicians, Invoices, Payments, Equipment, campaigns, inventory, and other domain data across versioned functional APIs.Martini can consume ServiceTitan REST endpoints, send JSON over HTTPS, paginate through responses, map fields, and orchestrate writes to downstream systems.
Webhooks / outbound callbacksLimitedReceive notifications for selected ServiceTitan business events so downstream processing does not rely exclusively on continuous polling.Martini can expose a webhook-facing API or workflow entry point, validate and deduplicate notifications, and retrieve the current object by identifier. Coverage must be verified per event and API version.
AuthenticationYesAuthenticate registered applications with OAuth 2.0 access tokens, tenant identification, application identification, and appropriate API permissions.Martini can store client credentials, secrets, tenant identifiers, and application keys in secrets or environment configuration and apply required request headers securely.
Pagination and incremental synchronizationYesProcess list APIs page by page and use documented date, modification, or cursor filters where available for recurring synchronization.Martini workflows can persist page, cursor, or watermark state, resume interrupted runs, and perform scheduled reconciliation when reliable change filters are unavailable.
Bulk / asynchronous APIsNot confirmedA broadly applicable ServiceTitan bulk or asynchronous API was not confirmed; ordinary paginated REST requests should be assumed.Martini can orchestrate bounded paginated requests and asynchronous workflow processing, but a ServiceTitan bulk capability should not be assumed.
File / attachment APIsNot confirmedA general-purpose ServiceTitan file or attachment API was not confirmed.Martini can process files when a documented ServiceTitan or external file endpoint is available, but the integration should verify the relevant API domain first.
Database / analytics accessNot confirmedDirect database access to ServiceTitan operational data was not confirmed; documented APIs or supported export and reporting facilities should be used.Martini can write API-retrieved data to supported SQL databases or analytics platforms without requiring direct database access to ServiceTitan.

How ServiceTitan exposes data and business events

ServiceTitan REST APIs

REST is ServiceTitan's primary documented integration mechanism. Versioned JSON-over-HTTPS APIs are organized into areas such as CRM, dispatch, accounting, marketing, inventory, settings, and payroll, with operations for Customers, Locations, Jobs, Appointments, Technicians, Invoices, Payments, and other business data.

Martini implementation pattern

Martini implementation pattern: Martini authenticates with the configured OAuth 2.0 application, invokes the required ServiceTitan domain endpoints, processes pagination and incremental filters where available, maps the response into a canonical model, and calls the target system or persists the result.

Implementation sequence

Authenticate using stored ServiceTitan OAuth credentials
Request a page or increment from the selected ServiceTitan API domain
Validate the JSON response and preserve pagination state
Map ServiceTitan objects to the canonical integration model
Apply business rules and write to the target system
Store the checkpoint and route failures for retry or reconciliation

ServiceTitan Webhook Notifications

ServiceTitan provides webhook-style notifications for selected business events. Availability, event types, payloads, delivery guarantees, and subscription behavior must be verified for the tenant and API version; notifications should not be treated as universal coverage for every object change.

Martini implementation pattern

Martini implementation pattern: Martini exposes a webhook-facing API or workflow trigger, validates the notification, creates a deduplication key, and starts processing that retrieves the current ServiceTitan object by identifier before transforming it for downstream systems.

Implementation sequence

Receive the supported ServiceTitan notification
Validate the request and identify the event and source object
Check the event or object deduplication key
Retrieve the current ServiceTitan object when the payload is incomplete
Map and route the object to the target workflow
Retry transient retrieval or delivery failures with bounded backoff

ServiceTitan Scheduled Synchronization

ServiceTitan list APIs commonly require pagination. Recurring synchronization can use documented date, modification, or cursor-based filters where available; objects without reliable change filters may require scheduled reconciliation.

Martini implementation pattern

Martini implementation pattern: a scheduler starts a workflow that reads the last successful watermark or page state, requests bounded pages, transforms each object, writes results, and commits progress only after successful processing.

Implementation sequence

Start the synchronization on a configured schedule
Load the stored watermark, cursor, or page checkpoint
Request and process one ServiceTitan page
Transform and write the returned objects
Persist progress after successful downstream writes
Run reconciliation for missed or failed changes

Common ServiceTitan integration patterns

Pattern 1: Sync customers and jobs to Salesforce

When to use this pattern

Use this pattern when sales or account-management teams need field-service context. The workflow synchronizes Customers, Locations, Jobs, and Appointments, retains source identifiers, and supports controlled updates where Salesforce is allowed to send changes back.

Integration direction
ServiceTitan
Martini
Salesforce
Example Mapping
ServiceTitan FieldCanonical FieldTarget Field
Customer.idsourceCustomerIdExternal customer ID
Customer.namecustomerNameAccount name
Location.addressserviceAddressService address
Job.statusserviceJobStatusJob status
Martini implementation pattern

Martini retrieves changed objects through paginated REST requests or processes supported event notifications, joins related identifiers without relying on display names, applies ownership and status rules, and performs idempotent Salesforce writes. Transient API failures are retried, while mapping and validation failures are routed to an exception process.

Martini capabilities used
  • API consumption
  • scheduled workflows
  • webhook triggers
  • data mapping
  • business rules
  • error handling

Pattern 2: Synchronize invoices and payments to accounting

When to use this pattern

Use this pattern when billing data must move from field-service operations into NetSuite or QuickBooks Online. Processing can be triggered by a schedule or a business-defined billing milestone and should maintain accounting identifiers and status.

Integration direction
ServiceTitan
Martini
NetSuite or QuickBooks Online
Example Mapping
ServiceTitan FieldCanonical FieldTarget Field
Invoice.idsourceInvoiceIdExternal invoice ID
Invoice.customerIdcustomerReferenceCustomer reference
Invoice.totalinvoiceAmountTransaction total
Payment.idsourcePaymentIdExternal payment ID
Martini implementation pattern

A Martini workflow retrieves Invoices, Payments, Customers, and related Locations, validates billing status, transforms the ServiceTitan model into the target accounting model, and upserts records using stable identifiers. Failed postings are recorded with response details and retried or reconciled without duplicating successful transactions.

Martini capabilities used
  • API consumption
  • workflow orchestration
  • data mapping
  • validation
  • business rules
  • retry and reconciliation

Pattern 3: Process dispatch notifications

When to use this pattern

Use this pattern when operational teams need near-real-time notification of supported appointment or job events. Because ServiceTitan webhook coverage is event-specific, the required event and payload must be confirmed before implementation.

Integration direction
ServiceTitan
Martini
ServiceNow or Zendesk
Example Mapping
ServiceTitan FieldCanonical FieldTarget Field
event.idsourceEventIdIntegration event ID
Job.idserviceJobIdExternal job ID
Appointment.statusappointmentStatusTicket or task status
Appointment.startscheduledStartPlanned start
Martini implementation pattern

Martini receives the notification through an API or workflow trigger, validates authentication and payload shape, deduplicates the event, retrieves the current Job or Appointment, and creates or updates the target task or ticket. Bounded retries cover transient retrieval and downstream failures, while unsupported event types are rejected or logged for review.

Martini capabilities used
  • API exposure
  • webhook consumption
  • validation
  • deduplication
  • workflow orchestration
  • error handling

Pattern 4: Load operational data into a warehouse

When to use this pattern

Use this pattern for reporting, technician utilization, revenue analysis, service-level analysis, and cross-system analytics. It is appropriate for Customers, Locations, Jobs, Appointments, Technicians, Invoices, and Payments when direct ServiceTitan database access is not available.

Integration direction
ServiceTitan
Martini
Snowflake or analytics database
Example Mapping
ServiceTitan FieldCanonical FieldTarget Field
Job.idserviceJobIdjob_id
Appointment.startappointmentStartappointment_start
Technician.idtechnicianIdtechnician_id
Invoice.totalinvoiceAmountinvoice_amount
Martini implementation pattern

A scheduled Martini workflow reads paginated API data, applies documented incremental filters where available, persists watermarks, normalizes object relationships, and loads warehouse tables in controlled batches. Periodic reconciliation identifies missed events or failed pages, and invalid rows are isolated for correction rather than blocking the full load.

Martini capabilities used
  • scheduled workflows
  • API consumption
  • pagination control
  • data transformation
  • database integration
  • monitoring and reconciliation

Applications commonly integrated with ServiceTitan

ServiceTitan can be connected to adjacent business applications when field-service, customer, financial, support, or analytics data must be shared. These are typical enterprise architecture targets rather than evidence of dedicated Martini connectors.

Application Scenario Direction Martini Pattern
Salesforce Synchronize ServiceTitan Customers, Locations, Jobs, and service activity with sales and account-management records. ServiceTitan → Martini → Salesforce Martini consumes paginated ServiceTitan REST responses or supported event notifications, maps stable ServiceTitan identifiers into Salesforce fields, and performs controlled create-or-update operations with retry and exception handling.
NetSuite Transfer Customers, Invoices, Payments, and financial status into accounting and ERP processes. ServiceTitan → Martini → NetSuite A Martini workflow retrieves billing objects after defined milestones, normalizes customer and accounting identifiers, applies posting rules, and records failed transactions for reconciliation.
QuickBooks Online Synchronize customers, invoices, payments, and related accounting information for service businesses using QuickBooks Online. ServiceTitan → Martini → QuickBooks Online Martini orchestrates ServiceTitan API consumption and QuickBooks Online API calls, transforms invoice and payment models, and uses idempotent upserts based on source identifiers.
HubSpot Share customer, lead, campaign, and service information between marketing processes and field-service operations. ServiceTitan → Martini → HubSpot Martini maps ServiceTitan customer and marketing data to HubSpot objects, applies ownership rules for bidirectional updates, and routes validation failures to an exception workflow.
ServiceNow Create or update operational tickets and notifications based on ServiceTitan jobs, appointments, or service exceptions. ServiceTitan → Martini → ServiceNow Martini receives supported ServiceTitan event notifications, retrieves the current Job or Appointment, maps it to a ServiceNow task or incident model, and retries downstream writes with deduplication.
Zendesk Give support teams visibility into customer locations, jobs, appointment status, and service history. ServiceTitan → Martini → Zendesk A scheduled or event-driven workflow retrieves current ServiceTitan data, transforms it into Zendesk customer and ticket context, and uses stable identifiers to prevent duplicate updates.
Snowflake Load operational ServiceTitan data for historical reporting, reconciliation, and cross-system analytics. ServiceTitan → Martini → Snowflake Martini runs scheduled paginated extraction workflows, applies documented incremental filters where available, normalizes related object identifiers, and loads warehouse-ready datasets with checkpointing.
Power BI Provide dashboards for revenue, jobs, appointments, technician performance, and service operations through a reporting layer. ServiceTitan → Martini → Power BI Martini synchronizes ServiceTitan data to a supported warehouse or reporting store, applies business transformations, and exposes a consistent dataset for Power BI consumption.

How to build a ServiceTitan integration in Martini

Objective

Register the ServiceTitan application and prepare environment-specific OAuth 2.0 credentials, tenant identifiers, application keys, and permissions.

Instructions in Martini

  • Store client credentials, secrets, tenant identifiers, and application keys in Martini secrets or environment configuration.
  • Keep production and integration environment values separate.
  • Configure the required ServiceTitan request headers and token behavior without embedding secrets in mappings or logs.

Objective

Select a scheduled, event-driven, or API-led entry point based on the required synchronization latency and the ServiceTitan event coverage available to the tenant.

Instructions in Martini

  • Use a scheduler for initial loads, recurring synchronization, or reconciliation.
  • Use a webhook-facing API or workflow trigger only for confirmed ServiceTitan event types.
  • Define a checkpoint, watermark, or deduplication key before processing begins.

Objective

Consume the relevant ServiceTitan REST API domain and retrieve complete object data while respecting pagination and consistency behavior.

Instructions in Martini

  • Request pages or documented incremental ranges from the required API domain.
  • Persist progress after successful processing so interrupted runs can resume.
  • After a webhook, retrieve the current Customer, Job, Appointment, Invoice, or Payment when the notification does not contain the full object.

Objective

Coordinate retrieval, validation, transformation, target writes, exception routing, and checkpoint updates in a maintainable Martini workflow.

Instructions in Martini

  • Separate event receipt from slower downstream processing where appropriate.
  • Apply bounded concurrency and throttling to avoid excessive ServiceTitan requests.
  • Use reusable API invocation and authentication logic for common ServiceTitan calls.

Objective

Convert ServiceTitan JSON objects into a canonical model and then into the target application's schema.

Instructions in Martini

  • Preserve ServiceTitan identifiers and relationships between Customers, Locations, Jobs, Appointments, and financial objects.
  • Normalize dates, statuses, addresses, and accounting values according to target requirements.
  • Validate required fields and isolate malformed objects for review.

Objective

Enforce ownership, status, timing, and eligibility rules before writing data to downstream systems.

Instructions in Martini

  • Define which system owns customer, appointment, job, and financial fields.
  • Use event type, object status, or billing milestone to control downstream actions.
  • Make writes idempotent and use stable identifiers instead of names or addresses.

Common ServiceTitan data objects used in integrations

ObjectTypical UseCommon target systemsMartini handling
CustomersSynchronize customer accounts and contact information with sales, support, and accounting applications.Salesforce, HubSpot, NetSuite, QuickBooks Online, ZendeskMartini retrieves or receives references to Customers, validates required fields, maps stable identifiers, and performs idempotent downstream upserts.
LocationsRepresent service addresses associated with Customers and support dispatch and service-history processes.Salesforce, Zendesk, Snowflake, operational databasesMartini preserves the Customer and Location relationship, normalizes address fields, and routes incomplete or conflicting addresses for review.
JobsRepresent service work orders or jobs performed for a Location.Salesforce, ServiceNow, Zendesk, SnowflakeMartini retrieves the current Job after an event or during a scheduled sync, applies status and ownership rules, and writes a canonical service-work model.
AppointmentsRepresent scheduled visits associated with Jobs and support dispatch notifications.ServiceNow, Zendesk, Salesforce, analytics platformsMartini maps appointment timing and status, deduplicates event-driven updates, and retries retrieval when webhook delivery precedes eventual consistency.
TechniciansRepresent field employees or technicians assigned to Jobs and Appointments.Snowflake, Salesforce, Power BI, operational databasesMartini synchronizes technician identifiers and attributes, applies incremental filters where documented, and preserves relationships to Jobs and Appointments.
InvoicesRepresent billing documents associated with completed work.NetSuite, QuickBooks Online, Snowflake, Power BIMartini transfers invoice data after business-defined billing milestones, maps accounting identifiers, and records processing status for reconciliation.

Authentication and security considerations

OAuth 2.0 application security

ServiceTitan integrations use an application registered in the developer portal, OAuth client credentials, access tokens, a tenant identifier, application identification, and appropriate permissions or scopes. Exact headers and credentials can vary by API environment and version.

Credential management

  • Store OAuth credentials, tenant identifiers, application keys, and secrets in Martini secrets or environment configuration.
  • Keep production and integration environment credentials separate.
  • Do not place credentials in mappings, source code, static payloads, or operational logs.
  • Restrict API permissions to the ServiceTitan domains and operations required by the workflow.

Operational considerations for ServiceTitan integrations

Rate limits and retries

Confirm ServiceTitan rate limits for each API domain and tenant. Use bounded concurrency, throttling, and retry with backoff for transient failures and retryable HTTP 429 responses.

Pagination and checkpoints

Process list responses page by page and persist the last successful page, cursor, or synchronization watermark. Do not assume a fixed page size, and test behavior when records change during a long-running synchronization.

Events and idempotency

Webhook deliveries may be duplicated, and a notification may arrive before the referenced object is fully available. Deduplicate events, use stable ServiceTitan identifiers for upserts, and retry object retrieval with bounded backoff.

Schema and reconciliation

Keep ServiceTitan API versions explicit, validate required fields, tolerate additive fields where practical, and test mappings when enumerations or nested structures change. Use periodic reconciliation and an exception process to detect missed events or failed incremental requests.

Why use Martini instead of scripts or point-to-point integrations?

Orchestration beyond point-to-point code

Martini provides a maintainable workflow layer for authenticating to ServiceTitan, consuming paginated REST APIs, receiving selected webhook events, applying business rules, and coordinating writes across multiple target systems.

Reusable integration logic

Shared authentication, API invocation, validation, mapping, retry, and exception-handling logic can be reused across ServiceTitan workflows instead of being duplicated in scripts.

Operational control

  • Separate webhook receipt from asynchronous business processing when workloads are slow or bursty.
  • Persist checkpoints, deduplication keys, and reconciliation state.
  • Centralize transformations between ServiceTitan objects and canonical or target models.
  • Support monitoring, troubleshooting, and controlled deployment of integration changes.

Frequently asked questions

How can ServiceTitan be integrated with enterprise systems?

ServiceTitan can be integrated primarily through its versioned REST APIs, which expose operational, customer, dispatch, accounting, inventory, marketing, payroll, and related data as JSON over HTTPS. Selected business events can also produce webhook-style notifications. OAuth 2.0 application authentication, tenant identification, application identification, and appropriate permissions are required.

Can Martini integrate with ServiceTitan?

Yes. Martini can consume ServiceTitan REST APIs, receive supported ServiceTitan webhook notifications, orchestrate scheduled or event-driven workflows, transform data, and write results to enterprise applications, databases, or analytics platforms.

Do I need a connector to integrate ServiceTitan with Martini?

No dedicated ServiceTitan connector is required. Martini can integrate using ServiceTitan's confirmed native mechanisms, including REST APIs, OAuth 2.0 authentication, pagination, and supported webhook notifications.

Is there any extra Lonti cost to integrate ServiceTitan with Martini?

Lonti does not charge an additional per-connector or per-vendor fee to integrate ServiceTitan. The integration is subject to the provisioned capacity of the Martini environment. Separate costs may apply from ServiceTitan, cloud infrastructure, databases, or other third-party systems based on subscription, usage, and deployment model.

Which ServiceTitan integration methods should architects use?

REST APIs are the primary documented mechanism for new integrations. Use webhook-style notifications for selected supported events when near-real-time processing is needed, and use scheduled paginated synchronization or reconciliation for broader coverage. GraphQL and SOAP APIs were not confirmed for ServiceTitan.

Are ServiceTitan webhooks available for all object changes?

No. ServiceTitan webhook-style notifications are available for selected business events, but coverage is event-specific. Confirm the event type, creation or update behavior, payload identifiers, subscription requirements, retry behavior, and delivery guarantees for the tenant and API version.

How does synchronization with ServiceTitan handle pagination and duplicates?

Martini can process ServiceTitan list responses page by page, persist cursors or watermarks, and use documented date or modification filters where available. Webhook workflows should deduplicate using an event identifier or a combination of event type, object identifier, and timestamp, while downstream writes should use stable ServiceTitan identifiers for idempotent upserts.

Can Martini expose an API façade for ServiceTitan data?

Yes. Martini can expose a controlled REST API that validates callers, invokes ServiceTitan workflows, applies mappings and business rules, and returns a canonical response. This can shield consumers from ServiceTitan-specific authentication, pagination, object relationships, and version details.

Related Martini documentation

APIs

Workflows

Transformation

Security

Operations

Connect ServiceTitan with your enterprise systems

Use Martini to build secure, maintainable ServiceTitan integrations that combine REST API consumption, selected event notifications, scheduled synchronization, data transformation, and workflow orchestration.

EXPLORE MARTINI
BOOK A DEMO