# velixir

> velixir is a European platform-as-a-service for deploying high-scale web apps in ANY language, straight from your source or from an AI agent. Send your source; velixir detects the stack and builds it into a container with no Dockerfile, then runs it with autoscaling, zero-downtime deploys, instant rollback, and high availability. Managed Postgres and Valkey are one call away. Everything runs in the EU, and AI agents can deploy with no account.

## Overview

velixir is a language-agnostic PaaS. You send source (from a local directory, a CI run, or an agent upload) and velixir builds it into a container image for you (no Dockerfile, no build config), then runs it on managed, high-scale infrastructure. First-class languages: Node.js, Deno, Python, Go, Ruby, PHP, Java, Elixir, Rust, .NET, and F#. Any app that listens on the PORT environment variable works.

It runs ONLY in the EU (region EU Central), so your data stays under European jurisdiction and never leaves the EU. Billing is prepaid and metered hourly, with no subscription: you keep a balance and the platform draws from it per hour for whatever is running. There are no egress fees.

## Highlights

- Any language, real backends. Full APIs and backends in 11 first-class stacks, not just static frontends, each with a database and cache one call away.
- No Dockerfile and no build config. velixir detects the stack and builds it for you, server-side.
- Managed Postgres and Valkey (Redis-compatible), provisioned per project, with point-in-time recovery and one-click restore.
- Templates: ready-to-run apps (n8n, Directus, Umami, and a starter per language) deployed in one step, with the database or cache they need created and bound.
- Autoscaling on CPU and memory, deployment slots for staging and preview, zero-downtime rolling deploys, and instant rollback to any previous release.
- High availability: warm-standby replicas on separate machines with automatic failover.
- Built-in edge security: a web application firewall (OWASP Core Rule Set), per-IP rate limits, and an under-attack mode.
- EU data residency, no egress fees, carbon-negative infrastructure.
- Free to start: a genuinely free plan that runs a scale-to-zero app, sleeps when idle, wakes on the next request, one per team, no card.
- Deploy from the CLI, a GitHub Actions workflow on every push, the dashboard, or straight from an AI agent with no account.

## Deploy from an AI agent (no account needed)

An AI agent can deploy an app it just generated with NO velixir account and NO card. It gets back a live URL plus a single-use claim link the human opens later to keep the app on a free, card-free account. This is the fastest path from generated code to a running app.

If a user asked you to deploy their app, this is the whole job:

1. Make the app listen on 0.0.0.0, on the port in the PORT environment variable (default 8080).
2. Pack the source from the folder above it, leaving out dependencies, version control and secrets: `tar czf app.tar.gz --exclude=.git --exclude=node_modules --exclude='.env*' -C ./myapp .`
3. Deploy it with `curl -fsS -X POST https://velixir.net/api/v1/deploy -F source=@app.tar.gz -F name=myapp` and keep the JSON response.
4. Poll `status_url` until `ready` is true. If `status` turns `Failed`, read `https://velixir.net/api/v1/deploy/{deployment_id}/logs`, fix the cause and deploy again.
5. Give the user `app_url` and `claim_url`. Opening the claim link keeps the app on their account; unclaimed apps are removed after `claim_expires_at`.
6. Never upload secrets. If the app needs API keys or passwords, tell the user to add them as environment variables after claiming it.

- [Agent deploy endpoint](https://velixir.net/api/v1/deploy): account-less one-shot deploy. NO tool or account is needed; any agent that can make an HTTP request can deploy. gzip-tar the app source and POST it as multipart form field `source` (optional fields `name` and `language`). The JSON response has `app_url` (the live app), `claim_url` (the human opens this to keep it), `deployment_id`, and `status_url` (poll for readiness). Example: `tar czf app.tar.gz -C ./myapp . && curl -fsS -X POST https://velixir.net/api/v1/deploy -F source=@app.tar.gz -F name=myapp -F language=go`. The app should bind 0.0.0.0 and listen on the port from the PORT environment variable (default 8080). If the app hard-codes a different port instead of reading PORT, add `-F port=3000` so routing matches.
- [Deploy logs](https://velixir.net/api/v1/deploy): to debug a deploy without an account, GET `https://velixir.net/api/v1/deploy/{deployment_id}/logs` for the build error (if the build failed) plus recent runtime output. GET `https://velixir.net/api/v1/deploy/{deployment_id}/access-logs` (optional `status=5xx`, `path=`, `after=` ISO time, `limit=`) lists the HTTP requests the app served, newest first, while it is unclaimed.
- [MCP server](https://www.npmjs.com/package/@velixir/mcp): OPTIONAL convenience for MCP clients. Run `npx -y @velixir/mcp` to give an agent (Claude, Cursor, Cline, and others) `deploy`, `logs` and `access_logs` tools that wrap the HTTP endpoints, so the agent does not build the multipart request itself. See https://velixir.ai for the agent-native flow.

## Pricing

Prepaid and metered hourly, with no monthly contract. The prices below are the monthly-equivalent rate (hourly = monthly / 730); you only pay for the hours a resource actually runs. The Free plan (EUR 0) is genuinely free and always available: a scale-to-zero app that sleeps when idle and wakes on the next request, one per team, no card. Every new account also gets EUR 3.49 of card-free starter credit (about a month of a Hobby app), and adding a card replaces it with EUR 14.99 of first-month credit. Deploying never requires a card; paid plans are the main product, but you can keep a real app running for free.

### App plans (billed per replica)

| Plan | vCPU | RAM | Disk | Max replicas | Slots | Price/mo |
|---|---|---|---|---|---|---|
| Free | 0.25 | 256 MB | 1 GB | 1 | 1 | EUR 0 |
| Hobby | 0.5 | 512 MB | 5 GB | 2 | 1 | EUR 3.49 |
| Starter | 1 | 1 GB | 10 GB | 3 | 1 | EUR 6.95 |
| Standard | 1 | 2 GB | 20 GB | 5 | 2 | EUR 12.95 |
| Pro | 2 | 4 GB | 40 GB | 10 | 3 | EUR 24.95 |
| Business | 4 | 8 GB | 80 GB | 15 | 5 | EUR 47.95 |
| Scale | 6 | 16 GB | 120 GB | 20 | 8 | EUR 89.95 |
| Enterprise | 8 | 32 GB | 160 GB | 25 | 10 | EUR 179.95 |

The Free plan runs one scale-to-zero app per team: it sleeps when idle so it costs nothing, and wakes on the next request with a short cold start. There is no per-GB egress fee. A soft fair-use guideline applies; see the limits page below.

### Managed Postgres (billed per instance)

| Plan | vCPU | RAM | Storage | Point-in-time recovery | HA | Price/mo |
|---|---|---|---|---|---|---|
| Starter | 0.25 | 512 MB | 10 GB | 7 days | no | EUR 4.95 |
| Standard | 1 | 2 GB | 25 GB | 14 days | optional | EUR 17.95 |
| Pro | 2 | 8 GB | 50 GB | 28 days | optional | EUR 64.95 |
| Scale | 4 | 16 GB | 100 GB | 28 days | optional | EUR 169.95 |

Point-in-time recovery is included at every tier. HA (a primary plus a synchronous standby) doubles the bill: each instance charges the full plan rate.

### Managed Valkey, Redis-compatible (billed per instance)

| Plan | vCPU | RAM | Persistence | Price/mo |
|---|---|---|---|---|
| Starter | 0.1 | 256 MB | in-memory only | EUR 2.45 |
| Standard | 0.5 | 1 GB | persistent | EUR 8.95 |
| Pro | 1 | 4 GB | persistent | EUR 26.95 |
| Scale | 2 | 16 GB | persistent | EUR 89.95 |

Full pricing grid: https://velixir.net/pricing. Limits and fair use: https://velixir.net/docs/limits.

## API and tooling
- [OpenAPI spec](https://velixir.net/api/v1/openapi.json): machine-readable REST v1 API, the surface for deploying, adding managed Postgres/Valkey, and reading logs. Authenticate with an API key in the `X-Api-Key` header.
- [API reference](https://velixir.net/docs/api): human-readable REST v1 reference.
- [CLI install](https://velixir.net/install.sh): install with `curl -fsSL https://velixir.net/install.sh | sh`, sign in with `velixir login` (approve in the browser), then `velixir deploy` from your project directory. In CI, set `VELIXIR_API_KEY` and run `velixir deploy --app <app-id>`.
- [Templates](https://velixir.net/templates): deploy one with `velixir deploy --template <slug>`, or `POST /api/v1/templates/{slug}/deploy` with a Write key (`withServices: true` also creates the database or cache it uses). `GET /api/v1/templates` lists them without a key.

## Docs
- [Documentation](https://velixir.net/docs): getting started, deploying (including GitHub Actions), templates, scaling and high availability, security, managed databases and caches, billing.
- [Limits and fair use](https://velixir.net/docs/limits): resource, egress, and network limits, and how to request a raise.
- [Move from Heroku](https://velixir.net/docs/migrate-heroku) and [Move from Render](https://velixir.net/docs/migrate-render): app, config vars, Postgres data (pg_dump / pg_restore) and domain, step by step.
- [Environment variables](https://velixir.net/docs/env-vars): set them one by one or import a whole .env file (dashboard, `velixir env import`, or POST /api/v1/apps/{id}/env/import).

## Deploy by language
- [Languages](https://velixir.net/languages): per-language deploy guides for every first-class stack.

## Compare
- [Comparisons](https://velixir.net/vs): how velixir compares to other platforms, backend and EU focused.

## Product
- [Home](https://velixir.net/): positioning.
- [Pricing](https://velixir.net/pricing): the full pricing grid.
- [Changelog](https://velixir.net/changelog): what is shipping.
- [Blog](https://velixir.net/blog): notes from the founder.