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 deploy .
Deployed! https://roxer.com/my-app

No account required for free tier. Just install and publish. The CLI generates an API key on first use.

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://api.roxer.com/api/publish \
  -H "Authorization: Bearer YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{"html": "<h1>Hello</h1>"}'

# Publish a ZIP with entry point
$ curl -X POST https://api.roxer.com/api/publish \
  -H "Authorization: Bearer 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
Auto-sleep after 15 minutes of inactivity
Wakes automatically on the first incoming request (cold start: ~2 seconds)

CLI Commands

# Deploy the current directory
$ roxer deploy .

# Deploy with a custom app name
$ 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

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`

MCP Setup (Claude Code)

Use Roxer directly from Claude Code, Cursor, or any MCP-compatible AI tool. One command to set up, then just ask Claude to deploy.

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.

API Reference

All endpoints require an Authorization: Bearer YOUR_KEY header. Base URL: https://api.roxer.com

Pages

POST /api/publish

Publish a new HTML page.

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

# Response
{
  "id": "abc123",
  "url": "https://roxer.com/abc123",
  "created": "2025-01-15T10:30:00Z"
}

PUT /api/pages/{id}

Update an existing page's content.

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

# Response
{
  "id": "abc123",
  "url": "https://roxer.com/abc123",
  "updated": "2025-01-15T11:00:00Z"
}

DELETE /api/pages/{id}

Delete a page.

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

# Response
{
  "deleted": true
}

GET /api/pages/{id}/stats

Get analytics for a page.

$ curl https://api.roxer.com/api/pages/abc123/stats \
  -H "Authorization: Bearer YOUR_KEY"

# Response
{
  "id": "abc123",
  "views": 1423,
  "unique_visitors": 892,
  "last_viewed": "2025-01-15T14: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://api.roxer.com/api/apps/deploy \
  -H "Authorization: Bearer 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://api.roxer.com/api/apps/app_x7k9m2/status \
  -H "Authorization: Bearer YOUR_KEY"

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

GET /api/apps/{id}/logs

Retrieve recent logs for an app.

$ curl https://api.roxer.com/api/apps/app_x7k9m2/logs \
  -H "Authorization: Bearer YOUR_KEY"

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

GET /api/apps/{id}/env

List all environment variables for an app.

$ curl https://api.roxer.com/api/apps/app_x7k9m2/env \
  -H "Authorization: Bearer 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://api.roxer.com/api/apps/app_x7k9m2/env \
  -H "Authorization: Bearer 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://api.roxer.com/api/apps/app_x7k9m2/env/DB_PATH \
  -H "Authorization: Bearer YOUR_KEY"

# Response
{
  "deleted": true
}

DELETE /api/apps/{id}

Delete an app and all its data.

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

# Response
{
  "deleted": true
}

Auth & Billing

POST /api/checkout

Create a Stripe checkout session to upgrade your plan.

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

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

POST /api/auth/api-key

Generate or rotate your API key.

$ curl -X POST https://api.roxer.com/api/auth/api-key \
  -H "Authorization: Bearer YOUR_KEY"

# Response
{
  "api_key": "rxr_live_abc123..."
}

GET /api/auth/plan

Get your current plan and usage.

$ curl https://api.roxer.com/api/auth/plan \
  -H "Authorization: Bearer YOUR_KEY"

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

Pricing

Simple, transparent pricing. Start free, upgrade when you need more.

	Quick Sharing	Hosting ($19/mo)	Max ($49/mo)
Pages per hour	20	1,000	1,000
Page size	2 MB	10 MB	10 MB
Apps	No	5	100
Page lifetime	14 days	Permanent	Permanent
Custom domains	No	Yes	Yes
Roxer branding	Yes	Removed	Removed
SQLite persistence	No	Yes	Yes

View Pricing & Upgrade

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.