Getting Started

Publish HTML or deploy full-stack apps in seconds.

Install the CLI

$ npm install -g @roxer/cli

Publish a static HTML page

$ roxer publish index.html
Published! https://roxer.com/abc123

Deploy a full-stack app

$ roxer login
$ roxer deploy .
Deployed! https://my-app.roxer.com

Two URL patterns. Server apps (Node, Python) get their own subdomain: https://<app>.roxer.com. Static publishes and static-site builds (dist/, build/, plain HTML) get a path: https://roxer.com/<slug>.

Login required for apps and domains. roxer publish still works without an account on the free tier. roxer deploy and roxer domain require roxer login.

Pages (HTML Hosting)

Host static HTML pages with a single command or through the web UI. Perfect for AI-generated sites, prototypes, landing pages, and quick demos.

Web UI

Paste your HTML at roxer.com and click Publish. You get a live URL instantly.

CLI

# Publish a single file
$ roxer publish index.html

# Update an existing page
$ roxer update abc123 index.html

# Delete a page
$ roxer delete abc123

Multi-file / ZIP support

Publish directories or ZIP files that contain multiple HTML, CSS, JS, and image files.

# Publish a directory (auto-zipped)
$ roxer publish ./my-site/

# Publish a ZIP archive
$ roxer publish project.zip

Options

Flag	Description	Example
`--password`	Require a password to view the page	`roxer publish index.html --password secret`
`--slug`	Set a custom URL slug	`roxer publish index.html --slug my-demo`
`--ttl`	Auto-delete after N days (7, 30, 90, or 0 for permanent)	`roxer publish index.html --ttl 30`

API

# Publish HTML via API
$ curl -X POST https://roxer.com/api/publish \
  -H "X-Api-Key: YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{"html": "<h1>Hello</h1>"}'

# Publish a ZIP with entry point
$ curl -X POST https://roxer.com/api/publish \
  -H "X-Api-Key: YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{"zip": "base64...", "entry": "index.html"}'

Apps (Full-Stack Hosting)

Deploy Node.js and Python web apps with a single command. Roxer handles the build, packaging, and hosting.

Supported Runtimes

Runtime	Supported Frameworks
Node.js 20	Express, Fastify, Hono, Koa
Python 3.12	Flask, FastAPI, Django

How It Works

Upload your source code, Roxer builds it server-side, then deploys to an isolated Lambda function.

▲

Upload

roxer deploy .

→

⚙

Build

npm/pip install

→

⚡

Deploy

Lambda function

→

✓

Live

roxer.com

Auto-detection

Roxer automatically detects your framework, entry point, port, and whether you need a database. No config files required.

SQLite Persistence

Every app gets persistent SQLite storage via AWS EFS. Your data survives restarts and redeployments. Just write to /mnt/data or use your standard SQLite path.

Plan Requirements

App hosting requires a Hosting ($19/mo) or Max ($49/mo) plan
App hosting requires a Hosting or Max account (free, request access)
Auto-sleep after 15 minutes of inactivity
Wakes automatically on the first incoming request (cold start: ~2 seconds)

CLI Commands

# Connect the CLI to your account (one-time)
$ roxer login

# Deploy the current directory (lands at https://<dir-name>.roxer.com)
$ roxer deploy .

# Deploy with a custom app name (lands at https://my-api.roxer.com)
$ roxer deploy . --name my-api

# View logs (live tail)
$ roxer logs my-api

# Set an environment variable
$ roxer env set my-api DB_PATH=/mnt/data/app.db

# Check app status
$ roxer status my-api

Custom Domains

Attach your own domain to any app or page. Hosting plan required. Login required.

CLI

# Walks you through two CNAME records (validation + live)
$ roxer domain add preview.acme.com --app my-app

# List your domains
$ roxer domain list

# Show DNS setup status (and the next CNAME to add)
$ roxer domain status preview.acme.com

# Remove a domain
$ roxer domain delete preview.acme.com

How it works

You add the domain. Roxer prints a validation CNAME for ACM to issue your SSL certificate.
Once that CNAME is live, ACM issues the certificate and the CloudFront distribution deploys (~5 min).
Roxer prints a live CNAME pointing your domain at the distribution. Add it.
When that propagates, your site is live at https://your-domain.com.

Apex domains: most registrars don't support CNAME at the apex. Use a www. subdomain, or use a registrar with ALIAS/ANAME support (Cloudflare, Route 53, DNSimple).

Prefer a UI? Use the web flow at roxer.com/domains.

CLI Reference

Complete list of all CLI commands.

Pages Commands

Command	Description	Example
`roxer publish <file>`	Publish an HTML page	`roxer publish index.html`
`roxer publish <dir>`	Publish a directory as ZIP	`roxer publish ./my-site/`
`roxer update <id> <file>`	Update an existing page	`roxer update abc123 index.html`
`roxer delete <id>`	Delete a page	`roxer delete abc123`
`roxer stats <id>`	View page analytics	`roxer stats abc123`

Apps Commands

Command	Description	Example
`roxer deploy [path]`	Deploy a Node.js/Python app	`roxer deploy .`
`roxer deploy --name <n>`	Deploy with a custom name	`roxer deploy . --name my-api`
`roxer logs <app>`	View app logs (live tail)	`roxer logs my-api`
`roxer logs --no-follow`	Show recent logs only	`roxer logs my-api --no-follow`
`roxer env list <app>`	List environment variables	`roxer env list my-api`
`roxer env set <app> K=V`	Set an environment variable	`roxer env set my-api DB=sqlite`
`roxer env unset <app> <key>`	Remove an environment variable	`roxer env unset my-api DB`
`roxer status <app>`	Show app status	`roxer status my-api`
`roxer apps`	List all deployed apps	`roxer apps`
`roxer apps delete <id>`	Delete a deployed app	`roxer apps delete my-api`
`roxer init [template]`	Scaffold a new project (express, fastify, hono, flask, fastapi, react, svelte)	`roxer init express --name my-api`

Domain Commands

Command	Description	Example
`roxer domain add <domain>`	Attach a custom domain to an app or page	`roxer domain add preview.acme.com --app my-app`
`roxer domain list`	List all your custom domains	`roxer domain list`
`roxer domain status <domain>`	Show DNS setup status and next step	`roxer domain status preview.acme.com`
`roxer domain delete <domain>`	Remove a custom domain	`roxer domain delete preview.acme.com`

Account Commands

Command	Description	Example
`roxer login`	Connect the CLI to your Roxer account	`roxer login`
`roxer logout`	Disconnect the CLI (removes the local key)	`roxer logout`
`roxer account`	Show current plan and limits	`roxer account`
`roxer activate <token>`	Redeem an activation token (invite mode)	`roxer activate abc123...`
`roxer request-access`	Request access to a plan (invite mode)	`roxer request-access --plan launch`

Claude Code (Local MCP)

Use Roxer directly from Claude Code, Cursor, or any other tool that loads a local MCP server. One command to set up, then just ask Claude to deploy.

Using the Claude desktop app instead? See Claude Desktop below for the remote-connector setup — no CLI install needed.

Get your API key

Setup

Add this to ~/.claude.json under the top-level mcpServers key:

{
  "mcpServers": {
    "roxer": {
      "command": "npx",
      "args": ["-y", "@roxer/mcp"]
    }
  }
}

Verify It Works

In a new Claude Code session, run /mcp and confirm roxer appears in the list. Then just ask Claude to build and deploy.

Available Tools

Tool	Description
`pages_publish`	Publish HTML or a ZIP as a hosted page
`pages_publish_files`	Publish multiple files (auto-zipped)
`pages_update`	Update an existing page
`pages_delete`	Delete a page
`apps_deploy`	Deploy a full-stack app (Node.js or Python)
`apps_status`	Check app deployment status
`apps_delete`	Delete a deployed app

Usage

Just ask Claude. "Publish this HTML to Roxer," "Deploy this Express app," or "Build me a todo app and put it on Roxer." The MCP tools handle the rest.

Claude Desktop

If you're using the Claude desktop app — including Claude Cowork — you can connect to Roxer in three clicks. No CLI install, no config files. Claude builds; Roxer publishes; you watch.

Get your API key

Sign up at roxer.com; your API key is shown once on the activation page. Save it somewhere safe (a password manager is ideal). Lost it? See Forgot your API key.

What you'll need

Claude Desktop installed on macOS or Windows.
A paid Claude plan (Pro, Max, Team, or Enterprise). Free accounts get exactly one custom connector — this can be that one.
A Roxer account with an API key (see above).
About 5 minutes.

Setup

Open Claude Desktop, click your profile picture (top-right), then choose Settings.
In the left sidebar, click Connectors.
Scroll to the bottom of the connector list and click Add custom connector.
Fill in:
- Name: Roxer
- URL: https://mcp.roxer.com
Leave Advanced settings alone — Roxer fills in the technical bits for you. Click Add.
Click Connect next to "Roxer" in the list.
A new browser tab opens to a Roxer page that says "Connect Claude to Roxer". Paste your API key into the box and click Connect.
Close the browser tab and return to Claude. The Roxer connector now shows a green dot. You're done.

Try it

Start a new conversation in Claude Desktop and ask one of these:

Build me a link-in-bio page for my Instagram and deploy it to Roxer.

Deploy a tiny todo-list app I can use from my phone. Save tasks in a database.

Make a confetti countdown to my birthday and put it online.

Claude will write the files, publish them to Roxer, and hand back a URL like something.roxer.com. Click. Share. It runs forever.

Things to know

Question	Answer
Where do my apps live?	Each app gets its own address ending in `roxer.com`. Attach a custom domain later from roxer.com/domains.
Can Claude update an existing app?	Yes — just say "make this change to my todo app" and Claude knows where to find it.
Can Claude delete one?	Yes, but it always confirms with you first.
Will it cost me?	Roxer's free plan covers most starter apps. Heavier traffic or custom domains move you to a paid plan — see Pricing.
Is it safe?	Yes. Your Claude conversation never sees your Roxer API key directly — the key is exchanged for a temporary token in your browser, and only that token is used for deploys. Revoke any time from the Connectors page.

If something goes wrong

Symptom	Fix
"Add custom connector" button missing	You're on the Free plan and already have one custom connector. Remove the other one or upgrade.
Browser tab opens but the page errors	Refresh once. If still broken, your API key may have been rotated — recover a fresh one at roxer.com/recovery.
"Invalid API key" on the connect page	Make sure you copied the whole key. They're long. Try again.
Connector shows a red dot after a few weeks	The session token expired. Click Connect again to refresh.
Claude doesn't see Roxer in a chat	In the conversation, open the tools panel near the message box and make sure Roxer is checked.
Deploy says "build failed"	Ask Claude to look at the error and fix it — it has access to the build logs.

Disconnecting

Open Claude Desktop → Settings → Connectors → click Roxer → Disconnect. That immediately revokes Claude's access to your account. You can reconnect any time.

API Reference

All endpoints require an X-Api-Key: YOUR_KEY header. Base URL: https://roxer.com/api

Pages

POST /api/publish

Publish a new HTML page.

$ curl -X POST https://roxer.com/api/publish \
  -H "X-Api-Key: YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{"html": "<h1>Hello World</h1>"}'

# Response
{
  "id": "abc123",
  "url": "https://roxer.com/abc123",
  "created": "2026-04-27T10:30:00Z"
}

PUT /api/pages/{id}

Update an existing page's content.

$ curl -X PUT https://roxer.com/api/pages/abc123 \
  -H "X-Api-Key: YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{"html": "<h1>Updated</h1>"}'

# Response
{
  "id": "abc123",
  "url": "https://roxer.com/abc123",
  "updated": "2026-04-27T11:00:00Z"
}

DELETE /api/pages/{id}

Delete a page.

$ curl -X DELETE https://roxer.com/api/pages/abc123 \
  -H "X-Api-Key: YOUR_KEY"

# Response
{
  "deleted": true
}

GET /api/pages/{id}/stats

Get analytics for a page.

$ curl https://roxer.com/api/pages/abc123/stats \
  -H "X-Api-Key: YOUR_KEY"

# Response
{
  "id": "abc123",
  "views": 1423,
  "unique_visitors": 892,
  "last_viewed": "2026-04-27T14:22:00Z"
}

Apps

POST /api/apps/deploy

Deploy a new app or update an existing one. Send source as a ZIP.

$ curl -X POST https://roxer.com/api/apps/deploy \
  -H "X-Api-Key: YOUR_KEY" \
  -F "source=@project.zip" \
  -F "name=my-api"

# Response
{
  "id": "app_x7k9m2",
  "name": "my-api",
  "url": "https://roxer.com/my-api",
  "status": "deploying"
}

GET /api/apps/{id}/status

Get the current status of an app.

$ curl https://roxer.com/api/apps/app_x7k9m2/status \
  -H "X-Api-Key: YOUR_KEY"

# Response
{
  "id": "app_x7k9m2",
  "name": "my-api",
  "status": "running",
  "runtime": "node20",
  "url": "https://roxer.com/my-api",
  "last_deployed": "2026-04-27T10:30:00Z"
}

GET /api/apps/{id}/logs

Retrieve recent logs for an app.

$ curl https://roxer.com/api/apps/app_x7k9m2/logs \
  -H "X-Api-Key: YOUR_KEY"

# Response
{
  "logs": [
    { "ts": "2026-04-27T10:30:01Z", "msg": "Server listening on port 3000" },
    { "ts": "2026-04-27T10:30:05Z", "msg": "GET / 200 12ms" }
  ]
}

GET /api/apps/{id}/env

List all environment variables for an app.

$ curl https://roxer.com/api/apps/app_x7k9m2/env \
  -H "X-Api-Key: YOUR_KEY"

# Response
{
  "env": {
    "DB_PATH": "/mnt/data/app.db",
    "NODE_ENV": "production"
  }
}

PUT /api/apps/{id}/env

Set one or more environment variables.

$ curl -X PUT https://roxer.com/api/apps/app_x7k9m2/env \
  -H "X-Api-Key: YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{"DB_PATH": "/mnt/data/app.db"}'

# Response
{
  "updated": true
}

DELETE /api/apps/{id}/env/{key}

Remove an environment variable.

$ curl -X DELETE https://roxer.com/api/apps/app_x7k9m2/env/DB_PATH \
  -H "X-Api-Key: YOUR_KEY"

# Response
{
  "deleted": true
}

DELETE /api/apps/{id}

Delete an app and all its data.

$ curl -X DELETE https://roxer.com/api/apps/app_x7k9m2 \
  -H "X-Api-Key: YOUR_KEY"

# Response
{
  "deleted": true
}

Auth & Billing

POST /api/checkout

Create a Stripe checkout session to upgrade your plan.

$ curl -X POST https://roxer.com/api/checkout \
  -H "X-Api-Key: YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{"plan": "pro"}'

# Response
{
  "checkout_url": "https://checkout.stripe.com/c/pay_..."
}

POST /api/auth/api-key

Rotate your API key. Requires your current key in the X-Api-Key header. The old key is immediately invalidated. Lost your key? Use the recovery flow instead.

$ curl -X POST https://roxer.com/api/auth/api-key \
  -H "X-Api-Key: YOUR_CURRENT_KEY"

# Response
{
  "api_key": "abc123...",
  "plan": "pro"
}

POST /api/auth/recovery-request

Request a recovery email to reset a lost API key. Rate-limited to 3 requests per hour. Always returns 200 regardless of whether the email exists (no enumeration).

$ curl -X POST https://roxer.com/api/auth/recovery-request \
  -H "Content-Type: application/json" \
  -d '{"email": "you@example.com"}'

# Response
{
  "ok": true,
  "message": "If an active account exists, a recovery email has been sent."
}

GET /api/auth/plan

Get your current plan and usage.

$ curl https://roxer.com/api/auth/plan \
  -H "X-Api-Key: YOUR_KEY"

# Response
{
  "plan": "pro",
  "pages_today": 42,
  "pages_limit": 1000,
  "apps_count": 3,
  "apps_limit": 10
}

Forgot your API key?

Roxer doesn't store your API key in plain text — only a one-way fingerprint of it. So no one (not even Roxer support) can show it to you again. But you can mint a fresh one in two minutes.

Go to roxer.com/recovery.
Enter the email you used when you signed up. Click Send recovery link.
Check your inbox for an email from noreply@roxer.com titled "Reset your Roxer API key". Click the link inside (good for 30 minutes, single-use).
The page displays a fresh API key one time. Copy it and save it somewhere safe. You cannot view this key again after you leave.

Heads up — rotating the key invalidates the old one. Anywhere your old key was saved (Claude Desktop connector, the @roxer/cli's ~/.roxer/auth.json, scripts, environment variables) needs the new key.

If you're using Claude Desktop, see Disconnecting — click Disconnect, then Connect, and paste your new key.

If you're using the CLI, run roxer login again and paste the new key.

Why no email arrived

Check spam/junk — sender is noreply@roxer.com.
Make sure you used the exact email you signed up with. Roxer doesn't reveal whether an email is registered (anti-spam policy), so you'll always see the same "if registered, we sent you a link" message.
The recovery flow is rate-limited at 3 requests per hour per IP — if you've already requested several, wait an hour.

Pricing

Free plans. Request access to unlock Hosting and Max.

	Quick Sharing	Hosting (invite only, free)	Max (invite only, free)
Pages per hour	20	1,000	1,000
Page size	2 MB	10 MB	10 MB
Apps	No	5	100
Page lifetime	30 days	Permanent	Permanent
Custom domains	No	Yes	Yes
Roxer branding	Yes	Removed	Removed
SQLite persistence	No	Yes	Yes

Request Access (free)

Architecture

Roxer is built entirely on AWS. Every component is managed, serverless, and scales automatically.

⚡ Lambda (compute)

📦 S3 (storage)

🌐 CloudFront (CDN)

📊 DynamoDB (metadata)

📁 EFS (SQLite persistence)

🔗 API Gateway (routing)

Isolation Model

Each deployed app runs in its own Lambda function. No shared processes, no shared memory. One app cannot affect another.

Build Pipeline

Server-side builds run in a sandboxed builder Lambda. Dependencies install with npm install --ignore-scripts (Node.js) or pip install (Python) in a clean environment. Build artifacts are packaged and deployed to the app's Lambda function.

Built on AWS. Not a weekend project. Production-grade infrastructure from day one. The same services that run Netflix, Airbnb, and Stripe.