Install

The SDK

Best when you want the strongest privacy guarantee and do not mind adding one dependency. Install it in the service that runs your agent.

npm install @getjuratify/sdk

Construct one client for the process and call record wherever something worth proving happens. Events are hashed, chained, and encrypted locally, then queued, so recording stays off your critical path.

import { Juratify } from "@getjuratify/sdk";

const client = new Juratify({
  apiKey: process.env.JURATIFY_API_KEY!,
  workspaceId: process.env.JURATIFY_WORKSPACE_ID!,
  // 32-byte data key, raw bytes or base64. Never leaves the process.
  dataKey: process.env.JURATIFY_DATA_KEY!,
});

await client.record(
  "prompt",
  { input: "what is the capital of France", model: "gpt-5" },
  { sessionId: "sess-123" },
);

// Before the process exits, drain anything still queued.
await client.flush();

A sessionId groups related events into one chain, so use a stable value for the life of a conversation or task run. Call flush before your process exits, otherwise queued events can be lost with it.

Or wrap a model instead

If your model exposes doGenerate or doStream, as the Vercel AI SDK does, you can capture prompts, completions, and tool calls without writing any record calls yourself. Recording failures are swallowed by design here, so instrumentation can never break the model call path.

import { wrapModel } from "@getjuratify/sdk";

const model = wrapModel(client, myModel, { sessionId: "sess-123" });

OpenTelemetry

Best when you already emit traces and would rather not add a dependency. Keep your instrumentation and the GenAI semantic conventions, so chat calls, tool calls, and errors arrive as evidence without rewriting anything. There are two ways to connect.

Our span exporter (sealed in your process)

Drop our exporter into your existing tracer provider. It maps GenAI spans to events and seals each one locally through the same path as the SDK, so the vault still only ever sees ciphertext. This is the zero-knowledge OpenTelemetry path, and it takes the same three credentials as the SDK.

import { JuratifySpanExporter } from "@getjuratify/sdk";
import { BatchSpanProcessor } from "@opentelemetry/sdk-trace-base";

const exporter = new JuratifySpanExporter({
  apiKey: process.env.JURATIFY_API_KEY!,
  workspaceId: process.env.JURATIFY_WORKSPACE_ID!,
  dataKey: process.env.JURATIFY_DATA_KEY!,
});

// Register it like any other span processor on your provider.
provider.addSpanProcessor(new BatchSpanProcessor(exporter));

Set a juratify.session_id span attribute to group spans into one chain; without it each trace becomes its own session.

The raw OTLP endpoint (zero code, server-sealed)

If you would rather not add a dependency, point any OTLP exporter straight at the vault with two environment variables.

OTEL_EXPORTER_OTLP_TRACES_ENDPOINT=https://app.juratify.com/api/v1/otlp/traces
OTEL_EXPORTER_OTLP_HEADERS=authorization=Bearer <your API key>

A stock exporter sends span attributes as plaintext, so on this path the vault reads the payload at ingestion and encrypts it at rest under a per-workspace key. Records are still hash-chained, receipted, and checkpointed identically. The difference is only where the sealing happens: use the exporter above if you need payloads sealed before they leave your process. See Security for the full comparison.