# Quick Start **Page:** getting-started/quickstart [Download Raw Markdown](./getting-started/quickstart.md) --- # Quick Start **Three commands. That's all it takes.** In the next 5 minutes, you'll spawn a computer, run code on it, and share it with a URL. No installation. No configuration. No deployment step. Just HTTP. Or skip all of this and just: ```bash ssh hoody.com ``` That's it. Full Hoody OS in your terminal. From any device, anywhere. But let's start with the API approach first. --- ## Step 1: Get Your API Token Sign up at [hoody.icu](https://hoody.icu) and grab your API token from the dashboard. This token authenticates every request you make. ```bash # Install the Hoody SDK (includes CLI) npm install -g @hoody-ai/hoody-sdk # Authenticate hoody auth login ``` ```typescript import { HoodyClient } from '@hoody-ai/hoody-sdk'; const client = new HoodyClient({ baseURL: 'https://api.hoody.icu', token: process.env.HOODY_TOKEN }); ``` ```bash # Set your token as an environment variable export HOODY_TOKEN="your-api-token" # Test authentication curl -H "Authorization: Bearer $HOODY_TOKEN" \ https://api.hoody.icu/api/v1/users/auth/me ``` --- ## Step 2: Create a Project & Container A **project** organizes your containers. A **container** is a full Linux computer — Debian 13, systemd, the works — already online the moment it's created. ```bash # Create a project hoody projects create --alias "my-first-project" # Spawn a container (a full Linux computer) hoody containers create --project $PROJECT_ID --server-id $SERVER_ID --name "dev-box" ``` ```typescript // Create a project const project = await client.api.projects.create({ alias: 'my-first-project' }); // Spawn a container const container = await client.api.containers.create(project.data.id, { server_id: SERVER_ID, name: 'dev-box' }); console.log('Your computer is live:', container.data.id); ``` ```bash # Create a project curl -X POST https://api.hoody.icu/api/v1/projects \ -H "Authorization: Bearer $HOODY_TOKEN" \ -H "Content-Type: application/json" \ -d '{"alias": "my-first-project"}' # Create a container curl -X POST https://api.hoody.icu/api/v1/projects/$PROJECT_ID/containers \ -H "Authorization: Bearer $HOODY_TOKEN" \ -H "Content-Type: application/json" \ -d '{"server_id": "'"$SERVER_ID"'", "name": "dev-box"}' ``` Your container is already online. No boot time, no provisioning, no DNS propagation. Every service in that container — terminal, files, database, display — has a URL right now. --- ## Step 3: Use Your Computer Your container has the full Hoody Kit HTTP service stack built in — terminal, files, exec, sqlite, cron, pipe, browser, code, displays, daemon, notifications, tunnel, workspaces, curl, ssh, proxy, plus dynamic `http`/`https` ports. Let's use a few: ### Run a Command ```bash # Execute a shell command on your container hoody terminal sessions exec --ephemeral --command "echo 'Hello from the cloud!'" ``` ```typescript const containerClient = await client.withContainer({ id: container.data.id, project_id: container.data.project_id, server: container.data.server_name }); const result = await containerClient.terminal.execution.execute({ command: "echo 'Hello from the cloud!'" }); console.log(result.data.stdout); // "Hello from the cloud!" ``` ```bash curl -X POST "https://$PROJECT-$CONTAINER-terminal-1.$SERVER.containers.hoody.icu/api/v1/terminal/execute?ephemeral=true" \ -H "Content-Type: application/json" \ -d '{"command": "echo Hello from the cloud!", "wait": true}' ``` ### Read a File ```bash # Read a file from your container hoody files get /etc/hostname ``` ```typescript const file = await containerClient.files.get('/etc/hostname', { responseType: 'text' }); console.log(file.data); ``` ```bash curl "https://$PROJECT-$CONTAINER-files-1.$SERVER.containers.hoody.icu/etc/hostname" ``` ### Query a Database ```bash # Run a SQL query on the built-in SQLite hoody db exec-transaction --db app --create-db-if-missing --transaction '[{"statement":"CREATE TABLE greetings (message TEXT)"},{"statement":"INSERT INTO greetings VALUES ('"'"'Hello, Hoody!'"'"')"},{"query":"SELECT * FROM greetings"}]' ``` ```typescript const sqliteUrl = `https://${PROJECT_ID}-${CONTAINER_ID}-sqlite-1.${SERVER}.containers.hoody.icu`; const result = await fetch(`${sqliteUrl}/api/v1/sqlite/db?db=app&create_db_if_missing=true`, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ transaction: [ { statement: "CREATE TABLE greetings (message TEXT)" }, { statement: "INSERT INTO greetings VALUES ('Hello, Hoody!')" }, { query: "SELECT * FROM greetings" } ] }) }).then(r => r.json()); console.log(result); // { results: [{ resultSet: [{ message: 'Hello, Hoody!' }] }] } ``` ```bash curl -X POST "https://$PROJECT-$CONTAINER-sqlite-1.$SERVER.containers.hoody.icu/api/v1/sqlite/db?db=app&create_db_if_missing=true" \ -H "Content-Type: application/json" \ -d '{"transaction": [{"statement": "CREATE TABLE greetings (message TEXT)"}, {"statement": "INSERT INTO greetings VALUES ('"'"'Hello, Hoody!'"'"')"}, {"query": "SELECT * FROM greetings"}]}' ``` --- ## Step 4: Open Hoody OS You've been using the API directly. Now open the visual experience — **Hoody OS**. Hoody OS is a full web-based operating system that lives **inside each of your containers** — every container you spin up gets its own OS, on a server you own. It's served by the `workspaces` service: - **Hoody Workspaces** (`https://{projectId}-{containerId}-workspaces-1.{server}.containers.hoody.icu`) — A floating-window desktop where you arrange terminals, code editors, displays, files, and AI agents side by side. The Home dashboard and Console management views are apps inside this workspace, navigated to via in-app paths rather than separate service subdomains. Every app is a URL. Open it in any browser. Embed it in an iframe. Share it with a teammate. Control it via AI agent. The URLs just work — HTTPS with HTTP/2 and HTTP/3, zero configuration, zero certificates to manage. Ever. The inception: Hoody OS itself runs on a Hoody container. The OS that manages your containers is running in a container. It's embeddable, shareable, and multiplayer — just like everything else. ### From Any Browser Open your Workspace URL in any browser. Phone, laptop, TV, tablet — same environment, same state. ### From Any Terminal ```bash ssh hoody.com ``` Full Hoody OS as a TUI (Terminal User Interface). We built an entire browser engine for the terminal (`hoody-terminal-browser`), so you get the same OS experience — floating windows, AI chat, file management — rendered in pure text. Access from literally anything that supports SSH: a Raspberry Pi, an ESP32 (we won't judge), a server with no GUI, or your phone's terminal app. No per-machine SSH key upload required for this gateway — it opens a Hoody login screen (the same one you see in a browser) inside the TUI as soon as you connect. This is distinct from container SSH, which uses per-container public keys and the `ssh.$serverName.containers.hoody.icu` gateway — see [Networking → SSH](/foundation/networking/ssh/) for container shell access. --- ## What Just Happened? You just: 1. **Spawned a full Linux computer** — not a VM, not a Docker container, a real isolated system 2. **Ran commands on it via HTTP** — no SSH, no keys, no client software 3. **Read files and queried a database** — all through URLs 4. **Made it accessible from anywhere** — it was already online from the moment it was created **This is the HTTP revolution.** Every program, every file, every process is a URL. --- ## What's Next Learn what makes Hoody containers different from everything else. [Containers →](/getting-started/containers/) Discover all 18 HTTP services built into every container. [The Hoody Kit →](/kit/) Follow a guide to build a full-stack app, deploy AI agents, or vibe code. [Guides →](/guides/full-stack-app/) Understand why we rebuilt computing from scratch. [Understanding Hoody →](/vision/obsolescence/)