JobTread API: Contractor Workflows Carly Can Run
An estimate has been open for three days; Carly can send the useful follow-up, notify the salesperson when the customer raises a concern, and stop the sequence the moment the status changes. Around JobTread, Carly can also chase receivables, share payment and field updates, organize daily logs, and brief the team across email, calendars, tasks, and Slack.
JobTread’s API is open to every subscriber — “The API is available for anyone to use,” per their own help docs — and there’s no API-specific fee. Pricing is $199/month base plus per-user, and the pricing page states all features are included.
Two things make it unusual. The query language, Pave, defeats generic integration tooling in a way that’s worth understanding before you commit. And despite that, JobTread ships 42 webhook events that are self-serve and provisionable through the API itself — a better event surface than most construction software twice its size.
Contractor workflows Carly can run
JobTread fires an event for all of these already. Carly listens and runs the work that should follow:
- Invoices that chase themselves. An invoice goes out Friday, nobody follows up, and it quietly ages 40 days.
documentSentcan start a chase sequence that stops the moment payment lands. - Payments that update everyone. A payment comes in and the job’s status, the customer’s confirmation, and the books all need to agree — usually done by hand, or not at all.
- Estimates that don’t go cold. A quote sits unopened for five days. In residential construction that’s most of the window where you’d still have won it.
- Daily logs that reach the client. A log gets filed from the field and the homeowner never sees it, which is where most “I had no idea what was happening” complaints come from.
The invoice one is usually where the money is. Chasing receivables is the job every contractor knows they should do and nobody has time for.
For example:
When an estimate has been sent but not accepted after three days, send a useful follow-up, notify the salesperson if the customer replies with a concern, and stop the sequence the moment the estimate changes status.
Or:
Every morning, send the owner a brief covering unpaid invoices, payments received yesterday, estimates going cold, jobs missing a recent daily log, and the five items that need attention today.
Pave is GraphQL-like, which is not the same as GraphQL
This is the connection problem Carly handles before any of those workflows can run.
Everything goes to one endpoint: POST https://api.jobtread.com/pave. JobTread’s docs describe Pave as “a query language similar to GraphQL that allows you to query exactly what you need, and nothing more.”
The similarity ends where it matters. Pave queries are JSON objects, fields are requested as {} leaves, and inputs go under a $ key. So:
- REST tooling can’t express it. One URL, one verb, no resource paths. OpenAPI generators, generic REST connectors, and most no-code HTTP blocks model APIs as path plus method, and there’s nothing here to map.
- GraphQL tooling can’t either. There’s no introspection and no SDL, so GraphQL clients are equally stuck.
- Auth is in the request body, at
query.$.grantKey— not a header. That alone breaks connectors that only offer bearer or header auth configuration.
The practical upshot: you’re hand-writing an adapter. That’s not a dealbreaker, but it’s a real cost that “JobTread has an API” doesn’t convey.
One upside — the schema is queryable without credentials. {"query":{"version":{}}} returns a version string with no key at all, which makes exploration easier than the lack of a published spec suggests.
Getting a grant key, and the way it dies
Connect Carly under Settings → Integrations → API → Grants (app.jobtread.com/settings/integrations/api/grants). Webhooks live one tab over under the same path.
The key is shown once on creation.
The expiry rule is the thing to design around: grant keys expire after 3 months of inactivity. Not age — inactivity. A key in regular use never lapses. What this quietly kills is precisely the integrations least likely to be watched: quarterly reporting jobs, seasonal workflows, dormant fallback paths. Nothing documents an advance warning, and when it does lapse the error is "Supplied key is invalid or expired" — which conflates a dead key with a wrong one.
Worth not confusing with the API: JobTread’s Integration Partner program is application-gated with possible additional fees. That’s for vendors publishing a public integration, not for a contractor using their own data. It’s easy to read that page and conclude the API is gated when it isn’t.
Rate limits exist but aren’t knowable
JobTread’s FAQ says only that “every grant key can only make a certain number of requests to the API in a given time frame, to protect the site from abuse.”
No numbers are published — and /pave returns no rate-limit headers of any kind, no RateLimit-*, no Retry-After. So there’s no ceiling to design against and no runtime signal to back off from. You find the limit by hitting it. Build conservative pacing in from the start.
What it writes
This broad write surface is what lets Carly finish the workflow in JobTread instead of stopping at an alert.
Full create, update, and delete across accounts (customers and vendors), contacts, jobs, locations, documents, document payments and recipients, daily logs, tasks, time entries, files, forms and submissions, cost codes and items, custom fields, payments, plans, roles, memberships, users, dashboards, webhooks, and workflows.
Three things that will shape your code:
- Estimates and invoices are the same object. There is no
createInvoice. You callcreateDocumentwithtypeset tocustomerInvoice,customerOrder,vendorOrder,vendorBill, orbidRequest. - Creating a job has a mandatory chain. The docs are explicit: a location is required to create a job, and a customer is required to create a location. A new job for a new customer is three sequential writes.
sendDocumentgenuinely emails the document to a recipient. That’s real send capability, not draft-only.
File upload is a two-step flow — createUploadRequest, PUT to the returned URL, then createFile.
The 42 events
These events are the start signals for Carly’s real-time JobTread workflows.
Webhooks are self-serve and API-provisionable via createWebhook({ eventTypes, organizationId, url }), which matters: an integration can register its own subscriptions instead of walking a contractor through a settings UI.
The complete list, by object:
| Object | Events |
|---|---|
| Account (customer/vendor) | created, updated, deleted |
| Contact | created, updated, deleted |
| Job | created, updated, deleted |
| Location | created, updated, deleted |
| Document (estimate/invoice/order/bill) | created, updated, deleted, sent |
| Document payment | created, updated, deleted |
| Document recipient | created, updated, deleted |
| Payment | created, updated, deleted |
| Daily log | created, updated, deleted |
| Task | created, updated, deleted |
| Time entry | created, updated, deleted |
| Comment | created, updated, deleted |
| File | created, updated, deleted |
| Form submission | created, updated, deleted |
documentSent and the payment events are the commercially useful ones — invoice sent and payment received are both directly triggerable, which is exactly where contractor cash flow leaks.
What isn’t documented: the payload shape, whether deliveries are signed, and the retry policy. JobTread’s docs say only “a detailed POST request.” Don’t assume signature verification is available until you’ve confirmed it on a live account.
JobTread also ships its own workflow engine — createWorkflow with trigger types and actions, plus run and rerun controls — so there’s in-app automation before you reach for anything external.
JobTread’s AI Connector is an MCP server
Worth knowing because it changes what “connect AI to JobTread” means here. JobTread launched an AI Connector in April 2026 built on MCP, working with Claude or ChatGPT, and available to customers at no additional cost. A follow-up in June reported it as their fastest-growing integration ever. (Those adoption figures are JobTread’s own and unaudited.)
So unlike most construction software, there’s a first-party path to querying your job data from an assistant. What that path does not do is act on its own.
MCP servers wait to be asked. The protocol has no scheduler and no event mechanism — its maintainers acknowledge that change detection today means polling — so an MCP connection can answer a question but cannot notice something on its own.
Which is the gap the 42 webhooks exist to fill — and the reason the two are complementary rather than redundant.
The gotcha that will embarrass you
notify defaults to true. Any Carly workflow used for imports, testing, or backfills should explicitly set it to false. It’s a root-level input, and JobTread documents it as “set to false to suppress notifications for this request.”
Meaning: a bulk import or a historical backfill will fire real notifications to real customers and real crew unless every single call opts out. This is the fastest way to spam a contractor’s entire client list on day one of an integration. Set notify: false on anything that isn’t a genuine live action.
Two smaller ones:
- You must explicitly request
idor you get nothing back. Pave returns strictly what you name, so omittingidproduces an “id field required” error that reads like a validation bug. - The
wheresyntax is nested positional arrays —[["account","name"], "=", "Test Name"]— withand/ornesting and a separatewithblock for custom fields. Easy to malform, and the errors are terse.
Unlike much construction software, JobTread’s Zapier app is real — the listing returns genuine content with around 21 triggers and 24 actions, including a raw API-query escape hatch. (Note the slug is jobtread, unhyphenated; the hyphenated URL 404s.)
How Carly completes the JobTread workflow
An invoice sent, a payment received, a daily log filed from the field — JobTread fires all of them. What usually happens next is a notification in an app someone checks at the end of the day.
The AI Connector closes half the gap by letting you ask about job data. It doesn’t close the other half. The Carly JobTread integration page covers what connecting looks like and which of the 42 events are worth wiring first.
“Summarize which jobs are over budget” is well within what Claude will do through JobTread’s MCP connector. “The moment an invoice goes 30 days out, chase it and log the attempt” is not, because MCP has no trigger mechanism — the webhook does, and nothing on the assistant side is listening for it.
Carly sits on that side:
- Fires on the JobTread webhook —
documentSent,paymentCreated,jobUpdated,formSubmissionCreated - Runs the whole response in one flow — read the document, pull the customer, draft the message, send it, log the activity
- Actually sends — Gmail and Outlook, with attachments
- Handles Pave’s unusual API shape inside the native connection — JobTread’s auth and query structure don’t fit a standard HTTP block, but Carly takes care of that plumbing when you connect JobTread from the Integrations tab
Because JobTread exposes an API, you can connect it natively to Carly from the Integrations tab with your grant key. Carly can then use JobTread in on-demand, recurring, and event-triggered workflows. AI agents start at $35/month, and workflow steps that don’t use AI run free.
Frequently Asked Questions
Is the JobTread API free?
There’s no API-specific fee. JobTread’s help docs state the API is available for anyone to use, and the pricing page says all features are included with a subscription — $199/month base plus per-user pricing that scales down with headcount.
What is Pave?
JobTread’s query language. It’s GraphQL-like but not GraphQL: queries are JSON objects sent to a single /pave endpoint, with authentication in the request body rather than a header. That means neither REST nor GraphQL tooling works against it without a hand-written adapter.
Why did my JobTread API key stop working?
Grant keys expire after three months of inactivity. A key used regularly won’t lapse, but an integration that only runs quarterly or seasonally will silently die. The error message conflates expired and invalid keys, so it reads as a bad credential.
What webhooks does JobTread support?
Forty-two events across accounts, contacts, jobs, locations, documents, document payments and recipients, payments, daily logs, tasks, time entries, comments, files, and form submissions. Document sent and payment events are the most commercially useful. Webhooks can be created through the API rather than only the UI.
Does JobTread have an AI integration?
Yes — an AI Connector launched in April 2026, built on MCP and working with Claude or ChatGPT, included at no extra cost. It lets you query your job data from an assistant, but MCP has no trigger mechanism, so it responds to questions rather than reacting to events.
Why is my JobTread import sending notifications to customers?
The notify parameter defaults to true. Any bulk import or backfill will send real notifications to customers and crew unless you set notify: false on every call.
More: Construction AI · AI agents for ops · Best AI workflow automation tools · Claude + JobTread
Ready to automate your busywork?
Carly schedules, researches, and briefs you—so you can focus on what matters.
See what people say
"Before Carly, I relied on a Calendly link, but the whole process felt impersonal and not very professional. Carly changed that by handling all the back-and-forth, so I'm no longer stuck in endless email threads trying to line up schedules.
Now Carly reaches out to candidates, shares my real-time availability, lets them pick a slot, then sends a Zoom link and drops it straight into my calendar. She sends reminders to both of us before each call, which has significantly reduced no-shows and last-minute confusion.
On top of scheduling, Carly acts like a full executive assistant, sending me my schedule the night before so I can prepare for each call. It reminds me of the old x.ai assistant, but Carly is noticeably smarter, faster, and better suited to my healthcare recruitment business."
