How Deplixo Works

A technical deep-dive into the platform architecture — from deploy request to live app with persistence, real-time sync, and multi-user identity.

The deployment flow

Deploying an app is a single HTTP request. No authentication, no account, no build step.

  1. POST to /api/v1/deploy — send your HTML (and optionally additional files) as a JSON payload. No API key required.
  2. Hash ID assigned — the server generates a unique 8-character lowercase ID displayed as xxxx-xxxx (e.g. dfer-iiok). This becomes the app's permanent identifier.
  3. Live URL returned — your app is immediately accessible at https://deplixo.com/xxxx-xxxx/. The response also includes a claim token so you can attach the app to an account later. 
POST https://deplixo.com/api/v1/deploy
Content-Type: application/json

{
  "html": "<!DOCTYPE html><html>...</html>",
  "title": "My App"
}
// Response
{
  "hash_id": "dferiiok",
  "url": "https://deplixo.com/dfer-iiok/",
  "claim_token": "ctk_..."
}
Diagram: Deploy flow — POST request to hash ID assignment to live URL

App serving

Apps are served as raw HTML. There is no server-side rendering, no build output, no framework runtime. When a visitor loads https://deplixo.com/xxxx-xxxx/, the platform:

  1. Looks up the app by hash ID (the hyphen is presentational and stripped during lookup).
  2. Returns the stored HTML verbatim.
  3. Injects the Deplixo JavaScript SDK before </body>. This makes window.deplixo.db and window.deplixo.user available to every app automatically.

Single-file apps are one HTML document. Multi-file apps include an index.html plus additional CSS, JS, or asset files — all served from the same base URL (e.g. /xxxx-xxxx/styles.css, /xxxx-xxxx/app.js).

Free-tier apps also get a small Deplixo footer injected at the bottom. Paid-tier apps have no footer.

Built-in persistence

Every app gets a server-side key-value store via window.deplixo.db. No backend to build, no database to configure — it's injected automatically.

The API
// Set a value (any JSON-serializable data)
await deplixo.db.set("score", { points: 42, level: 3 });

// Get a value
const score = await deplixo.db.get("score");
// => { points: 42, level: 3 }

// List all keys (with optional prefix filter)
const keys = await deplixo.db.list();
// => ["score", "settings", ...]

const userKeys = await deplixo.db.list("user:");
// => ["user:alice", "user:bob"]

// Delete a key
await deplixo.db.delete("score");
localStorage sync

localStorage works normally in every app. But Deplixo also automatically persists localStorage writes to the server. If a user clears their browser cache or switches devices, their localStorage data is restored from the server on next visit.

This means simple apps that use only localStorage get server-backed persistence for free, with no code changes.

Multi-user & real-time

Visitor identity

Apps are multi-user by default. When a visitor first writes data (via deplixo.db.set), they are prompted to pick a display name. This name is unique within the app — no account required. 

// Access current visitor's identity
const user = deplixo.user;
console.log(user.displayName);  // "alice"
console.log(user.id);           // unique visitor hash

Every write to deplixo.db is tagged with who made it. This means your app can show who created or modified each piece of data without any extra work.

Real-time sync via onChange

Register a callback to receive live updates whenever any visitor changes data. Under the hood, this uses server-sent events (SSE) — no WebSocket setup, no polling. 

// Listen for real-time changes from any user
deplixo.db.onChange(function(change) {
  console.log(change.key);          // "chat:msg-42"
  console.log(change.value);        // { text: "hello", ... }
  console.log(change.user);         // "alice"
  console.log(change.action);       // "set" | "delete"
});

Remixing

Every app's source code is viewable at /xxxx-xxxx/source. From there, anyone can fork it into their AI tool of choice (Claude, ChatGPT, Gemini) with a single click.

When you remix an app, the new app tracks its parent — creating a fork chain. This means you can see how an app has evolved over time: who forked it, what they changed, and what new apps descended from it.

Remix chains provide attribution back to the original creator. The source view shows the full lineage so visitors can explore the history of an app.

The API

The REST API lives at https://deplixo.com/api/v1/. Interactive docs are at /api/docs (Swagger UI) and a plain-text reference for LLMs is at /api/v1/help.

Key endpoints
Method Endpoint Auth Description
POST /api/v1/deploy None Deploy a new app (HTML + optional files)
GET /api/v1/apps/ Session List your apps
GET /api/v1/health None Health check
POST /api/v1/auth/magic-link None Send a magic login link via email
POST /api/v1/auth/verify None Verify magic link token
Deploy payload
{
  "html": "<!DOCTYPE html>...",           // required: main HTML
  "title": "My App",                      // optional: app title
  "description": "A cool thing",            // optional: description
  "files": {                               // optional: additional files
    "styles.css": "body { ... }",
    "app.js": "console.log('hi')"
  }
}

MCP integration

Deplixo exposes an MCP (Model Context Protocol) server at mcp.deplixo.com. This lets AI assistants — Claude, ChatGPT, Cursor, and others — deploy apps directly during a conversation.

How it works
  1. The AI client connects to mcp.deplixo.com via Streamable HTTP transport.
  2. The MCP server exposes a deploy tool that the AI can call with HTML, title, and optional files.
  3. The server calls the Deplixo deploy API internally and returns the live URL to the AI.
  4. The AI presents the URL to the user — the app is live instantly.
Configuration
// Claude Desktop / claude_desktop_config.json
{
  "mcpServers": {
    "deplixo": {
      "url": "https://mcp.deplixo.com/mcp/"
    }
  }
}

No API key needed. The MCP server uses the same zero-auth deploy flow as the REST API. See the Deploy from Claude guide for a full walkthrough.

Pricing tiers

Deplixo is free to start — no account required.

Feature Free Personal Pro
App lifetime 14 days Forever Forever
Max size 1 MB Increased Increased
Custom slug
Deplixo footer Shown Removed Removed
Named URLs /you/app-name/ /you/app-name/

See the pricing page for full details and current prices.

Security

No auth needed for deploy

The deploy endpoint requires no API key, no account, and no authentication of any kind. This is intentional — it removes every barrier between "I have code" and "it's live." Anyone can deploy, anytime.

Claim tokens

When you deploy without an account, the response includes a claim_token. This token lets you attach the app to your account later. If you sign up or log in, you can claim your anonymously-deployed apps and manage them from your dashboard.

Transport security

All traffic is served over TLS (HTTPS). App data, the key-value store, and the deploy API are all encrypted in transit. The platform runs behind a Caddy reverse proxy which handles automatic certificate management.

Next steps

Getting Started

Deploy your first app in 30 seconds.
Deploy from Claude

Set up the MCP server and deploy from chat.
Deploy from Any AI

Use the paste site or API with any tool.
Launch an App

Paste your code and get a live URL.
Deplixo Guides
Ready to deploy?

No account required. Free for 14 days.

Launch an App
On This Page