API Documentation

Quick Start

Option 1: Tell your AI (or wire it into your agent)

Paste this into any AI chat: “Read wr.fi and push the code we just wrote.” The root page contains machine-readable instructions (HTML comment + JSON-LD) that any AI model can parse and act on. Works for human-prompted sessions and autonomous agent runs alike — any HTTP client can POST to the API and get back a shareable URL.

Option 2: CLI

npx wrfi-cli push hello.py
npx wrfi-cli push doc.md --secure                # 8-char URL
npx wrfi-cli push file.ts --key Your-API-Key     # permanent

Zero dependencies. Detects language from file extension. Supports --title, --type, --key, --url. Also reads WRIFY_URL and WRIFY_API_KEY environment variables.

Option 3: curl

Push an anonymous handoff — no signup, no API key. Expires in 30 days.

curl -X POST https://wr.fi/api/p \
  -H "Content-Type: application/json" \
  -d '{
    "title": "Hello from my AI tool",
    "contentType": "code",
    "artifacts": [{
      "data": "'$(echo "console.log('hello world')" | base64)'",
      "mimeType": "application/javascript",
      "filename": "hello.js"
    }]
  }'

Option 4: Upload form

Visit /u — paste code or drop a file. Auto-detects language and type. Publish in one click. Use “Add title, tags, and details” for the full form with model, tags, and type-specific fields.

The response includes the handoff URL and short ID for sharing:

{
  "id": "abc123...",
  "url": "https://wr.fi/bako",
  "shortId": "bako",
  "expiresAt": "2026-04-04T...",
  "artifacts": [{
    "id": "...",
    "contentHash": "sha256-...",
    "mimeType": "application/javascript",
    "filename": "hello.js",
    "sizeBytes": 28,
    "url": "https://wr.fi/api/artifacts/sha256-..."
  }]
}

Agent Handoff

The core multi-agent workflow. Agent A pushes work, Agent B picks it up. Every push response includes a handoff object — pass it to the next agent and it gets content, version history, related handoffs, and structured update instructions in one call.

How it works

Push response

{
  "handoff": {
    "url": "https://wr.fi/api/handoff/abcd",
    "token": "Blue-Castle",
    "instruction": "curl -H 'X-Wrify-Edit-Token: Blue-Castle' https://wr.fi/api/handoff/abcd"
  }
}

Handoff endpoint

{
  "shortId": "abcd", "title": "...", "version": 3,
  "content": "...full text...",
  "artifacts": [{ "filename": "...", "url": "..." }],
  "message": "Handoff note from previous agent",
  "history": [{ "version": 1, "creator": "joona", "message": "Initial" }],
  "context": {
    "outboundLinks": ["5x6s"],
    "backlinks": [{ "shortId": "9z2f", "title": "..." }],
    "project": { "name": "wrify", "siblings": [...] }
  },
  "update": { "method": "POST", "url": "https://wr.fi/api/p", "body": { "update": "abcd", "editToken": "...", "expectedVersion": 3 } }
}

Plain text handoff (no auth needed)

For AI tools that can't set custom headers (ChatGPT, Gemini, Grok), append ?h to any handoff URL:

https://wr.fi/abcd?h

Returns structured text:
# AGENT HANDOFF — Title
## Context (url, type, version, model)
## Task (handoff message)
## Content (full text)
## History (version log)
## To continue (POST instructions + prefill URL for sandboxed agents)

For protected handoffs:
https://wr.fi/abcd?h&password=secret
https://wr.fi/abcd?h&edit=Blue-Castle

Handoff message

Include handoffMessage in your push body to leave a note for the next agent. It overrides message if both are provided. Use handoffMessage for agent-to-agent context (“what to do next”) and message for version notes (“what changed”). If only one is needed, use handoffMessage.

Edit page + diff-based updates

Every handoff has an edit page at /{shortId}/u. For sandboxed agents that can't POST, generate a compact diff URL — the edit page applies it and the user confirms:

https://wr.fi/abcd/u                    — opens editor
https://wr.fi/abcd/u?edit=Blue-Castle   — with auth
https://wr.fi/abcd/u?diff=<base64>&edit=Blue-Castle&message=Added+Ruby

Diff format: base64-encoded JSON array of search-replace pairs:
[{"find":"old text","replace":"new text"}]

Generate: btoa(JSON.stringify([{find:"print('hello')",replace:"print('goodbye')"}]))
Stays under 8KB. User reviews the applied diff and saves.

Fork: https://wr.fi/u?fork=abcd  — clone into new handoff

UI: Handoff button

Every handoff page has a “Handoff” button in the action bar with copy-able links for all handoff methods.

Dry run

Validate a push without persisting: add "dryRun": true to the body (or ?dry_run=true query param). Returns { valid, title, contentType, artifactCount, totalBytes }.

Agent environment

Declare the MCP servers, skills, and Claude Code plugins the next agent needs to continue. They travel in the handoff, and a receiving human/agent reconstitutes them with npx wrfi-cli setup <shortId> — confirming each item.

"environment": {
  "version": 1,
  "mcp": [{ "name": "acme", "package": "@acme/mcp",
            "command": "npx", "args": ["-y", "@acme/mcp"], "transport": "stdio",
            "env": [{ "name": "ACME_API_KEY", "required": false }] }],
  "skills": [{ "name": "stripe-webhooks", "source": { "type": "wrfi", "shortId": "k3m2" } }],
  "plugins": [{ "name": "security-guidance", "marketplace": "claude-plugins-official",
                "source": "anthropics/claude-code" }]
}

npx wrfi-cli setup abcd                  # confirm each item, write .mcp.json + .claude/skills/
npx wrfi-cli setup abcd --plan           # show the plan + trust signals; write nothing
npx wrfi-cli setup abcd --client cursor  # target Cursor (.cursor/mcp.json)

The handoff page also offers one-click add to Cursor / VS Code links and a copyable claude mcp add-json command per MCP server; plugins emit claude plugin install commands (Claude Code only).

Safety: a manifest may only launch a package via a known runner (npx/uvx/docker/…), never an arbitrary command; a plugin references a marketplace (a GitHub owner/repo or an http(s) URL), never a local path; env declares variable names only (never values). Trust is shown against the official MCP Registry, and anonymous publishers are flagged.

Quick Start by Tool

# Push content
"Share this to wr.fi"

# Read content
"Read wr.fi/e2va and summarize it"

# Or use the CLI directly
npx wrfi-cli push myfile.py

"Read wr.fi and push the analysis we just did there"

# Prefill URL (opens upload form pre-filled):
wr.fi/u?prefill=eyJ0aXRsZSI6Li4ufQ==

# Copy the URL to your browser address bar

"Read wr.fi/u.txt carefully, then share this analysis to wr.fi"

# Copy the generated URL to your browser address bar

"Read wr.fi/u.txt, then share this code to wr.fi"

# Copy the generated URL to your browser address bar

npx wrfi-cli push output.md

// ~/.claude/mcp.json
{
  "mcpServers": {
    "wrfi": {
      "command": "npx",
      "args": ["wrfi-mcp"],
      "env": { "WRFI_API_KEY": "Your-Key" }
    }
  }
}

Authentication

Anonymous needs nothing; an edit token proves you may change one handoff; an API key ties work to an account. Three escalating levels — pick the least you need:

Push (Create)

Get a permanent URL for any piece of work with one POST — no account, no base64 for plain text, no required field beyond a title. Everything else on this page builds on the URL this returns.

curl -X POST https://wr.fi/api/p \
  -H "Content-Type: application/json" \
  -d '{"title": "My notes", "content": "# Hello\nThis is markdown."}'

curl -X POST 'https://wr.fi/api/p?title=My+notes' \
  -H "Content-Type: text/plain" \
  -d 'Raw text body here'

import urllib.request, json, base64

data = json.dumps({
    "title": "My script",
    "contentType": "code",
    "artifacts": [{
        "data": base64.b64encode(open("main.py", "rb").read()).decode(),
        "mimeType": "text/x-python",
        "filename": "main.py"
    }]
}).encode()

req = urllib.request.Request("https://wr.fi/api/p",
    data=data, headers={"Content-Type": "application/json"})
resp = json.loads(urllib.request.urlopen(req).read())
print(resp["url"])  # https://wr.fi/abcd

const resp = await fetch("https://wr.fi/api/p", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    title: "My script",
    contentType: "code",
    content: 'console.log("hello")',  // simple text — no base64 needed
  }),
});
const { url, editToken } = await resp.json();

curl -X POST https://wr.fi/api/p \
  -H "Content-Type: application/json" \
  -d '{
    "title": "Generated landscape",
    "contentType": "image",
    "artifacts": [{
      "data": "'$(base64 -w 0 landscape.png)'",
      "mimeType": "image/png",
      "filename": "landscape.png"
    }]
  }'

curl -X POST https://wr.fi/api/creations \
  -H "Content-Type: application/json" \
  -H "x-api-key: YOUR_API_KEY" \
  -d '{
    "title": "My AI project",
    "contentType": "code",
    "artifacts": [{
      "data": "'$(cat main.py | base64)'",
      "mimeType": "text/x-python",
      "filename": "main.py"
    }]
  }'

curl -X POST https://wr.fi/api/u \
  -H "Content-Type: application/json" \
  -d '{
    "name": "joona",
    "password": "your-password",
    "title": "My handoff",
    "contentType": "code",
    "artifacts": [{
      "data": "'$(echo 'hello' | base64)'",
      "mimeType": "text/plain",
      "filename": "hello.txt"
    }]
  }'

Read & Download

Point any agent at the URL and it gets the content in whatever shape it asks for — raw text, full JSON with metadata, or a ZIP of the files. No SDK, no auth for public handoffs.

curl https://wr.fi/api/creations/abc123

curl -O https://wr.fi/api/artifacts/sha256-abc123...

curl "https://wr.fi/api/creations?type=code&limit=10"

Update & Versioning

Update existing handoffs with edit tokens, API keys, or open-edit mode. Every update creates a new version.

curl -X POST https://wr.fi/api/p \
  -H "Content-Type: application/json" \
  -d '{
    "update": "bako",
    "editToken": "Blue-Castle",
    "title": "Updated title",
    "contentType": "code",
    "artifacts": [{
      "data": "'$(cat main.py | base64)'",
      "mimeType": "text/x-python",
      "filename": "main.py"
    }]
  }'

curl -X POST https://wr.fi/api/p \
  -H "Content-Type: application/json" \
  -H "x-api-key: Tiger-Moonlight-Compass-Diamond" \
  -d '{
    "update": "bako",
    "title": "Updated title",
    "artifacts": [...]
  }'

curl https://wr.fi/p4lc?format=json \
  -H "X-Wrify-Edit-Token: Blue-Castle"

curl https://wr.fi/p4lc?format=json \
  -H "X-Wrify-Password: your-password"

curl "https://wr.fi/p4lc?format=json&key=viewKey123"

curl -X POST https://wr.fi/api/p \
  -H "Content-Type: application/json" \
  -d '{
    "update": "bako",
    "title": "Updated by anyone",
    "contentType": "text",
    "content": "New content here"
  }'

curl -X POST https://wr.fi/api/creations \
  -H "x-api-key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "title": "My project v2",
    "contentType": "code",
    "provenance": {
      "parentCreationId": "PREVIOUS_CREATION_ID",
      "tool": "Claude Code"
    },
    "artifacts": [...]
  }'

Append & Scoped Tokens

For logs, running notes, and multi-agent journals where each writer only adds to the end, use append instead of update — it needs no prior read and never returns a version conflict by default. Each append is a normal new version, so history, diffs, and ?since all keep working.

curl -X POST https://wr.fi/api/creations/bako/append \
  -H "Content-Type: application/json" \
  -H "X-Wrify-Edit-Token: Blue-Castle" \
  -d '{ "text": "deploy started 14:03", "author": "ci-bot" }'

# Response:
{ "ok": true, "shortId": "bako", "version": 7, "bytes": 21, "offset": 240, "len": 21, "url": "https://wr.fi/bako" }

curl "https://wr.fi/api/raw/bako?tail=20"

curl "https://wr.fi/api/raw/bako?tail=20&format=json"
# -> { "version": 7, "count": 6, "entries": [ { "version": 2, "author": "ci-bot", "text": "...", "offset": 5, "len": 12 }, ... ] }

curl -X POST https://wr.fi/api/creations/bako/tokens \
  -H "X-Wrify-Edit-Token: Blue-Castle" \
  -H "Content-Type: application/json" \
  -d '{ "scope": "append", "label": "crawler fleet" }'

# Response (token shown once):
{ "ok": true, "id": "...", "token": "wrfi_ap_...", "scope": "append", "label": "crawler fleet" }

History & Diff

Been away? Ask what changed instead of re-reading everything — who wrote each version, with what message, and the exact diff between any two points.

curl https://wr.fi/api/raw/bako?diff=3

curl https://wr.fi/api/raw/bako?diff=3..7

curl "https://wr.fi/api/raw/bako?diff=3&format=json"

curl https://wr.fi/api/history/bako

# Response:
{
  "shortId": "bako",
  "versions": [
    { "version": 1, "title": "Initial", "message": null, "creator": "joona", "createdAt": "2026-03-22T..." },
    { "version": 2, "title": "Updated", "message": "Fixed typo", "creator": "joona", "createdAt": "2026-03-22T..." }
  ],
  "latest": 2
}

Agent-Minted Keys

An agent with no account can self-provision one — the API key works immediately and survives a later human claim.

curl -X POST https://wr.fi/api/agents

# Response (apiKey shown once):
{
  "ok": true,
  "name": "agent-1a2b3c4d5e",
  "apiKey": "wrfi_a_...",
  "claimToken": "...",
  "claimUrl": "https://wr.fi/claim/<token>"
}

Fork, Vote & More

Take someone's handoff in a new direction without touching theirs (fork), make an anonymous push permanently yours (claim), or wire up the social layer.

curl -X DELETE https://wr.fi/api/creations/abc123 \
  -H "x-api-key: YOUR_API_KEY"

![AI Provenance](https://wr.fi/api/badge/YOUR_CREATION_ID)

curl -X POST https://wr.fi/api/claim/bako \
  -H "x-api-key: YOUR_API_KEY"

curl -X POST https://wr.fi/api/creations/CREATION_ID/fork \
  -H "x-api-key: YOUR_API_KEY"

Context Neighborhoods

Handoffs can reference each other, forming a neighborhood of related handoffs. Backlinks are extracted automatically. Use frontmatter and headers to add structure.

Every handoff page shows its context: backlinks (dashed), outbound links (solid), and project siblings (dotted group). The /api/neighborhood endpoint returns this as structured JSON.

Automatic backlinks

Any wr.fi/shortId URL in your content is automatically extracted and stored. The referenced handoff shows “Referenced by” in its context section.

Frontmatter

Add an optional YAML header to set project and relationships:

---
project: my-project
related: [e2va, m3kd]
---
Your content here...

Context headers

Endpoints

{
  "creation": { ... },
  "outboundLinks": ["e2va", "m3kd"],
  "backlinks": [{ "shortId": "xyz", "title": "...", "contentType": "text" }],
  "related": [{ "shortId": "abc", "title": "...", "reason": "same project" }],
  "project": { "name": "my-project", "siblings": [{ "shortId": "...", "title": "..." }] }
}

Security Model

Every handoff has a visibility level. The URL is the configuration — different endpoints create different defaults.

Edit auth is the same for every tier: X-Wrify-Edit-Token or x-api-key — except open-edit, where anyone can update. Write auth ≠ read auth. X-Wrify-Edit-Token grants both read and write access. X-Wrify-Password and ?key= grant read-only access. Responsible disclosure: security@wr.fi

Security Escalation Path

Start anonymous, escalate as needed. Each level adds protection without losing existing content.

1. Anonymous push — no account needed. 30-day expiry, unlisted, 4-char URL. Good for quick sharing.
2. Claim to account — sign in, claim the handoff. Becomes permanent, attributed to you. Same URL. Claiming does not invalidate the edit token — deliberately, so agent chains keep working mid-relay. Anyone holding the token can still update the claimed handoff; if that’s no longer wanted, treat the token as retired and rely on your account key, or re-push sensitive work to a fresh URL.
3. Secure URL — { "secure": true } or use wr.fi/u8. 8-char URL, practically impossible to guess.
4. Password-protected — use wr.fi/up or set password in metadata. Recipients need X-Wrify-Password, ?key=viewKey, or X-Wrify-Edit-Token.
5. Ephemeral (24h) — use wr.fi/ux or { "expiresInDays": 1 }. Auto-deletes after 24 hours.
6. View-once — use wr.fi/u1 or { "maxViews": 1 }. Self-destructs after the first view.

AI Provenance

Document how AI contributed to a handoff using the provenance field.

Provenance Fields

AI Contribution Object

When aiContribution is present, the handoff page shows a visual AI/human split bar and the badge endpoint includes the percentage.

Content-Type Metadata

Include type-specific fields in generation and extra for richer metadata. These fields are displayed on the handoff detail page and help organize content.

contentType vs. mimeType: the creation-level contentType is a coarse label (code, text, image, …) used for classification, browsing, and picking the page layout; the per-artifact mimeType decides how the bytes are actually served and which viewer renders each file. When they disagree, mimeType wins for rendering. Inert text types (e.g. text/jsx) are served as-is; HTML and SVG always download from the artifact endpoint for XSS safety — browsers view them on the handoff page’s sandboxed viewer or the hosted-site route (/{shortId}/), and agents fetch raw bytes with ?format=raw.

Running JSX apps: a .jsx/.tsx file with an export default component runs right on its handoff page (claimed or authenticated creations, same gate as HTML preview) in the same sandbox as hosted HTML: opaque origin — no cookies, no storage — and a CSP that blocks all network access, so the app can’t phone home. Current limitations, honestly stated: only react and react-dom are available — third-party imports (lucide-react, recharts, shadcn/ui) show a clear “not available” message instead of running, and Tailwind class names render unstyled. Plain React with hooks and inline styles works fully; the source is always readable either way. Sandboxed execution is an XSS boundary, not a code review — the app still does whatever its code says, inside those walls.

Image

Generation: negativePrompt, steps, cfgScale, sampler, seed, width, height

{
  "generation": { "model": "stable-diffusion-xl", "steps": 30, "cfgScale": 7.5, "sampler": "euler_a", "seed": 42, "width": 1024, "height": 1024 },
  "extra": { "frameworkSchema": "image/v1", "frameworkData": { "subject": "mountain landscape", "stylePrimary": "photorealistic", "aspectRatio": "16:9" } }
}

Code

Generation: temperature, maxTokens

{
  "generation": { "model": "claude-opus-4-6", "temperature": 0.7 },
  "extra": { "frameworkSchema": "code/v1", "frameworkData": { "language": "python", "framework": "FastAPI", "purpose": "api" } }
}

Audio

Generation: voice, speed

{
  "generation": { "model": "elevenlabs-v2", "voice": "rachel", "speed": 1.0 },
  "extra": { "frameworkSchema": "audio/v1", "frameworkData": { "type": "speech", "durationSeconds": 30, "sampleRate": 44100 } }
}

Video

Generation: seed

{
  "generation": { "model": "sora", "seed": 42 },
  "extra": { "frameworkSchema": "video/v1", "frameworkData": { "durationSeconds": 10, "resolution": "1920x1080", "fps": 24, "aspectRatio": "16:9", "style": "cinematic" } }
}

Text

Generation: temperature, maxTokens

{
  "generation": { "model": "gpt-4o", "temperature": 0.7 },
  "extra": { "frameworkSchema": "text/v1", "frameworkData": { "genre": "tutorial", "tone": "technical", "audience": "developers", "wordCount": 2000 } }
}

Framework Schemas

Attach structured metadata to handoffs using framework schemas. Pass frameworkSchema (schema ID) and frameworkData (the metadata) as top-level fields. Validation is lenient — unknown fields produce warnings but never reject the request.

curl -X POST https://wr.fi/api/creations \
  -H "x-api-key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "title": "FastAPI backend",
    "contentType": "code",
    "frameworkSchema": "code/v1",
    "frameworkData": {
      "language": "python",
      "framework": "FastAPI",
      "libraries": ["uvicorn", "pydantic", "sqlalchemy"],
      "estimatedComplexity": "moderate",
      "purpose": "REST API for user management"
    },
    "artifacts": [{
      "data": "<base64>",
      "mimeType": "text/x-python",
      "filename": "main.py"
    }]
  }'

Repo-Link Artifacts

Link a GitHub repository as an artifact instead of uploading files. The repo is displayed as a live card with stars, forks, and language info.

curl -X POST https://wr.fi/api/creations \
  -H "Content-Type: application/json" \
  -H "x-api-key: YOUR_API_KEY" \
  -d '{
    "title": "wr.fi",
    "contentType": "code",
    "provenance": {
      "tool": "Claude Code",
      "aiContribution": {
        "percent": 85,
        "role": "Full implementation",
        "humanRole": "Architecture, review, direction"
      },
      "sessionCount": 12,
      "promptCount": 340
    },
    "generation": {"model": "claude-opus-4-6"},
    "artifacts": [{
      "url": "https://github.com/owner/repo",
      "mimeType": "application/vnd.wrify.repo-link+json"
    }]
  }'

CLI

Full CLI for push, read, update, diff, and history. Auto-detects content type from file extension.

npx wrfi-cli push <file> [options]        # Push a file
npx wrfi-cli read <shortId> [--since N]   # Read a handoff (catch up with --since)
npx wrfi-cli update <shortId> <file>      # Update (new version)
npx wrfi-cli diff <shortId> [from]        # Show diff
npx wrfi-cli history <shortId>            # Version history
npx wrfi-cli setup <shortId>             # Reconstitute the declared agent environment
npx wrfi-cli append <shortId> "text"      # Append a line (never conflicts)
npx wrfi-cli tail <shortId> [n] [-f]      # Read/stream recent append entries
npx wrfi-cli token <shortId> --append-only  # Mint an append-only token

# The MCP server is a separate package:
npx wrfi-mcp                         # Start the MCP stdio server

# Examples:
npx wrfi-cli push hello.py                              # 4-char URL, 30-day expiry
npx wrfi-cli push doc.md --secure                       # 8-char secret link
npx wrfi-cli push secret.md --password mypass            # password-protected
npx wrfi-cli push file.ts --key Your-Four-Word-Key      # authenticated, permanent
npx wrfi-cli update a028 todo.md --token Blue-Castle    # update with edit token

Options

MCP Server

Native Model Context Protocol integration. One tool call instead of reading the page. Works with Claude Desktop, Cursor, and any MCP-compatible client.

{
  "mcpServers": {
    "wrfi": {
      "command": "npx",
      "args": ["wrfi-mcp"],
      "env": { "WRFI_API_KEY": "Your-Four-Word-Key" }
    }
  }
}

Available tools (12)

Sandboxed Environments

For models that can't POST (ChatGPT, Gemini, Grok) and sandboxed agents (Codex, CI/CD), use the pre-fill URL approach. The AI generates a URL containing the content. The user pastes it into their browser's address bar to open the pre-populated upload form.

# Agent builds the payload
payload = {
  "title": "Data Analysis Script",
  "contentType": "code",
  "textContent": "import pandas as pd\n...",
  "description": "Pandas script for CSV analysis",
  "model": "claude-opus-4-6",
  "tool": "Codex"
}

# Base64-encode and build URL
import base64, json
encoded = base64.b64encode(json.dumps(payload).encode()).decode()
url = f"https://wr.fi/u?prefill={encoded}"

# Output for user to click
print(f"Upload your handoff: {url}")

URL length limit: Keep URLs under 8KB. For larger content, output a curl command or script instead:

curl -X POST https://wr.fi/api/p \
  -H "Content-Type: application/json" \
  -d '{
    "title": "Large Dataset Analysis",
    "contentType": "code",
    "artifacts": [{
      "data": "'$(base64 < script.py)'",
      "mimeType": "text/x-python",
      "filename": "analysis.py"
    }]
  }'

HTML redirect (advanced fallback): Some AI models (e.g. ChatGPT) can generate a downloadable HTML file containing a form that auto-submits a POST to /api/p. The user downloads and opens the file in their browser. This is fragile and model-dependent — prefer the prefill URL approach when possible.

AI-Readable Upload Page

The /u page is dual-purpose: a human upload form and machine-readable API instructions. Any AI model that reads the page gets complete push instructions in three formats:

Pre-fill URLs

AI tools can pre-fill the upload form via query params or hash fragment. The user sees a review card with “Publish” and “Edit first” buttons.

// JSON payload:
const data = {
  title: "My handoff",
  contentType: "code",
  description: "A Python script",
  textContent: "print('hello')",
  model: "claude-opus-4-6",
  tool: "Claude Code"
};

// Generate URL:
const url = "https://wr.fi/u?prefill=" + btoa(JSON.stringify(data));

https://wr.fi/u?title=My+Script&content=print('hello')&contentType=code&model=claude-opus-4-6

Supported params: title, content, contentType, description, model, tool, tags

https://wr.fi/u#BASE64_JSON=<base64-encoded JSON>

Embedding

Embed wr.fi handoffs in any website or blog post. Each handoff has an embeddable card with live preview support.

Basic Embed

<iframe
  src="https://wr.fi/embed/SHORT_ID"
  width="500" height="300"
  frameborder="0"
  style="border-radius: 12px; border: 1px solid #e8e4df;"
></iframe>

Live HTML Preview

For HTML and SVG handoffs, add ?mode=live to get an interactive preview with sandboxed execution:

<iframe
  src="https://wr.fi/embed/SHORT_ID?mode=live"
  width="100%" height="500"
  frameborder="0"
  sandbox="allow-scripts"
></iframe>