Audkit’s use of Sigstore Rekor to anchor signed roots offers a practical solution for external verification. The fact that the root is published where the platform cannot reach it suggests a genuine commitment to immutability. However, the requirement for customers to hold their own Ed25519 keys means that key management becomes a critical responsibility. If a private key is lost or compromised, the verification process could be affected. The system appears secure, but users must be diligent about maintaining their signing infrastructure to ensure continuous reliability.
Questions about Audkit
What is Audkit?
Audkit creates an immutable, append-only record of product events that are sequenced, hash-linked, and signed. Every event is committed to a per-project Merkle tree, and the signed root is published to Sigstore Rekor so the entire history can be re-verified on demand. Users can start by installing the package via npm and adding entries to the chain.
How does the six-step event sealing process work?
The service is designed for teams that need cryptographic proof of their product's actions without relying on promises. It provides a sealed record where every event becomes permanent through a six-step process that includes authentication, sequencing, and anchoring to a public log. This ensures that gaps and reorderings have nowhere to hide in the audit trail.
What are the pricing tiers and how is billing calculated?
Pricing is based on volume rather than proof, with a free plan that includes 25,000 events per month for a single team. The Pro plan costs $49 per month and supports up to 250,000 events, with metered overages billed at $0.20 per 1,000 events. All plans include Merkle-committed trees, publicly anchored roots, and offline verification capabilities.
How does Audkit handle metering and overages?
Each sealed event is treated as one unit for metering, and a background job reports it to billing usually within seconds. A daily check corrects the billed count from the sealed log, while storage is shown as a live figure but never billed separately. Overages are charged per unit rather than forcing a plan jump, keeping costs predictable as volume grows.
What cryptographic mechanisms ensure event integrity and non-repudiation?
The system uses Ed25519 customer-held keys to sign events before they leave the infrastructure, ensuring the provider cannot mint an event in the user's name. Each event includes a monotonic counter, a nonce-blinded commitment, and an encrypted payload pinned by a ciphertext hash. The leaf hash binds the whole skeleton in one hash, preventing time drift and payload manipulation.
How does Audkit ensure immutability and what export options are available?
Audkit is built on Postgres with database triggers that reject UPDATE, DELETE, and TRUNCATE operations outright to maintain immutability. Events are exported in CSV and NDJSON formats, and users can set up webhook alerts or view a live dashboard for real-time monitoring. The audkit CLI allows rebuilding the tree from an export to verify the record offline without touching the servers.
Which teams or use cases benefit most from Audkit?
The service is designed for products that require a tamper-evident history where every action is sequenced and committed to a per-project Merkle tree. It is suitable for teams needing RFC 6962 tree commits and inclusion proofs verified per RFC 9162. The architecture supports shared projects, member roles, and invitations up to the plan's seat limits.
What are the retention limits and how are proofs generated?
The free plan includes a 90-day retention cap, while the Pro plan offers seven years or forever retention for critical records. Both plans provide publicly anchored signed roots published hourly to Sigstore Rekor, a log Audkit cannot reach. Inclusion and consistency proofs are available on demand via the API to verify the record's state at any point in time.
How does the API enforce the append-only constraint?
The website states that the API cannot edit or delete events, enforcing a strict append-only model. Every event is sequenced and appended to a per-project RFC 6962 tree before the write is acknowledged. The dashboard sees the event the moment it lands, ensuring zero latency between action and visibility.
How does Audkit prevent sequence gaps or reordering?
The system guarantees that the next number in the sequence is never in doubt by using a monotonic counter assigned to each event. The skeleton of the event is hashed into a leaf and appended to the project's Merkle tree, creating a chain that can be re-verified from the first record. This process ensures that the entire history remains consistent and auditable.
What specific fields are sealed and how are they protected?
The service publishes signed roots hourly to Sigstore Rekor, creating a public anchor that Audkit cannot alter. The sealed fields include a createdAt timestamp bound into the leaf so time cannot drift, and a nonce-blinded commitment built to outlive the payload itself. The ciphertext hash pins the exact encrypted bytes stored for the user, ensuring payload integrity.
What are the key features of the dashboard and API?
The dashboard sees the event the moment it lands, providing immediate visibility without queuing in the trust path. The API rejects any updates or deletions, ensuring that the record remains exactly as it was when written. This design supports a complete audit trail where every event is permanent and verifiable.
How do the seat limits and event caps differ between plans?
The free plan allows three team seats and 25,000 events per month, while the Pro plan supports ten seats and 250,000 events. Overages beyond the Pro limit are billed at $0.20 per 1,000 events, which is the plan's own blended rate. There is no forced plan jump, allowing teams to scale usage without abrupt cost increases.
How does Audkit support offline verification and external audits?
The system uses a per-project Merkle tree whose signed root is published where Audkit cannot reach it, ensuring external verification. The audkit CLI rebuilds the tree from an export and checks it without touching the servers, enabling offline verification. This approach allows users to validate the record independently of the provider's infrastructure.
What is the official website of Audkit?
The official website of Audkit is audkit.dev.
AI-generated from reviews on this page. Verify anything important with the company directly.
The Merkle tree implementation effectively secures the event log. Customer-held keys ensure that the platform cannot forge history, providing strong evidence of data integrity.
Audkit presents a technically sound model for immutable event logging, leveraging Merkle trees and Ed25519 signatures to ensure data integrity. The process of anchoring signed roots to Sigstore Rekor is a strong feature, providing an out-of-band verification mechanism. However, the system relies heavily on the client-side SDK or CLI to perform local hash arithmetic, which may introduce complexity for teams less familiar with cryptographic primitives. The claim that payloads never leave Postgres is reassuring for privacy, yet the dependency on specific cryptographic standards means that any changes to the underlying key management could impact the verification process. Additionally, the reliance on a monotonic counter for sequencing assumes that the client infrastructure remains consistent. While the promise of an append-only record is attractive, the actual implementation details, such as how the server-assigned timestamps interact with the payload hash, are not entirely clear from the available information. The system seems robust, but the burden of verification shifts significantly to the user, who must manage the inclusion and consistency proofs independently. This requires a certain level of technical expertise that may not be present in all development teams, potentially limiting adoption among less specialized groups.
The verify function provides signed receipts that confirm integrity. Since there is no edit endpoint, any alteration becomes immediately obvious. This design eliminates the need to trust the platform blindly, allowing developers to check the history locally with confidence.
The append-only design of Audkit offers a compelling approach to maintaining immutable records. By committing every event into an RFC 6962 Merkle tree, the system ensures that history remains verifiable. The use of Ed25519 keys held by customers adds a layer of security that prevents even the platform from forging data. Publishing roots to Sigstore Rekor provides an external anchor that strengthens the integrity of the entire sequence, making it difficult for unauthorized changes to go undetected.
News
No news yet. This is where the business shares its own updates and press.
Photos
No photos yet. Photos shared by reviewers will show up here.
Widgets
Get the widget for your site →About Audkit
Audkit provides an append-only record of events generated by a product, with each event sequenced, hash-linked to the previous one, and signed. The service is designed so that the entire history of records can be re-verified on demand, starting from the first record. The records are immutable, supporting no updates and no deletions. Users can get started by installing the package via npm and begin adding entries to the chain.
- Website
- audkit.dev