The platform — ActivityLog

Ingest

One POST. Any language. Any platform.

A single JSON body is all it takes to store an activity message. No SDKs required — though they're coming. Works from cURL, JavaScript, C#, Python, Go, or anything that can make an HTTP request.

System tokens (al_…) authenticate writes — one per source, never shared
Batch up to 10 messages on Free, 500 on Pro, per-contract on Enterprise via POST /messages/batch
Body stored as-is up to your tier's inline cap (16 KB Free → 256 KB Pro). Pro adds body-store overflow as a paid add-on; Enterprise gets it by default up to a 16 MB hard cap.
Idempotency via sourceEventId — safe to retry on network failure

OTLP-compatible ingest

Point your OpenTelemetry collector at us.

ActivityLog accepts OTLP/HTTP — logs and traces — at /api/v1/otlp/v1/logs and /api/v1/otlp/v1/traces. Drop-in for any OpenTelemetry SDK or Collector. No new instrumentation, no SDK rewrite — change the exporter endpoint and you're done.

HTTP/Protobuf and HTTP/JSON; Content-Encoding: gzip supported. gRPC deferred.
Span trees with parent-child relationships preserved; span events become child messages
service.name from resource attributes is promoted to a first-party column
Partial-success semantics on rejected records — no silent drops

Langfuse-compatible ingest

Already using Langfuse SDKs? One env var.

ActivityLog accepts the Langfuse public ingest contract at /api/public/ingestion. Python langfuse, langfuse-js, the LangChain integration, and the OpenAI proxy all keep working — change three environment variables, leave your code alone.

Traces, spans, generations, events, and scores all map across
Score events land as MessageAnnotation rows, queryable alongside the trace
Streamed generation updates map onto duration messages — open on create, close on update
HTTP 207 multi-status on partial success, matching Langfuse's existing contract

LLM telemetry

Model, tokens, cost — first-class columns.

When span attributes follow the OpenTelemetry gen_ai.* semantic conventions, we promote them out of the metadata bag and into first-party columns: model, input tokens, output tokens, cache reads, cache creates, and cost. Same for the equivalents in Langfuse generation events. The query API stays the same; you just get new dimensions to filter and aggregate on.

Filter by model=claude-opus-4-7; aggregate cost by user; compare prompt versions
InputTokens, OutputTokens, CacheReadTokens, CacheCreateTokens, CostMicrocents available on the message row
First-party columns are surfaced in the admin portal today; a dedicated visualisation UI is on the roadmap, not shipped
Non-LLM activity continues to flow through the same backend — this is an extension, not a pivot

Full prompts & responses

No truncation at the body cap.

LLM prompts and responses are the bulk of the payload, and they're often megabytes. When a body exceeds the tier's inline cap, we overflow to content-addressed blob storage instead of dropping data. The message row keeps a hash key; the body is still queryable and exportable. Up to your tier's hard cap.

Free: bodies over 16 KB are rejected with HTTP 413 — overflow isn't available
Pro: body-store overflow is a paid add-on; when enabled, bodies above 256 KB persist intact
Enterprise: overflow on by default; default hard cap 16 MB, configurable per contract
Content-addressed storage — identical prompts deduplicate automatically

Query

Ask across every source. Group by person, partner, or action.

Beyond the raw event list, POST /activity/search runs over the facet index: filter by person, partner, action, source, or date and get matching events plus roll-up counts in a single call — one person's or one partner's activity across every connected tool. Keyset-paginated, so pages stay stable while new data streams in.

Facet on person, partner, action, source, or date — filter and group in the same request
One call returns events and per-facet counts across the whole result set — no second aggregation query
Cross-source by design: a person's commits, tickets, calls, and AI sessions in one timeline, resolved to one identity
Keyset pagination via nextCursor — stable under concurrent ingest, no skip drift
Reader-scoped JWT; results never cross the tenant boundary
Prefer a simple list? GET /messages still filters by stream, level, type, tag, and time

Multi-tenant

Isolation that scales with your business.

Every account is a tenant with full data isolation. Invite team members with scoped roles. Create multiple systems — each with its own tokens, streams, and retention settings.

Roles: Operator, Member, Auditor, Reader — enforced at the API level
TOTP 2FA for Operator accounts — required by default for admin actions
Per-system tokens — rotate or revoke without affecting other systems
Full tenant boundary — your data never appears in another tenant's queries

Coming soon — first-party integrations

Capture lifecycle events from any .NET app.

First-party plugin coming for Umbraco apps — install a NuGet package, configure an al_* token, every Content / Media / Member / User lifecycle event flows into ActivityLog with the right partner / project / actor hierarchy attached. v13 ships first; v17 to follow. The plugin is one piece of a broader extensibility seam: any code in your host process can inject IActivityLogClient and emit events through the same batched, retried OTel pipeline — custom controllers, hosted services, your own audit tables. Not Umbraco-only by design.

Drop-in NuGet — composer auto-wires DI, no boilerplate in your app
Resolves partner + project from the Umbraco content path; emits actor (user vs member) per event
19 Umbraco core notifications captured: Content / Media / Member / User lifecycle + auth
OTel transport — same endpoint, same auth, same dashboards as Claude Code / OTel collector ingest
Decorator-pattern hooks let you forward your existing audit-trail tables without rewriting call sites
Per-tier retention configurable per-token (5 years on Pro and above)

From scattered logs to answers for every level.