Handlify

Overview

Handlify deploys the apps Claude builds for you — straight to Qiscus infrastructure. Ask in a Claude chat, or use this dashboard. No server to manage, no Git required, no ops queue.

Every app gets a live https://<id>.handlify.qiscus.io URL. You can gate who may open it (private / your team / anyone), attach a custom domain, set env secrets, and redeploy — all from chat or the dashboard.

Quickstart

  1. Open a Claude chat connected to the Qiscus Builder connector.
  2. Describe what you want built. Claude generates the files and deploys them.
  3. You get a live URL in ~20–40 seconds.
You: build a countdown landing page for our Q3 hackathon with a signup form,
     and deploy it.

Claude uses deploy_project under the hood and replies with the URL. Iterate by asking for changes — it redeploys at the same URL.

Deploying apps

Code Claude generates

The most common path. Claude writes the files and deploys them directly — no git repo needed. Static sites (HTML/CSS/JS) or Node apps. If the app needs a database, a managed PostgreSQL is provisioned and its DATABASE_URL injected automatically (credentials never shown).

From a public Git repo

Ask Claude to import the repo — give it the public https:// URL and it deploys via create_app_from_repo. Also works from the Handlify CLI.

From a private Git repo

Add an SSH deploy key on the Deploy keys page, put its public half as a read-only deploy key on the repo, then ask Claude to deploy the SSH URL. Multi-service repos deploy via docker-compose. Repos on the internal Forgejo use a shared deploy key — no per-repo setup needed.

Managing apps

Open an app from Apps to manage it. From the dashboard you can:

  • Environment secrets — add/remove env vars (values are write-only, never shown again), then Apply & redeploy.
  • Custom domain — serve the app from your own domain.
  • Access — choose who can open the URL (below).
  • Deployments & logs — build history + container logs.
  • Ownership — hand the app to someone else (see below).
  • Danger zone — permanently delete the app.

Or from chat: get_app, get_logs, restart_app, deploy_app, update_project, delete_project.

Auto-sleep & keep-awake — an app with no traffic for ~72h is put to sleep to save resources and auto-wakes on the next request (a few-second cold start), so you normally do nothing. Need one to stay up during a known busy window (a weekly quiz, a scheduled demo)? Pin Keep awake on the app's card (time-boxed, max 14 days, renewable) or from chat with set_keep_awake.

URL access

Control who can open an app's URL. Change it from the app's Access card, or from chat with set_access / get_access. Changes take effect immediately — no redeploy.

  • private — only you (the owner).
  • team — an allow-list of specific emails or whole domains (e.g. qiscus.com).
  • company — anyone with a @qiscus.com account.
  • public — anyone with the link.
  • password — public, gated by a shared password.

This is not the same as owning the app. An app has exactly ONE owner — the only one who can deploy, configure or delete it. Adding someone to team lets them open the URL, nothing more. To let someone else deploy it, transfer it: the Ownership card, transfer_owner in chat, or handlify transfer <uuid> <email>.

You: make gate-demo-b1c229 accessible only to andi@qiscus.com and me
Passwords & secrets: a URL password can be set in the dashboard (recommended) or passed inline via chat — if you pass it in chat it will appear in the transcript. It's always stored salted-hashed, never in plain text. Env secret values, API keys, and private deploy keys are dashboard-only and never travel through chat.

Custom domains

On the app's Custom domain card: add a domain you own, point its DNS (a CNAME or A record) at handlify.qiscus.io, click Check DNS, then Apply to this app. The app then serves on your domain alongside the auto-generated one.

Connect a client

Beyond the Claude.ai connector (which uses Google sign-in), you can call this MCP from a CLI or script with a personal API key. Generate one in Settings → API keys, then point a client at the endpoint with a Bearer header:

Claude Code

claude mcp add --transport http qiscus-builder \
  https://qiscus-coolify-mcp.qiscus.io/mcp \
  --header "Authorization: Bearer <your-key>"

Codex / other CLIs (via the mcp-remote bridge)

[mcp_servers.qiscus-builder]
command = "npx"
args = ["-y", "mcp-remote", "https://qiscus-coolify-mcp.qiscus.io/mcp", "--header", "Authorization: Bearer <your-key>"]

Cursor / generic JSON MCP config

{
  "mcpServers": {
    "qiscus-builder": { "url": "https://qiscus-coolify-mcp.qiscus.io/mcp", "headers": { "Authorization": "Bearer <your-key>" } }
  }
}

Keys are scoped like the dashboard (only your own apps) and revocable anytime.

MCP tools

list_apps / get_appList your apps / one app's details.
get_logs / list_deployments_for_appContainer logs / deploy history.
deploy_projectDeploy code Claude generated (static/node, optional DB).
create_app_from_repo / deploy_private_repoDeploy from a public / private git repo.
update_project / deploy_app / restart_appRedeploy / trigger / restart.
get_access / set_accessRead / set who can open a URL.
manage_secretsGet the dashboard link to set env secrets out-of-band.
transfer_ownerHand an app to another user — one owner per app, and the owner is who may deploy it (owner/admin).
delete_projectDelete an app (owner/admin).

Roles

  • viewer — read-only (list/get/logs) + read access levels.
  • developer — viewer + deploy, restart, update, delete, manage secrets, set access.
  • admin — everything.

You only ever see and act on your own apps (admins see all). Roles are per-email.