A8gent
Build guide - ServiceTitan API

ServiceTitan custom automation without Zapier

ServiceTitan API access is plan-gated before you write a line of code. The plan gate, the client-credentials auth, the API surface, and the published limits.

A8gent
·

What you get from this guide

  • The plan gate on ServiceTitan API access, quoted from ServiceTitan's and Zapier's own documentation
  • The four credentials - client ID, client secret, tenant ID and app key - and where each comes from
  • The client-credentials auth flow, token lifetime, and why there is no refresh token
  • The documented default rate limits, including the reporting limit that breaks polling loops
  • An honest account of what we could not verify, because the developer portal renders client-side

The plan gate comes first

Search for ServiceTitan automation and you get Zapier. Zapier's own help centre, Zapier's blog, ServiceTitan's Zapier integration page, and a row of agencies writing about Zapier. It is a well-owned SERP and the content is not bad. It simply starts at step four.

Step one is that ServiceTitan API access is gated by your package, and if you are on the wrong one, none of the rest of this matters. ServiceTitan's help documentation for the Zapier integration states that only customers on The Works or legacy pre-packaging customers can use Zapier as it requires API access, which is included with these service agreements. Zapier states the same requirement from its side: a ServiceTitan account on The Works or Legacy package, because API access is only included with those service agreements. Both pages were readable in August 2026.

Read that carefully, because the framing on those pages hides the general rule inside a Zapier-specific sentence. The gate is not on Zapier. The gate is on API access. Zapier needs API access, so Zapier is gated. Your n8n workflow needs API access, so it is gated identically. Writing your own service in Python does not route around it, because there is no unauthenticated path into a ServiceTitan tenant. This is the single most useful fact on this page and it is why so many "build a custom ServiceTitan integration" projects die in week one.

Check your own contract, not a blog post

Software packaging changes, and vendors rename tiers. Before you scope anything, ask your ServiceTitan account contact in writing whether your agreement includes API access, and get the answer in an email. This page is dated August 2026 and is a starting point, not a contract. If the answer is no, your realistic options are upgrading, using whatever native automation and reporting your tier does include, or building around ServiceTitan on the channels you control - phone, forms, messaging - rather than inside it.

There is a second, smaller gate on top: permissions. ServiceTitan's getting-started documentation for the V2 developer portal says an administrator must enable Generate API Application Key and Manage API Application Access on your user. An owner whose package includes the API can still be locked out of creating an app because nobody ticked those boxes.

The four credentials you need

Once you are through the gate, ServiceTitan's auth model is more moving parts than most field service APIs. There are four values, they come from two different places, and mixing them up produces authentication errors that do not tell you which one is wrong.

ServiceTitan API credentials and where each one comes from
CredentialWhere it comes fromHow it is used
Client IDServiceTitan: Settings, Integrations, API Application AccessSent in the token request body.
Client secretGenerated alongside the client ID in the same screenSent in the token request body. Shown once - store it in a secret manager.
Tenant IDDisplayed with the client ID and secret when you generate themIdentifies which ServiceTitan account you are acting on. Used in resource requests.
Application keyThe developer portal app you created, under KeysSent as the ST-App-Key header on every resource call.

The order of operations is not obvious from the screens. You create the application in the developer portal first, choosing which API scopes it needs and naming the tenants it may access, and copy its application key. Then, inside ServiceTitan, you go to Settings, Integrations, API Application Access, connect the new app, review what it is asking for and allow access - and that step is what produces the client ID, secret and tenant ID. ServiceTitan's getting-started article describes this two-step flow, including the "Connect New App" and "Allow Access" actions, as read in August 2026.

Treat the client secret and application key the way you would treat a password, because they are one. The API key and OAuth glossary entries cover the general handling rules. In practice: environment variables or a secret manager, never in a workflow node's plain text field, and rotate them when someone with access leaves.

How authentication actually works

ServiceTitan uses OAuth 2.0 with the client credentials grant. The developer portal documentation describes it as machine-to-machine, "user less access", and states it is currently the only supported flow. There is no user consent screen and no browser redirect, which makes it straightforward to automate - and there is one wrinkle that catches people.

There are no refresh tokens. The documentation states that ServiceTitan employs only access tokens and does not issue refresh tokens, because it supports only machine-to-machine calls under the client credentials grant. It also states that access tokens expire in 15 minutes, and recommends caching the access token rather than requesting a new one for every transaction, because ServiceTitan throttles requests for new access tokens. All as documented in August 2026.

That combination has a concrete design consequence. If your workflow requests a fresh token on every run and you run it often, you are hammering the token endpoint and you will get throttled - and the failure will look like an authentication problem rather than a rate problem. Cache the token with its expiry, reuse it until roughly a minute before it dies, and only then re-request.

Token request - shape only, confirm the exact host in the live docs

POST https://auth.servicetitan.io/connect/token
Content-Type: application/x-www-form-urlencoded

grant_type=client_credentials
&client_id={client_id}
&client_secret={client_secret}

# Integration environment uses the
# auth-integration host instead.
# Response carries an access token that
# expires in 15 minutes. No refresh token.

Resource call - both headers are required

GET {module base URL}/{path for your tenant}
Authorization: Bearer {access_token}
ST-App-Key: {application_key}

# Take the exact module base URL and path
# from the API reference inside the
# developer portal for your own tenant.

Both headers are mandatory. ServiceTitan's making-your-first-API-call documentation shows the Authorization: Bearer and ST-App-Key headers together, and notes that all calls must use HTTPS and that you should test in the integration environment before production. Sending a valid token without the app key fails, and the error will not necessarily say which header is missing.

The API surface: jobs, estimates, customers

Here is where this page is going to be less specific than you would like, and the reason matters more than the inconvenience.

What we could not verify, and why

ServiceTitan's developer portal at developer.servicetitan.io is a client-rendered application. When we fetched its pages in August 2026 to verify endpoint paths, the response contained essentially no readable text - just the application shell. Some documentation pages served from the partner-facing host did render, which is where the auth details above are quoted from, but the endpoint reference itself did not. We are therefore not printing exact endpoint paths, request shapes or field names for jobs, estimates and customers, because the only way to produce them would be to copy them from third-party blog posts, and third-party blogs disagreed with each other on those paths in our own search results. Log into the developer portal, open the API reference for your tenant, and take the paths from the source.

What we can say confidently is the shape of the surface, because it is consistent across ServiceTitan's own documentation and its module naming. The API is split into modules, each with its own base path, rather than being one flat namespace:

  • Job planning and management - jobs, projects and appointments. This is where a job's lifecycle lives, and it is the module most automations start with.
  • CRM - customers, locations, contacts, leads and bookings. Anything about who the work is for.
  • Sales and estimates - estimates, their line items and their approval state. The module behind unsold-estimate automations.
  • Accounting - invoices, payments and the export surface, if your automation touches money.
  • Reporting - saved reports, which have their own stricter limit and their own semantics.

The practical consequence of the module split is that a single business workflow usually crosses two or three modules. Following up an unsold estimate means reading the estimate from the sales module, the customer from CRM, and possibly checking whether a job was created in the job module. Plan your data mapping with that in mind - you will be joining across modules on ids, and the ids are the thing you should store in your own state table. The unsold estimate follow-up guide works through exactly that workflow in a platform-neutral way.

Published rate limits

ServiceTitan does publish default rate limits, in a help centre article rather than in the developer portal. As documented in August 2026:

ServiceTitan default API rate limits as documented in August 2026
API typeDocumented default limitWhat it means in practice
Regular APIs60 calls per second per application per tenantGenerous for event-driven work. Reachable by a bulk backfill loop with no pacing.
Reporting APIs1 of the same report per minute per tenantA repetition cap, not a volume cap. A polling loop on one report hits it on the second call.
Token endpointThrottled - no public number foundCache the access token. The docs advise caching precisely because new-token requests are throttled.

The reporting limit is the one that quietly breaks builds. It reads like a small number until you realise it is scoped to the same report: you cannot sit in a loop refreshing one report every ten seconds, no matter how few rows it returns. If your automation depends on report data, cache the result and drive your logic off the cache, or move to the resource endpoints instead.

Whatever the numbers say, build as though they will be hit. Honour 429 responses with exponential backoff rather than an immediate retry, pace bulk jobs deliberately instead of firing them as fast as the runtime allows, and put error handling around every call so a throttled request becomes a queued retry rather than a lost record. The rate limit entry covers the general pattern.

Direct API versus Zapier

Since the SERP for this query is entirely Zapier, it is worth being fair about when Zapier is the right answer. It often is. What it is not is the only answer, and it is not a way around the plan gate.

Choosing between Zapier and a direct API build on ServiceTitan
FactorZapierDirect API
Plan requirementNeeds ServiceTitan API access - The Works or legacy.Identical requirement. The gate is on the API, not the tool.
Time to first working automationHours. Connect, pick a trigger, map fields.Days. Auth, token caching, endpoint discovery, error handling.
Cost shapePer task. Predictable while volume is low, unpleasant when it is not.Build cost up front, then hosting. Volume barely moves the number.
Conditional logic and stateWorkable, but state between runs is awkward.Your own database. Follow-up sequences and dedupe become straightforward.
Error handlingWhat the platform gives you.Yours: retries, dead-letter queues, alerting you actually see.
Who can maintain itAn operations person can edit it.Someone who can read code, or the person you paid to build it.

The honest rule of thumb: if the automation is one trigger and one or two actions with no memory between runs, use Zapier and spend your effort elsewhere. If it needs to remember what it did last week, branch on business rules, or run at a volume where per-task pricing starts to hurt, build direct. Sequenced follow-up, de-duplication across systems and anything with its own state table all fall firmly on the direct-build side. The workflow automation and iPaaS entries define the categories if the vocabulary is new, and AI automation cost covers how to price the two options against each other.

Building a direct-API automation

The steps below assume the plan gate is cleared. They are deliberately about the plumbing, because the business logic on top is the same as any other field service automation.

1

Settle the package question in writing

Email your ServiceTitan account contact and ask whether your agreement includes API access. Do this before anything else. A scoped automation project that discovers the gate in week two has burned the discovery budget on nothing, and the answer takes a day to get.

2

Get the permissions turned on

Have an administrator enable Generate API Application Key and Manage API Application Access for the user who will create the app. Without them the developer portal will let you log in and then refuse to let you do anything useful.

3

Create the app against the integration environment first

The developer portal offers separate integration and production logins. Start in integration. Create the app, add the tenant IDs it may access, select only the API scopes your automation genuinely needs, and copy the application key. Over-scoping an app is the sort of thing that fails a security review later, and it costs nothing to be narrow now.

4

Connect and approve the app inside ServiceTitan

In ServiceTitan: Settings, Integrations, API Application Access, Connect New App, choose your application, review the requested access, allow it. Copy the client ID, client secret and tenant ID that this produces. The secret is shown once. Put all four values straight into a secret manager rather than a notes file.

5

Write a token helper with caching

One function that returns a valid access token: if the cached token expires more than a minute from now, return it; otherwise POST the client credentials to the token endpoint, store the new token with its expiry, and return that. Given a 15-minute lifetime and documented throttling on new-token requests, this small piece of code is what keeps a busy workflow from throttling itself into what looks like an auth outage.

6

Discover your endpoints from the portal, not from a blog

Open the API reference inside the developer portal, find the module you need, and copy the base URL and path from there. Test it with a single read in the integration environment and confirm the response shape against your own tenant's data before you write any mapping. Field names differ between accounts more than you would expect, because ServiceTitan tenants are heavily configured.

7

Decide events versus polling deliberately

If the developer portal offers event delivery for the objects you care about on your tenant, use it as the fast path. If it does not, or you cannot confirm it, poll on a schedule with a modified-since filter and keep a cursor in your own state table. Either way store the ids you have already processed so a replay or a double delivery does not produce a duplicate action - that is idempotency, and it is not optional in a system that touches customers.

8

Instrument it before you trust it

Log every request, response code and retry, alert on sustained 429s and on any auth failure, and put a plain-language weekly summary in front of whoever owns the process. An automation nobody can see is an automation nobody believes. The observability entry covers what is worth capturing.

Where these builds go wrong

  • Scoping the project before confirming the ServiceTitan package includes API access.
  • Assuming that avoiding Zapier avoids the plan gate. It does not - the gate is on the API.
  • Requesting a new access token on every run, then reading the resulting throttling as an auth bug.
  • Sending the Bearer token without the ST-App-Key header, or the reverse.
  • Copying endpoint paths from third-party blog posts instead of the developer portal reference.
  • Polling a report in a tight loop, against a documented limit of one of the same report per minute per tenant.
  • Building straight against production instead of the integration environment.
  • Requesting every scope on the app because it is easier than working out which ones are needed.
  • No idempotency key, so a replayed event sends a customer the same message twice.
  • Storing the client secret in a workflow node's plain text field where anyone with editor access can read it.

If you run ServiceTitan and your package includes API access, you have a genuinely capable platform to automate against - the modules are well separated and the auth model, once cached properly, is boring in the good way. Sector context is on the HVAC and plumbing automation page. If your package does not include it, say so early and look at what a comparable build looks like on Jobber or at the channels outside your field service system. Either way, automation services explains how we scope and hand over, and the free automation audit will tell you which side of the gate you are on before you spend anything.

FAQ

Do I need a specific ServiceTitan plan to use the API?
Yes, and this is the thing that stops most projects. ServiceTitan's own help documentation for its Zapier integration states that only customers on The Works or legacy pre-packaging customers can use Zapier as it requires API access, which is included with these service agreements. Zapier's own setup article says the same thing from the other side: it requires a ServiceTitan account on The Works or Legacy package, because API access is only included with those service agreements. That gate applies to the API generally, not to Zapier specifically - Zapier is simply one consumer of it. Both were readable in August 2026; confirm against your own contract because packaging changes.
Can I build ServiceTitan automations without Zapier?
Yes. Zapier is one client of a documented REST API, not the only way in. If your package includes API access you can call ServiceTitan directly from n8n, Make, a scheduled script, or your own service, and you get things Zapier cannot give you: multi-step logic in one place, your own state storage, no per-task pricing, and full control over error handling. The important caveat is that dropping Zapier does not get you around the plan gate - the gate is on the API itself.
What credentials does the ServiceTitan API need?
Four things. A client ID and a client secret, generated in ServiceTitan under Settings, Integrations, API Application Access. A tenant ID, which identifies the ServiceTitan account you are calling on behalf of and is shown alongside those credentials. And an application key from the developer portal app you created, passed as the ST-App-Key header. Documentation for the first three is in ServiceTitan's help centre and Zapier's setup article; the ST-App-Key header is documented in the developer portal's first-API-call page, all as read in August 2026.
How does ServiceTitan authentication work?
OAuth 2.0 client credentials, machine to machine. You POST client_id, client_secret and grant_type=client_credentials as form-encoded data to https://auth.servicetitan.io/connect/token for production, or the auth-integration host for the integration environment. The developer portal documents that ServiceTitan employs only access tokens and does not issue refresh tokens, because it supports only machine-to-machine calls, and that access tokens expire in 15 minutes. It also recommends caching the token rather than requesting a new one per transaction, because request throttling applies to new access tokens.
What are the ServiceTitan API rate limits?
ServiceTitan's help documentation on default API rate limits states 60 calls per second per application per tenant for regular APIs, and 1 of the same report per minute per tenant for reporting APIs, as documented in August 2026. The reporting limit is the one that surprises people: it is not a volume cap, it is a repetition cap on the same report, and a naive polling loop over a report will hit it immediately. Treat both as defaults to confirm in the live docs rather than as guarantees.
Which endpoints cover jobs, estimates and customers?
ServiceTitan's API is split into modules with separate base paths - job planning and management for jobs, projects and appointments, CRM for customers, locations, leads and bookings, and a sales and estimates area for estimates. We are not going to print exact endpoint paths here, because the ServiceTitan API reference is a client-rendered application that our checks could not read as static text in August 2026, and a path copied from a third-party blog post is how you spend an afternoon debugging a 404. Log into the developer portal, open the API reference for your tenant, and take the paths from there.
Does ServiceTitan support webhooks or do I have to poll?
ServiceTitan does publish integration mechanisms beyond simple request-response, but we could not read the current webhook or event documentation as static text because the developer portal renders client-side, so we are not going to describe its event catalogue from memory or from third-party summaries. Check the developer portal directly. Design defensively in the meantime: a scheduled poll over a modified-since filter is slower but works on every account, and if events are available on yours you can add them as a fast path later without redesigning.
Is a direct API build worth it over Zapier for a small contractor?
It depends on volume and logic. If you need three simple one-to-one syncs and your task volume is low, Zapier is cheaper than paying someone to build and maintain a service. Once you need conditional branching, your own state between steps, retries you control, or your task count starts driving the bill, a direct API build usually wins on both cost and reliability. Our automation cost page covers how to think about that trade-off, and the free audit will tell you honestly which side of the line you are on.

Done for you

Want a ServiceTitan automation built directly against the API, not stitched together in a Zap?

We check the plan gate first, then build against ServiceTitan's API with cached auth, real error handling and reporting you can read. If your package does not include API access, we will tell you in the free consult rather than after the invoice.

The consult is free, and you keep whatever we build.

Keep building

The rest of the cluster