Operations orchestration, every capability typed and reachable.
Sync · Validate · Orchestrate · Ship
Start here New? Watch the 1-minute explanationKnow your way around? Jump straight in:
What is this?
The point is the workflow in the field, delivered to the worker's handset over rich messaging — RCS, Apple Messaging for Business, WhatsApp, and SMS. That conversational thread is the primary delivery channel; the mobile PWA and the web runner are the backstop. Everything you build through this API exists to feed and consume that field workflow.
ServiceProof is an operations orchestration platform — not a system of record. Data flows through ServiceProofSync, our near-real-time, intelligent, auto-merging, bi-directional live data synchronization engine that runs on-prem or server-side: it keeps your ERP / CMMS / ServiceTitan / WMS in lockstep with the platform without polling. Humans edit through forms; field workflows collect new state; every change flows back through the same engine to the systems-of-record. We enrich, validate, route, and surface; we don't replace.
Every capability is API-first, MCP-ready, and consistent across the wire. The form an office user fills in is the same write endpoint your integration POSTs against. The validation rules, locked defaults, and conditional visibility are identical. One contract, two audiences.
The Eleven Pillars
Why it's built this way
Most platforms ask you to integrate first, then read state back out. We flip it. When a field tech taps started job, paused for parts, or delivered on their handset, that tap is the data — a timestamp, a photo, a signature, a GPS fix, attached to the entity, queryable forever, with nothing to read from and nothing to reconcile. That posture is why the platform is shaped the way it is, and why the API is shaped the way it is.
Synced in from ServiceTitan / ERP / CMMS, enriched by field workflows + office forms, pushed back out on milestone completion. We enrich, validate, route, and surface — we don't replace your systems of record.
Pillar 3 — the Context Engine — hydrates an anchor record's whole neighborhood (parents, children, lookups, scoped reports) into one [[ ]] bundle every workflow, form, surface, and email reads identically. One definition, every surface.
The integration floor is a job-number key, an outbound webhook on milestone completion, and a PDF proof packet to the customer. No deep two-way sync required to get value on day one.
The multi-section form an office user fills in is the exact endpoint your integration POSTs against — same validation, locked defaults, conditional-visibility-aware required checks, composite-key inheritance.
A workflow is authored once and rides the field three ways — RCS / Apple Messaging / WhatsApp / SMS over Infobip first, the mobile PWA and web runner as the full-featured fallback when a step can't render in chat.
Every Studio action is a friendly-named REST endpoint, and the menu hierarchy doubles as an MCP agent's tool dictionary. An agent can author a surface or run a report the same way a person can.
The platform's own intelligence
Pillar 3 isn't just a token resolver — underneath it is the Context Truth Layer: a persisted, change-aware intelligence the platform builds about how your data connects. It's 100% SQL/C#. An AI agent doesn't have to guess; it reads what the platform already discovered. That's the difference between an agent that fumbles and one that runs your operation like a dream — and most of it works with no AI key at all.
Every hydrate is cached per (definition, anchor) and re-served only when its source rows haven't moved — a freshness stamp, never a TTL, so a warm hit is never stale. Edits self-correct; a background pack pre-warms active users. You manage none of it.
Every hydrate harvests the keys a user works within (CustomerNumber / WorkOrderNumber / EquipmentNumber) into a per-user map with confidence. An agent calls known_keys first and hydrates straight off known truth — no re-lookup, no guessing.
POST /api/v1/context/recommend reads your schema and drafts ready-to-save relationship maps. The loop is recommend → save → hydrate — no binding grammar to learn. The same capability is a Copilot/MCP tool, and an optional AI pass refines it.
Most tenants run without an AI subscription, so the platform's deterministic ranking + key/name compare powers conversational add / list / relate / query over messaging with zero AI. When a tenant does bring a key, the AI stands on this same intelligence.
An MCP agent can resolve_identity a person (an employee key, an email) to their platform user and pass acting_as to see their worklist — “show me Alan's dispatches” — then revert. Read-only scoping through the identity bridge; no privilege change.
A context can pull a saved cross-entity report — aggregates, time-travel, the works — and land its rows addressable, scoped by inner Entity_Property, so [[Slot[0].Customer_OrgName]] just works alongside your parents, children, and lookups.
The Platform Surfaces
Schema, data, forms, and the field + messaging layers — each reference doc stands alone, so you shouldn't need to bounce between them to do one thing.
Design the shape of your data. Entities composed of typed properties, language displays, catalog import.
Single + bulk upsert, list, pivot, views, per-instance variance and time-travel against the schema you designed.
Chained joins, conjunctive filters, aggregates (SUM/COUNT/AVG/MIN/MAX), variance over cadenced snapshots.
The most user-facing surface. Hierarchical multi-section, atomic multi-save, validation parity with the Portal.
Workflow + step CRUD, branching, duplication, reordering. Field-side companion to your back-office data.
Upload, signed URLs, stream-through proxy, Azure Blob / S3 / Google Drive / SFTP across 14 provider types.
Create, list, update preferences + contacts, lock/unlock, find-or-create with auto-provisioning.
Provision tenants, configure SMTP / languages, send invites, manage tenant-wide policies.
Pillar 3 — the logic layer. Hydrate an anchor record's related data (parents, children, lookups, scoped reports) into one [[ ]] bundle every other surface reads.
Pillar 8 — tenant-authored pages from one LayoutJson that render on Portal + Mobile + RCS. 35 section kinds, 5 anchor sources. Author once, render everywhere.
Pillar 10 — send + read over WhatsApp (live) / RCS / AMB / SMS via Infobip. Text, buttons, list, CTA-URL, image, location, plus the unified inbound log. The handset delivery layer.
The send → await → poll → end agent loop. converse (send + durable ordered inbox) and ask (bounded inline wait for a confirm / approve / proof reply).
Pillar 9 — install + configure trigger-driven packs and read the Action Center run log. 10 trigger types (OnDemand / Timer / Webhook live); run, simulate, inspect every step.
Offline-first IndexedDB + sync outbox, optimistic UI, GPS + geofence, a forms runner with binary capture, metro-tile home + drawer menu. The full-featured workflow backstop.
Read these four first
Twenty minutes here saves hours of trial-and-error later. UTC always, friendly names everywhere, language fallback by design.
Token → whoami → one working write. Five minutes. Your first round-trip end-to-end.
Session tokens vs long-lived API keys. Scopes, role flags, rotation, what the bearer carries internally.
UTC dates with Z, friendly idOrName, pagination, error envelope, language fallback.
Tenant vs tenantUser vs user, entity vs instance vs property, workflow vs step. Small file, big payoff.
Tooling
Treat them as the canonical "here's a working integration" and copy the patterns that apply.
Drop in your API key, pick any of 424 endpoints from the Postman tree, fire a real request, see the response. No tool install needed.
80+ canonical request/response examples extracted directly from the integration test harness. Every JSON body verbatim from a passing assertion — copy-paste safe.
424 requests across 29 folders. Set baseUrl + apiKey and run anything in your terminal of choice.
Foundation .NET console + Windows Service. Fork the connector, deploy as a service, monitor via EventLog. Win / macOS / Linux.
11 real-world patterns end-to-end: webhook intake, nightly RowHash diff, multi-entity parent chain, time-travel, conflict detection.
Three-audience validator (UI + Copilot + integrators), Levenshtein suggestions, the discover → build → validate → save recipe, CI drift detection.
Hash-diff dirty detection, composite-key + parent resolution, bidirectional pull-then-push, locale-safe wire formatting, Serilog & EventLog.
Send and run conversations as a 3rd party over WhatsApp / RCS / Apple. The integrator path is one call — POST /api/v1/messaging/send with an API key — fire-and-forget, send-and-wait, or on-reply callback.
Every console harness, zipped from source. Six are self-contained — unzip, set --base-url + --token, dotnet run. Read the code, fork what fits.
Ready when you are
Five minutes, you have a token and a green response. An hour, you've shipped something real. Pick the door that matches where you are.