Integrations
Most carriers and vendors drive AuditCake through the REST API — but the API is only one way in and one way out. If your systems can't call it, or you'd rather AuditCake fit your existing workflow, audits can arrive and results can be returned through several other channels. This page is the menu.
Two edges, chosen independently
Every integration has an intake edge (how an audit arrives) and a delivery edge (how the finished result is returned). You pick one method for each; they don't have to match. Both are independent of your mode — Mode 1/2/3 decides who owns and operates the audit, the methods here decide how the data moves. So “Mode 3, Email intake, Custom delivery” is one fully-specified integration.
Intake — how an audit arrives
Whatever the method, it ends the same way: a canonical audit, created and entering the lifecycle immediately. What differs is who initiates, and whether you send AuditCake's shape or your own.
| Method | Direction | Format | What you do | Best when |
|---|---|---|---|---|
| API (recommended) | You send | AuditCake's | POST /audits in the canonical shape | Your systems can call HTTPS in our format |
| You send | Yours | Forward each new order to an address AuditCake gives you | You already email audit assignments | |
| Push | You send | Yours | POST or drop your native format (HTTP, file) to an AuditCake endpoint | Your system emits audits, but not in our shape |
| Poll | AuditCake fetches | Yours | Grant scoped read access to your system of record | Audits already live in a system AuditCake can reach |
API is the recommended path when your systems can call HTTPS — direct and self-service (see Create an audit). Email, Push, and Poll are there for when they can't: each is operated by AuditCake and set up with you once, with no canonical payload to build on your side: a small mapper, configured for your relationship, turns whatever you produce into an audit. Email is the email-transport flavor of Push — both hand your raw format to that mapper; Poll is the one where AuditCake fetches instead of you sending.
Inventory checks
Email, Push, and Poll intake all share one blind spot the API doesn't have: no delivery receipt. When you POST /audits you get a 201 and an audit code back, so you know it landed. When you email or drop a file, an order that never arrived looks exactly like an order you never sent.
An inventory check closes that gap. On a schedule you choose, you send a list of every audit you currently expect AuditCake to be working — a spreadsheet is fine. Each list is reconciled against the audits AuditCake actually holds for you as soon as it arrives, and anything on your list that never reached us is flagged to the auditors running your account.
| What you send | Requirement |
|---|---|
| The file | A spreadsheet (.xlsx, .xls, or .csv) attached to an email, from a consistent sender address |
| One row per audit | A header row naming the columns, then one row per audit you expect to be open |
| The key column | Your own order or control number — the same identifier you send at intake. This is what each row is matched on. |
| Helpful columns | Policy number, insured name, and order date. Used to describe anything missing so it can be chased. |
| Optional header lines | A report date and a total row count above the header. Both are checked against what was read, so a misread file is caught rather than trusted. |
Columns are matched by name, not position, so adding a column to your export won't break the check. The cadence is yours — weekly is typical; each list simply replaces the last.
What a clean result means. A check passes when every row on your list matched an audit AuditCake holds — in any state, including ones already finished. It is not a claim that your count equals the number still open: carriers normally keep an audit on their outstanding list until their own system closes it, so recently completed work stays listed for a while and that is not a discrepancy. The only failure is a row that matched nothing at all, which means the order never reached us — resend it, and the next list confirms it.
Inventory checks are configured by AuditCake per relationship, like the intake method itself. They are optional: an intake without one behaves exactly as it does today.
Delivery — how the result is returned
A finished audit reaches a terminal review state, and the delivery method takes over. Delivery is chosen independently of intake.
| Method | Direction | Payload | What you do | Best when |
|---|---|---|---|---|
| API | You pull | Canonical | GET /audits on your own schedule | You'd rather poll than host an endpoint |
| Webhook (recommended) | AuditCake notifies | Thin signal — you then pull | Register a URL + signing secret once | You want to know when an audit changes |
| Custom | AuditCake delivers | Your system's shape (full) | Tell AuditCake where results go and in what format | Results must land in a specific external system |
Webhook is the recommended default — you hear about changes (including completion) as they happen, rather than checking for them. API delivery is the read endpoints on your schedule (see Read & list audits) when you'd rather pull. Webhook and Custom are detailed below.
Webhook delivery
Polling the read API works. If you prefer, you can subscribe to change events instead: register one URL and AuditCake notifies you when an audit you own changes — completed, advanced to a new status, a figure updated. The notification is a thin signal, not the audit itself: it tells you which audit changed and how, and you fetch the authoritative record from the read API. One standing subscription covers all your audits and carries every kind of update — including the AI Scheduler's outreach events (see AI Scheduler) — each tagged by its event type.
POST https://your-system.example.com/auditcake-webhook
Content-Type: application/json
X-AuditCake-Signature: sha256=<hmac of the body with your signing secret>
{
"event": "audit.completed",
"auditCode": "A1B2C3",
"carrierControlId": "CTRL-2026-00042",
"status": "SENT_TO_CARRIER",
"rev": 7,
"occurredAt": "2026-06-13T18:04:00Z"
}
// → then GET /api/v1/audits/A1B2C3 for the full, current recordYour endpoint acknowledges with a 2xx; AuditCake signs every delivery and retries with backoff and an idempotency key, so a brief outage never drops an event. Ask AuditCake to register or change the URL and signing secret.
Custom delivery
When results must land in a specific external system in a specific shape — a SOAP upload, a partner API, a form — AuditCake runs a submit-back built for it: on completion it transforms the audit into that system's shape, delivers the full result, and reconciles the confirmation. This is the path for systems that can't accept a generic webhook. AuditCake builds and operates the integration; you tell it where results go and in what format.
Pairing intake and delivery
The two edges combine freely. Common pairings:
| Intake | Delivery | Typical fit |
|---|---|---|
| API | API | You can call HTTPS both ways |
| API | Webhook | You create audits programmatically and want results pushed as they finish |
| Custom | You email assignments and need results back in a specific system | |
| Poll | Custom | One system of record owns the whole round trip |
Setup
Every method except direct API is configured by AuditCake per relationship — there is no self-signup. Whichever you choose, it resolves to the same carrier, vendor, and key model: an intake audit is created under your relationship's scope, and a delivered result is returned on its behalf. Ask AuditCake to set up or change either edge.
Next: Create an audit →