# Every project gets its own web address on day one

> Every project gets a free https://<slug>.vibiz.app address on day one with HTTPS included, active for as long as the project exists.

**Every project created on thelastapi gets a free, live web address at `https://<slug>.vibiz.app` the moment it is provisioned.** You do not need to register a domain, configure DNS records, or manage SSL certificates to put your app online. As soon as you deploy your code, your site answers publicly over HTTPS at that address for as long as your project exists.

When you start a side project, buying a custom domain before you validate the idea adds friction and cost. You need an address immediately so you can test sign-in flows, share preview links with early users, and verify your build in production. Here is how the default web address works, how to deploy to it, and how to manage it as your project grows.

## How your project gets its address

When you initialize a project using the CLI, thelastapi creates your project and provisions its core resources. By default, this includes hosting, serverless Postgres, sign-in, and analytics:

```bash
mkdir my-app && cd my-app
vibiz init "Acme Bakery"
```

This command generates a unique project slug based on your project name—such as `acme-bakery`—and writes a `./vibiz.json` configuration file containing your project ID. The address `https://acme-bakery.vibiz.app` is reserved for your project immediately.

You can also initialize a project from the API directly:

```bash
curl https://thelastapi.dev/v1/projects \
  -H "Authorization: Bearer $VIBIZ_API_KEY" \
  -H "content-type: application/json" \
  -d '{"name":"Acme Bakery"}'
```

The response returns a `202` status with your project details, including the assigned slug and the provisioning status of each resource. If you want a database alongside your web host from the start, see our guide on [Serverless Postgres for side projects: one database per project](https://thelastapi.dev/blog/postgres-database-per-project).

## Deploying your site in one command

Your `<slug>.vibiz.app` address becomes active on the web as soon as you run your first deploy. From your project folder, run:

```bash
vibiz deploy
```

Deploying works by content hash. The CLI hashes your files locally and checks them against the hosting service with `POST /v1/files/missing`. Only new or modified files are uploaded over HTTP via `PUT /v1/files/:sha`. Files that the host already stores are never uploaded twice. Once uploaded, the manifest is submitted, and the build goes live at your address.

To deploy static assets or a built frontend, read [Deploy a static site with one command](https://thelastapi.dev/blog/deploy-static-site-one-command). If your application requires a backend server or a full-stack framework, read [Deploy a Next.js app with a database and sign-in in one command](https://thelastapi.dev/blog/deploy-nextjs-app-database-sign-in).

The CLI automatically excludes files you would not want deployed:
- Dependencies and caches: `node_modules`, `.next`, `dist`, `.turbo`, and `.git`
- Project configuration: `vibiz.json`
- Local environment files: `.env*`
- Private credentials and keys: `*.pem`, `id_rsa`, `.npmrc`

If you want to review changes before updating your production address, deploy a preview version:

```bash
vibiz deploy ./site --preview
```

A preview deployment builds at an isolated URL. Once you verify that the build works, promote that deployment ID directly to your live production address:

```bash
vibiz promote dep_12345
```

Because production deployments keep their file manifests, promoting a preview deployment or switching back to an earlier build with `vibiz rollback` happens instantly without a rebuild.

## Limits and pricing for the default subdomain

Hosting on your assigned `.vibiz.app` address is not charged today. Builds and live sites are recorded in usage at $0 while pricing remains undecided. For budget-conscious founders, read [The cheapest way to host a website and database for a side project](https://thelastapi.dev/blog/cheapest-hosting-database-side-project) to see how the other resources fit together.

Here are the operational rules and limits for the hosting resource:

| Feature | Specification |
| --- | --- |
| Default URL format | `https://<slug>.vibiz.app` |
| HTTPS certificates | Included automatically for all addresses |
| Hosting price | $0 today (builds recorded at $0; pricing undecided) |
| Daily build limit | 30 builds per project per UTC day |
| Deployment file limit | Up to 10,000 files per deployment |
| Individual file size limit | Up to 50 MB per file |
| Rollback speed | Instant for production builds |
| Deletion retention | Data kept for 7 days after project deletion |

If you hit the 30-build limit within a UTC day, the platform answers `429 rate_limited`. You can inspect your daily build count at any time using `GET /v1/usage`.

To learn more about file manifests and deployment workflows, check the official [Hosting](https://thelastapi.dev/docs/hosting) documentation.

## Deploying from Claude Code, Cursor, or chat

You do not need to install the CLI locally to use your `.vibiz.app` address. If you build using Claude or ChatGPT, you can connect the remote Model Context Protocol (MCP) server located at `https://thelastapi.dev/mcp`.

When building from a chat interface:
1. The agent calls `vibiz_create_project { name: "Acme Bakery" }`.
2. The agent sends the project files using `vibiz_deploy { project_id, files: [...] }`.
3. The site builds and answers immediately at `https://<slug>.vibiz.app`.

Chat-based deployments support up to 300 files per call, with a limit of 3 MiB per individual file and 4 MiB total payload per deploy. When updating code later, the agent calls `vibiz_code { action: "read", project_id, paths: ["index.html"] }` and sends back only the modified files using `vibiz_deploy { project_id, files: [...], base: "live" }`.

For coding agents running on your machine—such as Claude Code, Codex, or Cursor—run:

```bash
vibiz mcp add --clients "Claude Code"
vibiz skills add --global
```

Your agent can then build the project, run tests locally using `vibiz dev`, and deploy straight to your public address. Detailed instructions for connecting agents can be found in the [Quickstart](https://thelastapi.dev/docs/quickstart) documentation.

## Monitoring uptime and health checks

Once your site answers at its `.vibiz.app` URL, thelastapi monitors it automatically. Every active project is checked about once an hour by the background monitoring system, which tests the address from a visitor's perspective using the user-agent `VibizStack-Health/1.0`.

The automated `Site up` check:
- **Fails** if the address answers with a `5xx` error, times out after 10 seconds, fails DNS resolution, or presents an invalid HTTPS certificate.
- **Warns** if the root path `/` answers with a `4xx` error or resolves over unencrypted HTTP.

You can inspect the health of your site from the command line:

```bash
vibiz health
```

To run an immediate health check on a specific project rather than waiting for the hourly scan:

```bash
vibiz health run acme-bakery
```

You can view health statuses across all your side projects at once inside [Mission Control and health checks](https://thelastapi.dev/docs/mission-control).

## Connecting a custom domain later

Your project never loses its `<slug>.vibiz.app` web address. If you later decide to brand your side project with a domain you own, you can add it on top of the existing hosting without interrupting the default address.

Add your domain using the CLI:

```bash
vibiz domains add shop.example.com
```

The command outputs the DNS records you need to add at your registrar. For a subdomain like `shop.example.com`, you point a `CNAME` record with the value `cname.vibiz.app`. Once DNS propagates and the HTTPS certificate issues, your custom domain becomes the project's `primary_url`. Both addresses continue to function side by side.

If you do not own a domain yet, you can also search and buy one directly using account credits via `vibiz domains buy sellshelf.app`. Domains bought through the platform configure their DNS automatically. Full domain management commands are covered in the [Domains](https://thelastapi.dev/docs/domains) reference.

## Next steps

To start a new project with its own live address, create your account at [thelastapi.dev/start](https://thelastapi.dev/start). Once your account is active, run `npm install -g @vibiz/cli`, execute `vibiz login`, and create your first site with `vibiz init`.

## Frequently asked questions

### Does the free .vibiz.app subdomain expire if I do not use it?

No, the subdomain remains active for as long as your project exists. If you delete a project, the address goes offline immediately, but you have a 7-day window during which you can restore the project and recover the site.

### Can I use sign-in with Google or GitHub on the default address?

Yes, projects created with default hosting include sign-in that works out of the box on your `https://<slug>.vibiz.app` address. When you work locally with `vibiz dev`, the sign-in resource also trusts `http://localhost:3000`.

### What happens if someone else already took the slug I want?

Project slugs must be unique across the platform. If a requested name produces a slug that another account or project already uses, the API returns a `409 domain_taken` error so you can pick a different project name.

### Can I export my project code and database if I want to leave?

Yes, running `vibiz export` downloads a complete snapshot containing your live source code, configuration guides, and your database as plain SQL that can be restored into any Postgres instance.

---

Published 2026-11-15 · https://thelastapi.dev/blog/project-address-vibiz-app
