Now available · Cloud or self-hosted

Versioned JSON storage for your apps.

Every write creates a version. Publish data and sites with one atomic promote, share them with your team, and let AI agents work with them safely — open to every agent, private to yours.

Open Admin UI Read the Docs

// npm install @usewren/client
import { WrenClient } from "@usewren/client";

const wren = new WrenClient({ baseUrl: "https://…", apiKey: "wren_…" });

// Create a document (version 1)
const doc = await wren.documents.create("pages", { title: "Hello", body: "World" });

// Update (version 2 created automatically)
await wren.documents.update("pages", doc.id, { title: "Hello v2" });

// Pin a label and read it back
await wren.labels.set("pages", doc.id, "published");
const live = await wren.documents.get("pages", doc.id, { label: "published" });

# pip install usewren-client
from wren import WrenClient

with WrenClient("https://…", api_key="wren_…") as wren:
    # Create a document (version 1)
    doc = wren.documents.create("pages", {"title": "Hello", "body": "World"})

    # Update (version 2 created automatically)
    wren.documents.update("pages", doc.id, {"title": "Hello v2"})

    # Pin a label and read it back
    wren.labels.set("pages", doc.id, "published")
    live = wren.documents.get("pages", doc.id, label="published")

# Create a document (version 1)
POST /api/v1/pages
{ "title": "Hello", "body": "World" }
→ { "id": "abc", "version": 1, "data": { ... } }

# Update (version 2 created automatically)
PUT /api/v1/pages/abc
{ "title": "Hello v2" }
→ { "id": "abc", "version": 2, "data": { ... } }

# Pin a label to version 2
POST /api/v1/pages/abc/labels
{ "label": "published" }

# Serve the published version publicly (no key)
GET /api/v1/orgs/{slug}/pages/abc
→ version 2 data

Features

Everything you need, nothing you don’t.

Built for developers who want a real backend without the operational overhead.

Versioned by default

Every mutation creates a new version. Roll back, diff, or time-travel to any point. No extra setup.

Tenant isolation

Each org gets its own Postgres schema. Isolation is structural — not a policy to misconfigure.

Label snapshots

Pin any version as published, draft, or staging. Serve different audiences from the same document.

Built for AI agents

A built-in MCP server and llms.txt. Agents read your public data with no key and work in your private data as you — every write reversible. How it works →

Cloud or self-hosted

Start free on our cloud, or deploy to your own infrastructure with Docker. Bring your own Postgres. No vendor lock-in.

Streamed responses

All responses stream from Postgres to the client. Flat memory, no buffering regardless of result size.

Sites from trees

Map URL paths to versioned files. wren deploy to a preview, check it, then promote the whole site in one transaction. Roll back the same way.

Public by rule

Nothing is public until you add a rule. Make a tree or collection readable by anyone — only the published versions, so drafts stay private.

Work together

Invite people by email straight into groups like Editors or Viewers. Admins can view the org as a member to help — and every change made that way is recorded as such.

AI agents

Open to every agent. Private to yours.

One server, one MCP endpoint. What you publish, anyone’s agent can find and use. What you keep private, only your agents reach — with your permissions, and nothing they do is permanent.

Public data, no key

Any agent can connect to /mcp without signing up, see who publishes what, and read published sites and collections. Always the released version, never your drafts.

Private data, as you

“Sign in with WREN” from Claude, Cursor or VS Code, pick the org, and the agent works with your groups’ access. Or give it an API key. Revoke either at any time.

Safe to let it write

Agent writes land as new versions labeled preview. Review the diff, promote what’s good, roll back what isn’t. Nothing is overwritten.

# Read anyone’s public data — no account needed
claude mcp add --transport http wren-public https://wren.aemwip.com/mcp

# Work in your own org — opens a browser to sign in and choose the org
claude mcp add --transport http wren https://wren.aemwip.com/mcp/login

Set up Claude Code, Cursor or VS Code →

How it works

Simple by design.

No schemas to define, no migrations to run. Just POST JSON and go.

Define nothing

Collections are schema-free by default. POST any JSON document and it’s stored with version 1.

Mutate freely

Every PUT creates a new version. The old data is never overwritten.

Access history

List versions, diff any two, label a snapshot, or roll back — all via REST.

API Reference

A handful of endpoints. Infinite history.

The full API is documented at /docs. Here’s the shape of it.

bash

# Create a document
curl -X POST $WREN/api/v1/pages -H "Authorization: Bearer $KEY" \
  -d '{"title": "My Page", "published": false}'

# Update (creates version 2)
curl -X PUT $WREN/api/v1/pages/{id} -H "Authorization: Bearer $KEY" \
  -d '{"title": "My Page", "published": true}'

# Diff v1 → v2
curl "$WREN/api/v1/pages/{id}/diff?v1=1&v2=2" -H "Authorization: Bearer $KEY"

# Rollback to v1
curl -X POST $WREN/api/v1/pages/{id}/rollback/1 -H "Authorization: Bearer $KEY"

Client Libraries

First-class TypeScript & Python clients.

Full types. Zero extra dependencies. Works in Node, Bun, and async Python.

TypeScript & JavaScript npm install @usewren/client

import { WrenClient } from "@usewren/client";

const wren = new WrenClient({ baseUrl, apiKey });

// Documents, versions, labels, trees…
const doc  = await wren.documents.create("pages", data);
const hist = await wren.versions.list("pages", doc.id);
const diff = await wren.diff.compare("pages", doc.id, 1, 2);
await wren.labels.set("pages", doc.id, "published");

Python pip install usewren-client

from wren import WrenClient, AsyncWrenClient

# Sync
with WrenClient(base_url, api_key=key) as wren:
    doc  = wren.documents.create("pages", data)
    hist = wren.versions.list("pages", doc.id)
    wren.labels.set("pages", doc.id, "published")

# Async
async with AsyncWrenClient(base_url, api_key=key) as wren:
    doc = await wren.documents.create("pages", data)

Pricing

Start free. Scale when you’re ready.

Every plan includes the full API, Admin UI, versioning, labels, and binary assets.

1 organization
3 collections
1 000 documents
100 MB storage
10 000 API requests / day
Community support

Get started