InstantDeploy

InstantDeploy (instantdeploy.site) is a hosting layer built for AI agents. It publishes any static site globally in under 2 seconds with zero configuration — no Git commits, no CI/CD pipelines, no dashboard setup, and no account needed for the first ship.

Website · API docs · OpenAPI spec · llms.txt

In the era of agentic coding — Claude Code, Cursor, Codex, Windsurf — development cycles have compressed from hours to seconds, but legacy hosting friction remains high. InstantDeploy removes the traditional "deployment step" so agents can iterate visually, share prototypes instantly, and build the web at the speed of thought.

InstantDeploy is agent-first by design: the CLI prints the deploy URL to stdout so agents can capture it, the API is described in a machine-readable spec at https://api.instantdeploy.site/openapi.json, and a plain-text integration guide lives at instantdeploy.site/llms.txt.

How it works

Deploy a directory and get a unique subdomain in the form https://<slug>.instantdeploy.site/ (for example, rapid-neon-otter.instantdeploy.site). Deploys are anonymous by default and expire after 24 hours — each one returns a 6-character claim code that converts it to permanent ownership via the CLI, the API, or the web at https://instantdeploy.site/claim?code=ABC123.

1curl -fsSL https://instantdeploy.site/install.sh | bash -s -- .  # install + deploy .

Who it's for: anything that can run a shell command or make an HTTP request — Claude Code, Cursor, Codex, and any other coding agent. Humans get the same one-liner; agents get stdout-capturable URLs, Bearer-token auth, and named API keys (one per agent or project).

What you get

Speed

Average deployment time under 1.8 seconds from upload to live URL, served from CDN-integrated object storage.

Zero setup

No Git, no account, no configuration for the initial ship. One shell command turns a local directory into a live URL.

Anonymous to permanent

Ship first, own later. A 6-character claim code upgrades any anonymous deploy to permanent, and Bearer-key deploys persist from the start.

Remix

Every deployed HTML page gets a small Remix button, so viewers can hand the site's source to their own agent and ship their own version.

Limits at a glance

Archive size: 100 MB maximum (.zip, .tar.gz, .tgz, .gz)
Content: static files only — HTML, CSS, JS, images, fonts, PDFs, videos; no server-side code
Expiry: 24 hours for anonymous deploys; none for claimed deploys
Rate limiting: configured per-IP on the API
API keys: up to 50 active named keys per account; custom domains: up to 20 per account

Quick start

This walks you from nothing to a live URL in one command, then shows how to keep the site permanently. Everything here works for humans and agents alike — the CLI prints the deploy URL to stdout so an agent can capture it.

Install the CLI (and optionally deploy in the same command)
The installer detects your local environment and sets up the instantdeploy command. Pass a directory to install and deploy in one line:
curl -fsSL https://instantdeploy.site/install.sh | bash # install only curl -fsSL https://instantdeploy.site/install.sh | bash -s -- . # install + deploy .
Deploy a directory
Point the CLI at any folder of static files (HTML, CSS, JS, images, fonts, PDFs, videos — max 100 MB archived):
instantdeploy . # deploy the current directory instantdeploy ship <dir> # deploy a specific directory
You get back a unique URL like https://rapid-neon-otter.instantdeploy.site — live in under 2 seconds. Anonymous deploys also return a 6-character claim code.
Claim the deploy to keep it
Anonymous deploys expire after 24 hours. Claiming converts one to permanent ownership:
instantdeploy claim <code> # needs an API key (see next step)
No CLI handy? Claim on the web at https://instantdeploy.site/claim?code=ABC123, or via POST /v1/dashboard/claim — see the API reference.
Authenticate for permanent deploys
With an API key, deploys are permanent from the start and appear in your dashboard:
instantdeploy login <api-key> # saves the key to ~/.instantdeploy/credentials instantdeploy whoami # verify the key (prints account email) instantdeploy list # list your deployments
To get a key, sign up at instantdeploy.site — or programmatically via POST /v1/auth/signup then GET /v1/auth/me (see Accounts and API keys). The CLI also honors the INSTANTDEPLOY_API_KEY and INSTANTDEPLOY_API_URL environment variables.

Deploys are public by default and appear in the homepage live feed. To keep a site link-only, ship it unlisted — it stays reachable by direct URL but is excluded from the feed and gets a robots-noindex tag:

1instantdeploy ship --unlisted .

For anonymous publishes, always surface the expiry to whoever asked for the deploy: the site disappears in 24 hours unless claimed. Agents should return the url, the slug, and the claim link to the user.

API reference

Everything the CLI does is one HTTP call away. The base URL is https://api.instantdeploy.site, the machine-readable spec is at https://api.instantdeploy.site/openapi.json, and interactive docs live at https://api.instantdeploy.site/docs.

Auth modes

Two modes cover every endpoint below — the difference is whether the deploy persists:

Anonymous: omit the Authorization header. Deploys expire in 24 hours and return a claim_code.
Authenticated: include Authorization: Bearer <API_KEY>. Deploys are permanent and appear in your dashboard. The Bearer key works on /v1/ship, /v1/auth/me, and all /v1/dashboard/* endpoints.

POST /v1/ship

Create a deployment by uploading an archive as multipart/form-data with a file field (.zip, .tar.gz, .tgz, .gz — max 100 MB). Add the Bearer header to claim it immediately.

123curl -X POST https://api.instantdeploy.site/v1/ship \
  -H "Authorization: Bearer $INSTANTDEPLOY_API_KEY" \
  -F "file=@site.zip"

The 201 response returns the live url, the slug, and created_at:

12345{
  "url": "https://rapid-neon-otter.instantdeploy.site",
  "slug": "rapid-neon-otter",
  "created_at": "2026-02-27T12:00:00+00:00"
}

Rate limits are enforced per-IP: a 429 RateLimitExceeded response carries a Retry-After header. Oversized archives return 413 FileSizeExceeded; malformed ones return 400 (InvalidFormat, ExtractionFailed).

Presigned publish (recommended for large sites)

A two-step alternative to /v1/ship where the archive uploads straight to storage:

Request an upload URL
POST /v1/publish with JSON { "filename": "site.zip", "file_size_bytes": 12345, "visibility": "public" } — returns a slug, an upload_url (expires in 30 minutes), and a publish_token.
Upload the archive
PUT the zip to upload_url with the header x-ms-blob-type: BlockBlob.
Finalize
POST /v1/publish/{slug}/finalize with JSON { "publish_token": "..." } — add Authorization: Bearer <key> to claim it. Returns the live url.

Other deployment endpoints

GET /v1/deployments — list recent deployments (powers the homepage feed).
GET /v1/remix/{slug} — fetch all files of a deployment (path, content, size) so an agent can remix it.

Visibility

Deploys default to public and appear in the homepage live feed:

Unlisted at deploy time: pass -F "visibility=unlisted" to POST /v1/ship (CLI: instantdeploy ship --unlisted .). Anyone with the link can view, but the site is excluded from the feed and its HTML gets a robots-noindex tag.
Toggle later: PATCH /v1/dashboard/sites/{slug}/visibility with { "visibility": "public" | "unlisted" } (owner only).

Accounts and API keys

How an agent goes from nothing to a permanent key:

Sign up: POST /v1/auth/signup with { "email": "user@example.com", "password": "min8chars" } — send credentials: include to receive the session cookie.
Get the key: GET /v1/auth/me with that cookie — the response includes api_key.
Deploy: POST /v1/ship with Authorization: Bearer <api_key>.

Also available: POST /v1/auth/login and POST /v1/auth/sign-out.

Managing keys:

Named keys (recommended — one per agent/project): create with POST /v1/dashboard/api-keys and { "name": "claude-code" } — the full key is returned once. List previews with GET /v1/dashboard/api-keys; revoke with DELETE /v1/dashboard/api-keys/{id} (immediate, other keys unaffected). Up to 50 active keys per account.
Custom key: POST /v1/dashboard/set-api-key with { "api_key": "your-24-64-char-key" } (url-safe: A-Za-z0-9_-).
Rotate: POST /v1/dashboard/regenerate-api-key.

Claiming anonymous deploys

Anonymous deploys return a 6-character claim_code. Make one permanent via any of:

CLI: instantdeploy claim <code> (needs an API key)
API: POST /v1/dashboard/claim with { "claim_code": "ABC123" } and Bearer auth
Web: https://instantdeploy.site/claim?code=ABC123

Custom domains

Serve a claimed deployment on your own domain with automatic SSL (up to 20 domains per account):

Add the domain
POST /v1/dashboard/domains with { "domain": "example.com", "slug": "your-slug" } (Bearer auth; you must own the deployment). The response includes two DNS records: a TXT record for ownership proof and an A record pointing at InstantDeploy.
Verify after DNS propagates
POST /v1/dashboard/domains/{id}/verify.
Done — SSL is automatic
SSL is issued automatically on the first request; no further steps. Manage with GET /v1/dashboard/domains and DELETE /v1/dashboard/domains/{id}.

Agent etiquette (from the platform's own guidance): always return the url and slug to the user; for anonymous publishes, mention the 24-hour expiry and give the claim link; prefer Bearer-key deploys so sites show up in the dashboard. And remember — every deployed HTML page gets a small Remix button.

Error shape

All error responses use a single envelope: { "error": { "code": "...", "message": "...", "details": {...} } }.

Architecture

InstantDeploy is built on a high-availability, low-latency stack designed for programmatic scale. The guiding idea is ephemeral infrastructure: uploads stream straight to CDN-backed object storage, metadata stays in a small relational store, and a serverless collector keeps free anonymous hosting from accumulating bloat.

Core stack

Frontend: Next.js 16 (App Router), Tailwind CSS 4, React-Markdown
Backend: Python (FastAPI), SQLAlchemy (Async), Pydantic
Database: PostgreSQL (Azure Database for PostgreSQL – Flexible Server)
Cache/Queue: Redis (Azure Cache for Redis) for rate limiting
Object storage: Azure Blob Storage (CDN-integrated)
Infrastructure: Azure VM (Ubuntu), Docker, Caddy (automatic HTTPS)
Serverless: Azure Functions (garbage collector) for managing ephemeral data

Deploy path

An upload travels from the agent to a live URL through a single streaming path — the API never buffers the whole site before storage sees it.

agent / CLI                                            browser
    |                                                     ^
    | POST /v1/ship (zip)                                 | <slug>.instantdeploy.site
    v                                                     |
+-------------------+   stream files   +-------------------------------+
| FastAPI (api)     |----------------->| Azure Blob Storage (CDN)      |
| validate + slug   |                  +-------------------------------+
+----+---------+----+                                 ^
     |         |                                      | delete expired blobs
     v         v                                      |
+----------+ +-------------+          +---------------+---------------+
|PostgreSQL| | Redis       |          | Azure Function (hourly GC)    |
| metadata | | rate limits |          | prunes expired deploy records |
+----------+ +-------------+          +-------------------------------+

Component breakdown

The API layer (apps/api). Built with FastAPI for maximum performance. It handles zip-based binary uploads, validates content, and streams data directly to Azure Blob Storage. It implements a multi-tenant slug system (e.g. rapid-neon-otter) and manages the anonymous-to-permanent claim flow.

The web platform (apps/web). A premium, dark-mode landing page. Its notable pieces are a real-time live feed of active anonymous deployments (skeleton states plus micro-animations), a Markdown blog engine using gray-matter for frontmatter, and a copy-to-clipboard system — a customized renderer that injects copy icons into all CLI commands and code snippets.

Automatic garbage collection. To support free, anonymous hosting without bloat, a serverless Azure Function monitors the metadata store and deletes expired blobs and database records every hour, keeping infrastructure clean and cost-effective.

The CLI installer (apps/cli). A frictionless shell script that detects the local environment and provides a one-line setup for AI agents — it turns any local directory into a live URL with a single command.

The claim flow is what makes ephemerality safe: anonymous deploys carry a 24-hour TTL enforced by the garbage collector, but claiming one (or deploying with a Bearer key) removes the expiry entirely.

Key outcomes

Speed: average deployment time under 1.8 seconds
Simplicity: no Git, no account, no setup required for the initial ship
Premium UX: high-fidelity design with Inter/Zinc aesthetics and glassmorphism
SEO ready: full metadata integration for viral sharing and agent discoverability

For AI agents

Copy this block into Cursor, Claude Code, or any coding agent to deploy with InstantDeploy correctly:

1234567891011121314151617181920212223242526272829303132333435363738394041424344# InstantDeploy — agent integration instructions

Publish static sites to live URLs with InstantDeploy
(https://instantdeploy.site). Follow these rules exactly:

1. Install the CLI (optionally deploying in the same command):
   curl -fsSL https://instantdeploy.site/install.sh | bash          # install
   curl -fsSL https://instantdeploy.site/install.sh | bash -s -- .  # + deploy
2. Deploy with `instantdeploy .` or `instantdeploy ship <dir>` — the live
   URL prints to stdout; capture it. Or skip the CLI entirely:
   POST https://api.instantdeploy.site/v1/ship as multipart/form-data with
   a `file` field (.zip/.tar.gz/.tgz/.gz, max 100 MB, static files only).
3. Anonymous deploys (no Authorization header) EXPIRE IN 24 HOURS and
   return a 6-character claim_code. Always report the url, the slug, the
   expiry, and the claim link
   (https://instantdeploy.site/claim?code=<code>) to the user.
4. Prefer authenticated deploys: send Authorization: Bearer <API_KEY> so
   deploys are permanent from the start. The CLI honors
   INSTANTDEPLOY_API_KEY; `instantdeploy login <key>` saves it, and
   `instantdeploy whoami` / `instantdeploy list` verify and list.
5. To get a key programmatically: POST /v1/auth/signup with
   {email, password (min 8 chars)}, then GET /v1/auth/me with the session
   cookie — the response includes api_key. Create named keys (one per
   agent) with POST /v1/dashboard/api-keys {name} — the key is returned
   once. Max 50 active keys per account.
6. Claim an anonymous deploy with `instantdeploy claim <code>` or
   POST /v1/dashboard/claim {claim_code} with Bearer auth.
7. For large sites use the presigned flow: POST /v1/publish
   {filename, file_size_bytes, visibility} -> PUT the zip to upload_url
   with header x-ms-blob-type: BlockBlob (URL expires in 30 min) ->
   POST /v1/publish/{slug}/finalize {publish_token}.
8. Deploys are public by default and appear in the homepage live feed;
   pass `--unlisted` (CLI) or visibility=unlisted (API) for link-only
   sites, or toggle later via
   PATCH /v1/dashboard/sites/{slug}/visibility.
9. Custom domains: POST /v1/dashboard/domains {domain, slug}, set the
   returned TXT and A records, then POST /v1/dashboard/domains/{id}/verify.
   SSL is automatic on first request. Max 20 domains per account.
10. Handle errors via the envelope {error: {code, message, details}} —
    429 RateLimitExceeded (per-IP, honor Retry-After), 413
    FileSizeExceeded, 400 InvalidFormat/ExtractionFailed. Machine-readable
    spec: https://api.instantdeploy.site/openapi.json

Docs: https://docs.aliarain.com/instantdeploy

Agents can also read this page as plain markdown — every page on this site is available to LLMs in raw form via the docs' llms.txt index.

Ask AI about this page