Documentation hub

Integration docs that are detailed enough for builders and readable enough for operators.

Move from first batch to production controls with endpoint maps, workflow ownership, and compliance evidence guidance in one place.

Implementation tracks Workflow lifecycle API surface map Webhook model Control matrix FAQ

Local bootstrap

Run this once to bring up the full stack and open the dashboard flow.

bash

cd infra/docker && docker compose up --build -d
DATABASE_URL="postgres://anchrix:anchrix@localhost:5433/anchrix?sslmode=disable" \
  bash infra/scripts/seed_demo_data.sh
open http://localhost:3000/dashboard

Open full quickstart

Demo payouts per sample batch

Seeded CSV includes clean and flagged rows across multiple corridors.

Policy outcomes

Pass, warn, require review, and deny are enforced at evaluation time.

Route candidates per payout

Scored on cost, speed, compliance, and risk before recommendation.

Default RBAC roles

Viewer through owner with maker-checker boundaries built in.

Choose your implementation track

Different teams enter at different points. Pick the path that matches your immediate objective.

10 min

Sandbox In 10 Minutes

Create a batch, import payouts, run policy, approve, and export artifacts without custom setup.

Operators and product demos

Fast path using seeded org and demo tokens
UI and cURL flow for the same lifecycle

Open track

1 to 2 days

API Automation

Wire Anchrix into your internal operations tooling with org-scoped REST endpoints.

Backend and platform engineers

Batch lifecycle, policy, investigation, and audit endpoints
Deterministic workflow state transitions

Open track

Design now, ship with webhook beta

Webhook Strategy

Plan event-driven downstream actions for approvals, artifacts, and compliance operations.

Integrations and platform ops

Event catalog and payload shape guidance
Polling fallback pattern available today

Open track

Half-day initial modeling

Policy and Governance

Author and evolve DSL-based rules with version snapshots attached to every evaluation.

Compliance and risk teams

Rule outcomes mapped to operational behavior
Versioned policy snapshots in each audit chain

Open track

Immediate after approval

Audit and Exports

Generate evidence packets and accounting files directly from approved payout batches.

Finance operations and auditors

Self-contained HTML packet with timeline evidence
Accounting-friendly CSV export path

Open track

Review before go-live

Security and Legal

Understand auth boundaries, role control, and policy/legal references before production.

Security, legal, and leadership

Org scoping plus RBAC checks at API boundary
Append-only audit model and governance docs

Open track

Payout workflow lifecycle

Map each operational stage to a concrete endpoint and output so teams can coordinate handoffs.

01Step 01

Operator

Create Batch

POST /v1/batches

Draft batch ID created with org scope and initial audit event.

02Step 02

Operator

Import Payout Rows

POST /v1/batches/{id}/items:import

CSV rows validated and attached to the batch with normalization metadata.

03Step 03

Operator

Evaluate Policy and Routing

POST /v1/batches/{id}/evaluate

Rule outcomes, route decisions, and policy snapshot hash captured per item.

04Step 04

Analyst

Investigate Flagged Items

POST /v1/investigations/{itemId}/generate

Tiered AI narrative scaled to plan level, with evidence pointers and disposition notes for review-required rows.

05Step 05

Operator + Approver

Submit and Approve

POST /v1/batches/{id}/submit → POST /v1/batches/{id}/approve

Maker-checker handoff with separation-of-duties checks and immutable audit trail.

06Step 06

Approver or Admin

Export Artifacts

POST /v1/batches/{id}/artifacts/audit-packet

Downloadable HTML evidence packet and accounting CSV artifacts.

API surface map

Core routes teams use most often in pilot and production workflows.

Method	Path	Purpose	Minimum role
POST	`/v1/batches`	Create payout batch container	operator+
POST	`/v1/batches/{id}/items:import`	Import and validate payout rows	operator+
POST	`/v1/batches/{id}/evaluate`	Run policy engine and route scorer	operator+
GET	`/v1/payout-items/{id}/policy-results`	Inspect row-level policy evidence	viewer+
POST	`/v1/investigations/{itemId}/generate`	Generate investigation narrative stream	analyst+
POST	`/v1/batches/{id}/submit`	Submit batch for checker approval	operator+
POST	`/v1/batches/{id}/approve`	Approve batch with maker-checker controls	approver+
GET	`/v1/audit-events`	Read immutable event timeline	viewer+
POST	`/v1/batches/{id}/artifacts/audit-packet`	Create regulator-ready HTML packet	approver+
POST	`/v1/batches/{id}/artifacts/export`	Generate accounting export CSV	approver+

Integration baseline

Every mutation route should include a bearer token and X-Org-Id. Keep role ownership explicit for create, investigate, and approve paths.

Route scorer dimensions

Cost weight0.35
Speed weight0.30
Compliance weight0.20
Risk weight0.15

Full API reference

Webhook event model

Event-driven targets to prepare now, with a production-safe fallback path available today.

Webhooks are planned in this build. Until they are enabled, poll /v1/audit-events on a short interval for status-driven downstream actions.

Event	Trigger	Payload highlights	Status
`batch.created`	New payout batch is initialized	batch_id, org_id, actor_id, created_at	Planned
`batch.evaluated`	Policy + route evaluation completes	batch_id, evaluated_count, flagged_count, snapshot_hash	Planned
`investigation.dispositioned`	Analyst sets disposition on a flagged item	item_id, disposition, actor_id, note_ref	Planned
`batch.submitted`	Operator submits for maker-checker	batch_id, submitted_by, submitted_at	Planned
`batch.approved`	Approver accepts the batch	batch_id, approved_by, approved_at, artifact_ids	Planned
`artifact.generated`	Audit packet or export file finishes	artifact_id, artifact_type, batch_id, download_path	Planned

Control matrix and rollout checklist

Use these controls to keep payout speed high without sacrificing governance quality.

Org-scoped access

Required X-Org-Id request boundary

Middleware scope check and org-filtered queries

RBAC enforcement

Role hierarchy from viewer through owner

Endpoint-level permission checks before mutation

Policy reproducibility

Rule set snapshot with SHA-256 hash

Stored on evaluation and included in artifacts

Maker-checker guard

Submitter cannot self-approve batch

Approval handler cross-checks prior submit event

Immutable audit trail

Append-only database trigger on audit_events

Update/delete attempts blocked at DB layer

Export chain-of-custody

Artifacts linked to batch and approval history

HTML packet + CSV generated from system data

Frequently asked implementation questions

Can we pilot with one payout corridor first?

Yes. Most teams start with one corridor, validate policy and approvals, then add corridors once exception handling is stable.

Do we need to use the UI if we already have ops tooling?

No. Every critical lifecycle stage has API endpoints, and the docs hub maps each stage to concrete routes and role gates.

How should we prepare for an external audit?

Use policy snapshots, immutable audit events, and generated audit packets as your baseline evidence package for reviewers.

Are webhooks live today?

Not yet in this build. Use scheduled polling of /v1/audit-events now, then shift to event delivery once webhook support is released.

Does the investigation copilot use a single model?

The investigation engine adapts its analytical depth to your plan tier. Higher tiers access more capable models and multi-model consensus for cross-validated analysis.

Need deeper docs for your rollout?

Start with quickstart and API reference, then use policy and audit docs to harden controls before production traffic.

Open quickstart Talk to team