# Nodion documentation

> All Nodion docs pages as Markdown, in sidebar order. Source: https://www.nodion.com/docs. Summary: https://www.nodion.com/llms.txt

---

Source: https://www.nodion.com/docs

# Documentation

## Deploy apps, data, and AI without managing servers.

Nodion is a managed cloud for applications, databases, object storage, volumes, DNS, CDN, transactional email, monitoring, and AI inference. You work in the [dashboard](https://app.nodion.com), with the [CLI](https://www.nodion.com/docs/cli), over the [HTTP API](https://www.nodion.com/docs/api), or from your coding agent via [MCP](https://www.nodion.com/docs/mcp).

New accounts can earn up to 15 € in credit when signing up. [Sign up](https://app.nodion.com/login) or [log in](https://app.nodion.com/login).

### How it is organized

-   **Account**: billing (EUR or USD), team access, and personal API keys under [Account → Security](https://app.nodion.com/account/security).
-   **Project**: the container for everything you run. Create one from the dashboard, then stay inside it.
-   **Region**: where those resources live. Pick a region when you create a service; it does not move later.
-   **Attachments**: databases, volumes, and buckets connect to apps so they can reach each other privately. You do not expose those services on the public internet to use them from an app.

### What you can run

The dashboard sidebar is the product list. Each item belongs to the current project:

-   [**Applications**](https://www.nodion.com/docs/applications): deploy from Git, a [Dockerfile](https://www.nodion.com/docs/dockerfile), [buildpacks](https://www.nodion.com/docs/buildpacks), or a pre-built image. Scale processes, attach domains, read logs and metrics, and open preview environments for a branch.
-   [**Databases**](https://www.nodion.com/docs/databases): managed Postgres, pgvector, MySQL, Valkey, and ClickHouse.
-   [**Volumes**](https://www.nodion.com/docs/volumes): persistent disks for apps that need a filesystem.
-   [**Buckets**](https://www.nodion.com/docs/buckets): S3-compatible object storage and access keys.
-   [**CDN**](https://www.nodion.com/docs/cdn): cache and serve content close to users.
-   [**DNS**](https://www.nodion.com/docs/dns): authoritative zones and records.
-   [**Email**](https://www.nodion.com/docs/email): sending domains for transactional mail.
-   [**Monitoring**](https://www.nodion.com/docs/monitoring): uptime and metric checks with notifications.
-   [**AI Inference**](https://www.nodion.com/docs/ai): hosted models from your project.

Under the account you will also find **Integrations** (GitHub and similar), **Registries** (push your own images), and **Support**.

### Get started

[#### Dashboard

Create an account, claim your sign-up credit, create a project, and deploy an app from Git.](https://app.nodion.com/login)

[#### CLI

Install nodion, sign in, and deploy or inspect apps from the terminal or CI.](https://www.nodion.com/docs/cli)

[#### AI agent

Connect Cursor or Claude to Nodion. Your agent can sign up, create the project, and deploy.](https://www.nodion.com/connect)

### Automate

[#### API

HTTP API for CI and your own tools. Interactive docs and OpenAPI included.](https://www.nodion.com/docs/api)

[#### MCP

Hosted MCP server so coding agents can manage the same resources.](https://www.nodion.com/docs/mcp)

---

Source: https://www.nodion.com/docs/how-it-works

# How it works

## One account, then a project, then resources in a region.

You sign in at [app.nodion.com](https://app.nodion.com/login). Billing and personal API keys live on the account. Everything you run lives in a [project](https://www.nodion.com/docs/projects).

### Account

The account is you (or your company). It holds billing currency, invoices, payment methods, and personal API keys under [Account → Security](https://app.nodion.com/account/security). Integrations and registries are also account-level, then shared into projects.

### Project

A project is the workspace. Pick one in the dashboard and stay there. Applications, databases, volumes, buckets, CDN, DNS, email, monitors, and AI keys all belong to that project. Invite people on the project **Members** tab.

### Region

When you create a service you pick a [region](https://www.nodion.com/docs/regions). That choice stays. Put an app and the data it talks to in the same region.

### Attachments

Databases and buckets attach on the app **Environment** tab. Connection variables are injected on the next deploy. You do not open those services to the public internet just to use them from the app.

Volumes mount on a **process**, at a path you choose. Optional read-only.

### How you work

-   Dashboard at [app.nodion.com](https://app.nodion.com)
-   CLI, documented under [CLI](https://www.nodion.com/docs/cli)
-   HTTP API, documented under [API](https://www.nodion.com/docs/api)
-   Coding agents via [MCP](https://www.nodion.com/docs/mcp)

---

Source: https://www.nodion.com/docs/projects

# Projects

## The workspace for every app, database, and other resource.

Open [Projects](https://app.nodion.com/projects) and create one. The dashboard then keeps you inside that project until you switch. Almost every create form needs a project selected.

### Tabs

-   **General**: name and project settings.
-   **Members**: invite people. Roles are owner, admin, and member. Owners cannot be demoted here.
-   **Git sources**: repositories this project can deploy from, including ones shared in.
-   **Limits**: how much the project is allowed to run. Ask for a higher limit when you hit one.
-   **API keys**: project tokens (`nodion_proj_…`) for CI. They belong to the project, not a person.

### Invites

Pending invites show on the projects list. Join or decline there. The invite email links back to [app.nodion.com](https://app.nodion.com).

### API access

Personal keys under [Account → Security](https://app.nodion.com/account/security) can be limited to specific projects. Project keys on the API keys tab can do anything in that project. Send `X-Nodion-Project` when you use the short API paths. See [API](https://www.nodion.com/docs/api).

---

Source: https://www.nodion.com/docs/regions

# Regions

## Pick a region when you create a service. It does not move later.

Regions are isolated from each other. Apps, databases, volumes, buckets, the [registry](https://www.nodion.com/docs/registries), logs, and metrics for a service stay in the region you picked. Images are not shipped across the globe, and data stays in that country.

The create forms show the regions that can take that service right now. A region can be grayed out if it is sold out or has no capacity for the plan you picked.

From a data privacy standpoint the providers below are sub processors of Nodion GmbH. Our APIs and control plane are hosted in Germany on infrastructure provided by Leaseweb Deutschland GmbH. For regions outside Germany, use the list below for the local provider, datacenter address, and certifications.

### Locations

Location

Country

Handle

Available services

EU Central

Germany

euc

Applications, Databases, Object Storage

**Datacenter Location** Heinrich-Lanz-Allee 47, 60437 Frankfurt am Main, Germany

**Datacenter Certifications** ISO 27001, ISO 9001, ISO 14001, ISO 50001, PCI DSS, SOC 2

**Infrastructure Provider** Leaseweb Deutschland GmbH

**Provider Certifications** ISO 27001, SOC 1, PCI DSS

US East

United States

use

Applications, Databases, Object Storage

**Datacenter Location** 11680 Hayden Rd Road Manassas, VA 20109, United States

**Datacenter Certifications** ISO 27001, ISO 50001, PCI-DSS, HIPAA, SOC 2 Type II, SOC 3

**Infrastructure Provider** Leaseweb USA, Inc.

**Provider Certifications** ISO 27001, SOC 1, PCI DSS, HIPAA

US West

United States

usw

Applications, Databases, Object Storage

**Datacenter Location** 1735 Lundy Ave San Jose, CA 95131, United States

**Datacenter Certifications** ISO 27001, SOC 1, SOC 2

**Infrastructure Provider** Leaseweb USA, Inc.

**Provider Certifications** ISO 27001, SOC 1, PCI DSS, HIPAA

APAC Central

Singapore

apc

Applications, Databases, Object Storage

**Datacenter Location** 1 Serangoon North Ave 6, Singapore 554502

**Datacenter Certifications** ISO 27001, ISO 50001, SOC 2, SOC 3, PCI DSS, HIPAA

**Infrastructure Provider** Leaseweb Singapore PTE. LTD

**Provider Certifications** ISO 27001, SOC 1, PCI DSS

The dashboard is the source of truth for which services a region can take right now. Put an application and the databases, volumes, and buckets it uses in the same region.

---

Source: https://www.nodion.com/docs/billing

# Billing and credit

## Usage-based billing, plus credit when signing up.

There is no monthly free tier. New accounts can earn **up to 15 € in credit** when signing up: 5 € each for subscribing to product updates, following Nodion on X and joining the Discord community. Claimed credit is granted once a payment method is on file. Claim it during [get started](https://app.nodion.com/get-started) or later under [Account → Rewards](https://app.nodion.com/account/rewards).

### Currency

Invoices are in **EUR** or **USD**. Some billing countries fix the currency. Otherwise you pick one under [Billing](https://app.nodion.com/billing). You can change it until the first invoice, then it stays.

### Account details and tax

Set Individual or Company, address, and country. Company accounts in VAT countries can add a VAT ID. Fill the address (and a name, or a company name) before you add a payment method.

### Payment

Add a card, SEPA direct debit, or PayPal. The default method is charged monthly for the previous month. Usage is metered (apps and databases down to the second).

### What things cost

Live plan prices are on [Pricing](https://www.nodion.com/pricing), in EUR and USD. High-level rates:

-   Apps: Discovery shared CPU, or General Purpose dedicated vCPU.
-   Databases: Discovery, General Purpose, or High Performance, with NVMe. A `-L` plan is the same compute with double the disk.
-   Object storage: Basic, Standard, or Premium, billed per GB-month.
-   Volumes: network €0.15 / GB / month; local €0.25 / GB / month.
-   Outbound transfer: €0.005 / GB.
-   Transactional email: €0.00025 per delivered message.

AI inference uses a prepaid wallet under [AI Inference → Billing](https://app.nodion.com/ai/billing), not the monthly platform invoice. Support plans are listed on Pricing.

---

Source: https://www.nodion.com/docs/applications

# Applications

## Run a service from Git, an image, or a one-click preset.

Create one from [Applications → New](https://app.nodion.com/applications/new) after you have a [project](https://www.nodion.com/docs/projects). Pick a [region](https://www.nodion.com/docs/regions) and a source.

### Source

-   **Git repository**: connect a provider under [Git integrations](https://www.nodion.com/docs/git), pick the repo and branch. Nodion scans the tree. Build with a [Dockerfile](https://www.nodion.com/docs/dockerfile) or [Buildpacks](https://www.nodion.com/docs/buildpacks). If the repo has a compose file you can import the stack. That path is experimental; see [Docker Compose](https://www.nodion.com/docs/compose).
-   **Prebuilt image**: deploy an existing image, including one you pushed to a [Nodion registry](https://www.nodion.com/docs/registries).
-   **Preset**: a [one-click app](https://www.nodion.com/docs/presets) with its own defaults. The dashboard, a Deploy to Nodion button, or an MCP agent (`presets.list` → `presets.get` → `apps.create` with `preset_key`) can start one.

Git apps can turn on **Auto-deploy** so a push to the branch starts a release.

### After it exists

The app page has these tabs:

-   **Overview**: status, attachments, first deploy.
-   **Deployments**: history. The header **Deploy** button starts one.
-   **Processes**: each process is its own containers. Set replicas, package (Discovery or General Purpose), command, ports, and volume mounts.
-   **Shell**: a terminal on a running process.
-   **Logs** and **Metrics**.
-   **Environment**: your variables (secrets are write-only after save), plus attach databases and buckets. The database must be in the same region. Injected values apply on the next deploy.
-   **Domains**: the default hostname and custom names.
-   **Previews**: Git apps only, not prebuilt images.
-   **Settings**: including preview enablement.

### Preview environments

Enable previews in settings. Each preview is an ephemeral app for a pull request or branch: its own URL, and a fresh database for each database attached to the parent app. Create one by hand, or auto-create on pull requests. Redeploy or close them from the Previews tab.

A preview starts with a copy of the parent app's environment variables, secrets included. Only the variables of attached databases point to the preview's own database. Nodion also sets `NODION_PREVIEW=1`, `NODION_PR_NUMBER`, `NODION_BRANCH` and `NODION_PARENT_APP`. Check `NODION_PREVIEW` in your code to switch payments, email and other side effects to test mode, because previews run unreviewed code with the parent's keys.

A preview expires after the inactivity TTL set in the parent's settings (7 days by default, 0 for no automatic expiry). Every redeploy starts the period again.

### Plans

Discovery shares CPU. General Purpose is dedicated vCPU. Live prices are on [Pricing](https://www.nodion.com/pricing).

---

Source: https://www.nodion.com/docs/databases

# Databases

## Managed Postgres, pgvector, MySQL, Valkey, and ClickHouse.

Create one from [Databases → New](https://app.nodion.com/databases/new). Pick the engine, a version, a name, a region, and a plan. The form grays out regions that cannot take that plan right now.

Redis is not offered. Use Valkey when you need a Redis-compatible store. The default env key for Valkey is still `REDIS_URL`, so existing apps keep working.

### Plans

Every plan includes local NVMe. Discovery shares CPU. General Purpose and High Performance use dedicated vCPU. A `-L` suffix is the same compute with double the disk. See [Pricing](https://www.nodion.com/pricing) for live numbers.

### Attach to an app

On the application **Environment** tab, attach the database and choose which connection fields become env vars. Those values are injected on the next deploy. Detach or edit the key names there. Manage the database itself from the Databases list.

The app and the database must be in the same [region](https://www.nodion.com/docs/regions). The API rejects a cross-region attach.

### Cluster, backups, access

Postgres, pgvector, and MySQL can add read replicas and an HA standby. Valkey can do HA. ClickHouse can run as a three-node cluster on an empty database. Those tabs appear only when the engine supports them.

Backups are opt-in on engines that support them (not Valkey, and not a ClickHouse cluster). Restore creates a new database. It does not overwrite the original.

Overview shows private access on the internal hostname, and optional public TLS. Detach every app before you delete a database.

### Previews

A [preview environment](https://www.nodion.com/docs/applications) gets a fresh database. It is not a clone of production data.

---

Source: https://www.nodion.com/docs/volumes

# Volumes

## A disk that survives process restarts.

Create one from [Volumes → New](https://app.nodion.com/volumes/new). Choose a name, a kind, a region, and a size in GB. The form shows the allowed range and how much free disk that region has.

### Network or local

**Network** volumes live on a volume host and are mounted over NFS. Several processes can share one. The application can move to another app host and keep the data.

**Local** volumes are a real disk on the same machine as the app. One process can mount up to four local volumes, and each local volume belongs to one process. That process cannot have more than one replica. Deploys stop the current instance before starting the new one. If that app host is lost, the data is gone.

### Mount it

Open the application **Processes** tab, edit a process, and add a volume mount: the volume, a container path, and optional read-only. The process and the volume must be in the same project. Put them in the same [region](https://www.nodion.com/docs/regions). A process can mix local and network volumes. A local volume path cannot be the same as another mount path of the process, or sit inside or around one.

### Grow, do not shrink

On the volume page you can grow the size. It cannot get smaller. The new size is billed from the moment you grow it. Usage shows after the next check.

### Price

Network €0.15 / GB / month; local €0.25 / GB / month. See [Pricing](https://www.nodion.com/pricing).

---

Source: https://www.nodion.com/docs/buckets

# Buckets

## S3-compatible object storage in your project.

Create one from [Buckets → New](https://app.nodion.com/buckets/new). Pick a name, a region, and a storage class: **Basic**, **Standard**, or **Premium**.

### Keys

**Storage keys** are for you and your tools. Mint one scoped to the bucket, or grant an existing regional key access. Permissions are readonly, readwrite, or full. The secret is shown once. Manage them under Storage keys.

An attached app gets a separate **service key**. It is not listed under Storage keys. Rotate it on the bucket Settings page. The app picks up the new values on the next deploy.

### Objects

The bucket page has **Objects** and **Settings**. Use any S3 client with the endpoint and keys the dashboard shows.

### Attach to an app

On the application **Environment** tab, attach a ready bucket. S3 connection variables are injected on the next deploy. Edit the key names or detach there.

### Price

Billed per GB-month by class (Basic €0.015, Standard €0.03, Premium €0.06). Outbound transfer is €0.005 / GB. See [Pricing](https://www.nodion.com/pricing).

---

Source: https://www.nodion.com/docs/cdn

# CDN

## Cache responses close to users.

Create a zone from [CDN → New](https://app.nodion.com/cdn/new). The sidebar label is **CDN Zones**.

### Origin

-   **Custom origin**: hostname you already serve, for example `assets.example.com`.
-   **Application**: pick an app and one of its domains.

The origin cannot change after the zone exists.

### Domains

Add a custom hostname on the zone. Verify with the TXT and CNAME records the dashboard shows. TLS is issued after verify.

### Caching

Set a default cache time for responses that send no caching headers. Leave **Respect origin cache headers** on to honor `Cache-Control` and `Expires`. Turn it off to force the default on everything.

Optional CORS lets browsers fetch across origins.

### Price

Outbound transfer is €0.005 / GB. See [Pricing](https://www.nodion.com/pricing).

---

Source: https://www.nodion.com/docs/dns

# DNS

## Authoritative zones for your domains.

Create a zone from [DNS Zones → New](https://app.nodion.com/dns-zones/new). Enter the domain. Point the domain’s nameservers at the servers Nodion shows after the zone exists.

### Records

The zone page has **Records**, **Metrics**, and **Settings**. Add the records your apps, mail, and CDN need.

### Take over

If the domain is already claimed, the form offers **Take over via DNS**. Add the TXT record it shows at your current DNS provider, then verify. Propagation can take a few minutes.

---

Source: https://www.nodion.com/docs/email

# Email

## Send transactional mail from your project.

The product in the sidebar is **Email Zones**. Create one from [Email Zones → New](https://app.nodion.com/email-zones/new). Give it a name and a region.

### SMTP

The zone page shows SMTP credentials for the relay. Use them from your app or any mail client that can speak SMTP. The password is a secret; copy it when you need it.

### Sending domains

Add a sending domain, prove it with the TXT record the dashboard shows, then add the DKIM (and SPF / DMARC) records so mail is signed and aligned. DKIM is required to activate. An activated domain is required for the From address. The zone lists recent messages and whether they were delivered.

Attach the zone to an app to inject the SMTP settings as environment variables on the next deploy.

### Price

€0.00025 per delivered message. Bounces and rejects are not billed as delivered. See [Pricing](https://www.nodion.com/pricing).

---

Source: https://www.nodion.com/docs/monitoring

# Monitoring

## Uptime checks on a URL or one of your apps.

The sidebar item is **Monitoring**. In the product they are called observers. Create one from [Monitoring → New](https://app.nodion.com/observers/new).

### What to watch

-   **Custom URL**: any http(s) endpoint.
-   **Application**: pick an app and a domain (default or custom).

Give it a name and how often to check. The observer page has overview, checks, anomalies, and notifiers.

### When something fails

Configure notifiers on the observer. Down events can also email the account. Open the observer from [Monitoring](https://app.nodion.com/observers) to see recent checks.

---

Source: https://www.nodion.com/docs/ai

# AI Inference

## Hosted models, billed on usage, called like OpenAI.

Open [AI Inference](https://app.nodion.com/ai) in the current project. This is a separate API from the [platform HTTP API](https://www.nodion.com/docs/api). Platform keys (`nodion_…`) manage resources. Inference keys (`nodion_ai_…`) call models.

### Tabs

-   **Keys**: create a key. It is shown once. Optional expiry and a daily spend limit. Only a project admin can create or revoke keys.
-   **Playground**: try chat (and other modes when models exist). Playground traffic is metered like any other request.
-   **Models**: catalog and readiness.
-   **Usage** and **Requests**.
-   **Billing**: a prepaid wallet, separate from the monthly platform invoice. Top up with card or PayPal.
-   **Settings**: allow or exclude providers, optional region allowlist, and policy toggles such as zero data retention.

### Call the API

bashcurl https://api.nodion.ai/v1/chat/completions \\
  -H "Authorization: Bearer $NODION\_AI\_KEY" \\
  -H "Content-Type: application/json" \\
  -d '{"model": "<model>", "messages": \[{"role": "user", "content": "Hello"}\]}'

Every endpoint, including embeddings, rerank, System One and OCR, with limits and error codes, is in the [AI API reference](https://www.nodion.com/docs/ai/api).

List token-priced models with `GET https://api.nodion.ai/v1/models` or browse the Models tab (including OCR, speech-to-text, and text-to-speech). Prices are there too, not on the platform price book. AI spend comes from the wallet, not from the platform invoice. Speech and OCR models are not listed on `/v1/models` — use the dashboard catalog or the public `/v2/public/ai/models` list. Models marked Preview can leave the catalog at short notice. There is no deprecation date; they stay callable until they disappear.

### Speech to text

`POST /v1/audio/transcriptions` is OpenAI-shaped multipart. The whole request body must stay under 25 MiB (file plus form fields). Files themselves are capped at 20 MiB. Duration is billed per second.

bashcurl https://api.nodion.ai/v1/audio/transcriptions \\
  -H "Authorization: Bearer $NODION\_AI\_KEY" \\
  -F model="mistral/voxtral-mini-transcribe" \\
  -F file="@speech.wav"

### Text to speech

`POST /v1/audio/speech` returns audio bytes. Input is billed per UTF-8 character (Unicode code point).

bashcurl https://api.nodion.ai/v1/audio/speech \\
  -H "Authorization: Bearer $NODION\_AI\_KEY" \\
  -H "Content-Type: application/json" \\
  -d '{"model": "mistral/voxtral-mini-tts", "input": "Hello from Nodion", "voice": "en-US"}' \\
  --output speech.mp3

### Voice cloning

Models with `supports_voice_cloning` accept a project-cloned voice id in `voice` on `POST /v1/audio/speech`. Create a sample with `POST /v1/audio/voices` (multipart `name`, `consent=true`, and a 3–30 second `file`). Ten voices per project. Ten create attempts per hour. Samples are stored encrypted until the voice or project is deleted; a short reference is sent to Mistral for each synthesis. You must confirm the sample is your own voice or that the speaker consented to cloning.

bashcurl https://api.nodion.ai/v1/audio/voices \\
  -H "Authorization: Bearer $NODION\_AI\_KEY" \\
  -F name="Studio" \\
  -F consent="true" \\
  -F file="@clip.wav"

curl https://api.nodion.ai/v1/audio/speech \\
  -H "Authorization: Bearer $NODION\_AI\_KEY" \\
  -H "Content-Type: application/json" \\
  -d '{"model": "mistral/voxtral-mini-tts", "input": "Hello from Nodion", "voice": "<voice-id>"}' \\
  --output cloned.mp3

### Realtime transcription

Realtime models use `wss://api.nodion.ai/v1/audio/transcriptions/realtime?model=…` with the same bearer key. The wire format is Mistral’s JSON frames (`session.update`, `input_audio.append` with base64 PCM), not OpenAI’s agent realtime API.

### Image generation

Image models use the OpenAI Images API: `POST https://api.nodion.ai/v1/images/generations`. The response is `b64_json` only — `url` and remote image fetches are rejected. `n` is reserved and settled per returned image. Image models are listed on the Models tab, not on `GET /v1/models`.

bashcurl https://api.nodion.ai/v1/images/generations \\
  -H "Authorization: Bearer $NODION\_AI\_KEY" \\
  -H "Content-Type: application/json" \\
  -d '{"model": "<image-model>", "prompt": "a red cube", "n": 1, "size": "1024x1024"}'

### Tools

Web search, news and fetch are billed per call from the same wallet. They are listed on the [AI Inference catalog](https://www.nodion.com/ai-inference#tools) and called with an inference key:

bashcurl https://api.nodion.ai/v1/tools/web\_news \\
  -H "Authorization: Bearer $NODION\_AI\_KEY" \\
  -H "Content-Type: application/json" \\
  -d '{"query": "EU cloud regulation", "limit": 5}'

`POST /v1/tools/web_search` takes the same `query` body, with optional fetch hydration of hits. `POST /v1/tools/web_fetch` takes a `url` and returns markdown by default. Optional `location`, `language` and `freshness` (`day`, `week`, `month`, `year`) filter search and news.

Page loads (`web_fetch` and the fetch hydration of `web_search`) run as [NodionBot](https://www.nodion.com/bot) and honor robots.txt, `Content-Signal: ai-input=no` and `tdm-reservation`. On `web_fetch`, only the `Accept` and `Accept-Language` request headers are forwarded; other headers are dropped and named in `warnings`, and URLs with credentials are rejected.

A refused `web_fetch` returns 403 with `blocked_by_robots`, `blocked_by_content_signal`, `blocked_by_tdm_reservation` or `blocked_domain`, or 503 with `robots_unavailable` (the site's robots.txt could not be read) or `fetch_unavailable`; refused calls are not billed, and a 503 can be retried later. During `web_search` hydration, a refused hit keeps the search at 200: it is listed in `warnings` with its code and not billed, while the search itself is.

### Agents that manage the cloud

To let Cursor or Claude create apps and databases, use [MCP](https://www.nodion.com/docs/mcp) with a personal platform key, not an inference key.

---

Source: https://www.nodion.com/docs/ai/api

# AI API reference

## Every endpoint on api.nodion.ai/v1, with limits and errors.

Base URL: `https://api.nodion.ai/v1`. The API follows the OpenAI shape, so OpenAI SDKs work when you point them at this base URL. For keys, the wallet, and the dashboard tabs, see [AI Inference](https://www.nodion.com/docs/ai).

pythonimport os
from openai import OpenAI

client = OpenAI(
    base\_url="https://api.nodion.ai/v1",
    api\_key=os.environ\["NODION\_AI\_KEY"\],
)
reply = client.chat.completions.create(
    model="<model>",
    messages=\[{"role": "user", "content": "Hello"}\],
)
print(reply.choices\[0\].message.content)

### Authentication

Send an inference key (`nodion_ai_…`) as a bearer token on every request. Platform keys (`nodion_…`) do not work here. `GET /v1/models` is the only call that needs no key.

httpAuthorization: Bearer nodion\_ai\_…

A rejected key answers 401 with one of these messages:

-   `missing bearer token`
-   `invalid api key`
-   `api key expired`
-   `account disabled`
-   `account under review`

Every response carries an `X-Request-ID` header. Quote it when you contact support.

JSON request bodies can be up to 1 MiB (System One 512 KiB). Base64 adds a third, so a file sent inline in JSON, such as an image, a PDF, or an OCR document, can be about 750 KB. Multipart uploads to `/v1/audio/transcriptions` and `/v1/audio/voices` can be up to 25 MiB, with transcription files up to 20 MiB and voice sample files up to 10 MiB (11 MiB for the whole form).

### Endpoints

Endpoint

What it does

Billed by

`GET /v1/models`

List token-priced models

Free

`POST /v1/chat/completions`

Chat, tools, structured output

Input and output tokens

`POST /v1/embeddings`

Vector embeddings

Input tokens

`POST /v1/rerank`

Rank documents against a query

Input tokens

`POST /v1/systemone`

System One: typed decisions with probabilities

Input tokens

`POST /v1/ocr`

Document and image OCR

Pages

`POST /v1/audio/transcriptions`

Speech to text

Audio seconds

`GET /v1/audio/transcriptions/realtime` (WebSocket)

Realtime speech to text

Audio seconds

`POST /v1/audio/speech`

Text to speech

Characters

`GET, POST /v1/audio/voices`

List and create cloned voices

Free

`GET, DELETE /v1/audio/voices/{id}`

Read or delete one cloned voice

Free

`POST /v1/images/generations`

Image generation

Images

`POST /v1/tools/web_search`, `web_news`, `web_fetch`

Web tools

Calls, plus each page a `web_search` fetches

Audio, images, and tools are described with examples on [AI Inference](https://www.nodion.com/docs/ai). The rest is below.

Before a call the wallet holds an upper bound of its cost. The request then settles on the reported usage, never above the hold, and the rest is released. If a successful answer reports no usage, the full hold is charged. A realtime transcription session holds the model's `max_audio_seconds` (1,800 seconds if the model sets none), so the wallet has to cover a full session up front.

### Models

`GET /v1/models` returns `{"object": "list", "data": [...]}` and lists chat, embeddings, and rerank models. OCR, speech, image, and tool models are not in it; the public catalog at `https://api.nodion.com/v2/public/ai/models` lists every kind. Useful fields per model:

-   `id`: the value for `model` in requests.
-   `kind`: `chat`, `embeddings`, or `rerank`.
-   `context_length` and `max_output_length` in tokens.
-   `pricing`: USD per token as decimal strings. `pricing_eur` has the EUR prices.
-   `supported_sampling_parameters` and `supported_features` (for example `tools`, `json_mode`, `structured_outputs`, `reasoning`).
-   `is_ready`: `false` means no route is healthy right now. The model stays listed.
-   `lifecycle`: `ga` or `preview`. `serving`: `hosted` (the weights run on Nodion) or `routed` (forwarded to a provider).
-   `supports_decisions`: the model answers [System One](#system-one).
-   `free_until`: set while a free window is active on a model served only by Nodion. The token prices then read 0.

### Chat completions

`POST /v1/chat/completions` takes the OpenAI Chat Completions body: `model`, `messages`, and the optional fields the model lists in `supported_sampling_parameters` and `supported_features`, such as `tools` or `response_format`.

bashcurl https://api.nodion.ai/v1/chat/completions \\
  -H "Authorization: Bearer $NODION\_AI\_KEY" \\
  -H "Content-Type: application/json" \\
  -d '{
    "model": "<model>",
    "stream": true,
    "max\_tokens": 512,
    "messages": \[
      {"role": "system", "content": "Answer in one sentence."},
      {"role": "user", "content": "What is an embedding?"}
    \]
  }'

What the gateway does to the request and the answer:

-   Without `max_tokens` (or `max_completion_tokens`) the gateway sets `max_tokens` to the model's `max_output_length`. Larger values are lowered to it.
-   With `"stream": true` the answer is server-sent events (`data: {...}` lines, then `data: [DONE]`). The gateway sets `stream_options.include_usage`, so the last chunk normally carries usage. If the upstream connection breaks mid-stream, a last chunk carries an `error` object and `finish_reason: "error"`, followed by `data: [DONE]`.
-   The `model` field in the answer is the id you sent. Reasoning text, when a model returns it, is in `reasoning_content`.

PDFs can go inline as a `file` content block with a base64 data URI. The gateway renders the first 20 pages to images before the call, so this only helps on models with image input. `file_id` references are rejected.

json{
  "role": "user",
  "content": \[
    {"type": "text", "text": "Summarize this contract."},
    {"type": "file", "file": {"file\_data": "data:application/pdf;base64,JVBERi0..."}}
  \]
}

Billing: input and output tokens at the model's price, cached input at the cache price where the route reports it. The hold counts every request byte as an input token, plus `max_tokens`. For requests with images or PDFs the input part is raised to the model's context length, or to at least 128,000 tokens when the request is larger than the context. Inside a model's free window (`free_until`), chat completions on hosted routes are free.

### Embeddings

`POST /v1/embeddings` takes the OpenAI body (`model`, `input` as a string or an array) and returns the OpenAI embeddings response. No streaming. Billed on `usage.prompt_tokens`. Use a model with `kind: "embeddings"`.

bashcurl https://api.nodion.ai/v1/embeddings \\
  -H "Authorization: Bearer $NODION\_AI\_KEY" \\
  -H "Content-Type: application/json" \\
  -d '{"model": "<embeddings-model>", "input": \["first text", "second text"\]}'

### Rerank

`POST /v1/rerank` scores `documents` against a `query`. Optional `top_n` limits the results. The answer has `results` with `index` (position in `documents`) and `relevance_score`, plus `usage.prompt_tokens`, which is what you are billed on. Use a model with `kind: "rerank"`.

bashcurl https://api.nodion.ai/v1/rerank \\
  -H "Authorization: Bearer $NODION\_AI\_KEY" \\
  -H "Content-Type: application/json" \\
  -d '{
    "model": "<rerank-model>",
    "query": "How do I reset my password?",
    "documents": \["Billing FAQ", "Account recovery guide", "Release notes"\],
    "top\_n": 2
  }'

### System One

`POST /v1/systemone` answers typed questions about a piece of state. The model scores every possible answer instead of writing text, so you get probabilities back, not prose. Use it for routing, triage, moderation, or as a gate before an agent runs a tool. One call answers up to 16 questions about the same state.

Models with `supports_decisions: true` on `/v1/models` serve it. System One only runs on Nodion-hosted routes, never on routed providers. The **Decisions** tab in the Playground has ready-made examples.

bashcurl https://api.nodion.ai/v1/systemone \\
  -H "Authorization: Bearer $NODION\_AI\_KEY" \\
  -H "Content-Type: application/json" \\
  -d '{
    "model": "aleph-alpha/kolibri-1",
    "state": {
      "customer\_tier": "enterprise",
      "ticket": "My checkout page shows a blank screen after I click Pay."
    },
    "questions": {
      "is\_bug": {
        "type": "noul",
        "instructions": "Is the customer reporting a software defect?"
      },
      "team": {
        "type": "choice",
        "instructions": "Which team should own this ticket?",
        "criteria": {
          "payments": "Checkout, billing, or payment processing issues.",
          "frontend": "Rendering, layout, or browser issues.",
          "account": "Login, permissions, or profile issues."
        }
      },
      "urgency": {
        "type": "score",
        "instructions": "How urgent is this ticket?",
        "criteria": \[
          "Can wait for the next release",
          "Should be fixed this week",
          "Blocking revenue right now"
        \]
      }
    }
  }'

#### Request

-   `model` (required): a model with `supports_decisions`.
-   `state` (required): what the questions are about. A string, an object, an array, or `null`.
-   `questions` (required): an object with 1 to 16 entries. The key is your name for the question (up to 128 characters) and comes back as the key in `answers`.

Each question has a `type`, optional `instructions`, and `criteria` that depend on the type. Instructions and criteria values can be a string, an object, or an array; `null` is allowed everywhere except for score levels.

-   `noul`: a yes/no question. `criteria` is optional and may only have the keys `true` and `false`. A `noul` needs non-empty `instructions` or at least one non-empty criterion.
-   `choice`: pick one label. `criteria` maps 1 to 26 labels to a value; blank strings are rejected. Labels must be unique, ignoring case, and up to 256 characters.
-   `score`: rate on a scale. `criteria` is an array of 2 to 10 non-empty levels, lowest first. Level indexes start at 0.

Unknown fields are rejected. The body can be up to 512 KiB, and the state plus the largest question must fit the model's context.

#### Response

json{
  "model": "aleph-alpha/kolibri-1",
  "answers": {
    "is\_bug": {"type": "noul", "noul": 0.91},
    "team": {
      "type": "choice",
      "choice": "payments",
      "confidence": 0.78,
      "probabilities": {"payments": 0.82, "frontend": 0.15, "account": 0.03}
    },
    "urgency": {
      "type": "score",
      "score": 1.5,
      "confidence": 0.6,
      "legend": {
        "0": "Can wait for the next release",
        "1": "Should be fixed this week",
        "2": "Blocking revenue right now"
      },
      "probabilities": {"0": 0.1, "1": 0.3, "2": 0.6}
    }
  },
  "usage": {"input\_tokens": 412, "output\_tokens": 0}
}

-   `noul`: the probability that the answer is `true`, from 0 to 1.
-   `choice`: `choice` is the most likely label, `probabilities` has every label and sums to 1, and `confidence` is a value from 0 to 1.
-   `score`: `score` is the probability-weighted mean of the level indexes (0 up to the number of levels minus 1). `probabilities` and `legend` are keyed by level index; `legend` maps each index to a level description. `confidence` is a value from 0 to 1.
-   `model` is the model that answered. `usage.output_tokens` is always 0.

The values in the example response are illustrative.

#### Billing

Only input tokens are billed, at the model's input price. The model reads the state once per question, so `usage.input_tokens` grows with the number of questions. Before the call the wallet holds (bytes of the state + bytes of all questions + 4,096) × the number of questions as input tokens, and the request settles on `usage.input_tokens`, never above the hold. Requests that fail are not billed; if you disconnect after the model has answered, its input tokens are billed. Free windows apply as for chat.

#### Errors

System One uses its own error body: `{"detail": "message"}`, and for 422 a list of `loc` / `msg` / `type` items that point at the field.

json{
  "detail": \[
    {"loc": \["body", "questions", "team", "criteria"\], "msg": "choice accepts 1 to 26 criteria", "type": "too\_long"}
  \]
}

-   **401**: missing or invalid key.
-   **402**: billing refused the request: balance, spend limits, or the request could not be priced. The reasons are those of the [402 codes](#402-codes), here only as `detail` text.
-   **404**: `model not found`, also for models without `supports_decisions`.
-   **422**: invalid body, body over 512 KiB, state and questions over the context, or the model rejected the request.
-   **429**: a key limit was hit. `Retry-After: 5`.
-   **502**: the model failed to answer.
-   **503**: no healthy route, none that matches the project's privacy settings, or the settings could not be loaded.
-   **529**: every route for the model is at capacity. `Retry-After: 5`.

### OCR

`POST /v1/ocr` follows the Mistral OCR shape. Send the file inline as a base64 data URI; remote URLs are rejected. PDF, PNG, JPEG, and WebP work.

bashcurl https://api.nodion.ai/v1/ocr \\
  -H "Authorization: Bearer $NODION\_AI\_KEY" \\
  -H "Content-Type: application/json" \\
  -d '{
    "model": "mistral/mistral-ocr-4-1",
    "document": {
      "type": "document\_url",
      "document\_url": "data:application/pdf;base64,JVBERi0..."
    }
  }'

-   `model`: an OCR model from the public catalog (`kind: "ocr"`).
-   `document`: `{"type": "document_url", "document_url": "data:..."}` or `{"type": "image_url", "image_url": "data:..."}`.
-   `pages` (optional): page indexes to read, starting at 0. Not every OCR model supports it; hosted OCR models and `firecrawl/pdf-inspector` answer 400.
-   `include_image_base64` (optional): return embedded images as base64. Not every OCR model returns images; some always answer with an empty `images` list.

The answer has `pages` (each with `index`, `markdown`, and `images`) and `usage_info.pages_processed`. Billed per processed page. The hold covers the whole document, and documents over the model's `max_pages` are rejected. `firecrawl/pdf-inspector` reads digitally generated PDFs only. An image answers 422; a PDF with scanned pages answers 422 with `code: "pages_need_ocr"` and the affected pages in `pages_needing_ocr`.

### Errors and limits

Every endpoint except System One answers errors in the OpenAI envelope:

json{
  "error": {
    "message": "insufficient AI balance. Top up in the AI Billing tab.",
    "type": "error",
    "code": "empty\_balance"
  }
}

`message` is always there. `type`, and whether `code` is set, vary by endpoint, so branch on the HTTP status first. Chat, embeddings, rerank, and the web tools put the [402 codes](#402-codes) in `code`. When the model's route answers chat, embeddings, or rerank with an HTTP error, the body also carries `request_id`. The `X-Request-ID` header is always there.

-   **400**: invalid JSON, missing `model`, or a model of the wrong kind for the endpoint (for example an OCR model on chat). A body over 25 MiB that reaches the API process uses `request body exceeds 25 MiB`.
-   **401**: see [Authentication](#authentication).
-   **402**: the wallet refused the request; see the codes below.
-   **404**: `model not found`, or an endpoint that does not exist.
-   **413**: the public host refused a body larger than 25 MiB before the API ran.
-   **429**: a key limit was hit, or the model is overloaded. Respect `Retry-After` where it is sent.
-   **502**: the model's route failed. Retry later.
-   **503**: no healthy route for the model, none that matches the project's privacy settings (Settings tab), or the settings could not be loaded.

402 codes. Chat, embeddings, rerank, and the web tools send them in `code`. OCR, audio, and image send only the message, and System One sends it as `detail`.

-   `empty_balance`: the available AI balance does not cover the hold for this request. Top up in the Billing tab, or turn on auto top-up.
-   `daily_quota`: today's spend on this key plus its open holds plus this request would pass the key's daily spend limit.
-   `month_quota`: this month's spend plus open holds plus this request would pass the monthly spend limit you set in the Billing tab.
-   `usage_limit`: this month's spend plus open holds plus this request would pass the monthly cap of your usage tier. The Billing tab shows the tier and when the next one applies.
-   `pricing_unavailable` and `reserve_failed`: the request could not be priced or held. Retry, then contact support with the request id.

Default limits per key:

-   300 requests per minute
-   2,000,000 tokens per minute (chat, embeddings, rerank, and System One)
-   10 concurrent requests
-   25 MiB request body on chat, embeddings, rerank, OCR, audio, and images. Tools are 1 MiB. System One is 512 KiB.

On chat, embeddings, and rerank a 429 sends `Retry-After: 5` for the request rate and for overload, `10` for the token rate, and `2` for concurrency. System One always sends `Retry-After: 5`. Creating a voice sends `Retry-After` when its own limits hit (too many uploads in progress, or more than ten create attempts per hour). Other 429s on OCR, audio, image, the web tools, and voices send none; wait a few seconds before you retry. Contact support if you need higher limits.

---

Source: https://www.nodion.com/docs/git

# Git integrations

## Connect a provider, then deploy from its repositories.

Integrations live on the account, at [Integrations](https://app.nodion.com/integrations). You can add more than one connection per provider. A project then picks an account (or a repo shared into the project) when you create an [application](https://www.nodion.com/docs/applications).

### What you can connect

-   Cloud providers the dashboard lists as configured (typically GitHub).
-   Self-hosted GitLab.
-   Self-hosted Gitea or Forgejo.

Self-hosted setup asks for the instance URL, then an OAuth app you create there. GitLab needs scopes `api`, `read_user`, and `read_repository`.

### After it is connected

Sync repositories from the integration. The row shows how many repos are cached and which apps use it. Share specific repos into a project on that project’s **Git sources** tab.

### Disconnect or remove

Disconnect stops new and automatic git deploys until you reconnect. Running deployments keep going. Remove clears the git link from apps that used it. That cannot be undone.

---

Source: https://www.nodion.com/docs/dockerfile

# Dockerfile

## Commit a Dockerfile. Nodion builds that image and runs it.

On [Applications → New](https://app.nodion.com/applications/new), connect a [Git](https://www.nodion.com/docs/git) repo and pick **Dockerfile**. The scan prefers this when it finds a Dockerfile. Use [Buildpacks](https://www.nodion.com/docs/buildpacks) when you want Nodion to install the runtime.

A **prebuilt image** skips the Git build. Push that image to a [registry](https://www.nodion.com/docs/registries) and deploy it. [Docker Compose](https://www.nodion.com/docs/compose) import at create is experimental and is not this strategy.

### What you set

-   **Base directory**: the build context, and where the Dockerfile lives in a monorepo.
-   **Dockerfile name**: usually `Dockerfile`. The scan also lists `Dockerfile.*`.
-   **Ports**: prefilled from TCP `EXPOSE` in that file. Add or remove as needed. After create, ports live on the **web** process.

Change strategy, path, and base directory later in **Settings**. That applies on the next deploy.

### What a build does

1.  Clones the branch.
2.  Uses the base directory as the build context. A `.dockerignore` there is honored. `.git` is never sent.
3.  Builds the named Dockerfile. Multi-stage files work. There is no stage picker, so the default final stage is what runs.
4.  Pushes the image and starts the `web` process from it.

Env vars marked **Build** on the **Environment** tab are passed as Docker build args (`ARG`). Runtime vars apply when the process starts, on the next deploy. Secrets stay write-only after save.

BuildKit secrets (`RUN --mount=type=secret`) are not wired. Put values you need at build time in those Build vars.

### Listen and health

Nodion does **not** set `PORT` on a Dockerfile app. That env is for [buildpacks](https://www.nodion.com/docs/buildpacks). Bind your server to the port on the web process (from `EXPOSE`, or whatever you set on **Processes**). If that list is empty, Nodion uses the image `EXPOSE`, then 8080.

Listen on all interfaces, not only localhost. The image `CMD` / `ENTRYPOINT` is the default start. Override the command on the process if you need to.

Readiness is an HTTP GET to the **Health check path** in Settings (default `/`) on the web port. A 2xx or 3xx response is healthy. A Docker `HEALTHCHECK` in the image is ignored.

The image `USER` is honored. An unknown user name fails the deploy.

---

Source: https://www.nodion.com/docs/compose

# Docker Compose

## Import a compose file once. Nodion turns it into an app, processes, and managed services.

This path is **experimental**. It is not `docker compose up`. Nodion does not keep running Compose, apply networks, or re-read the file on later deploys.

On [Applications → New](https://app.nodion.com/applications/new), connect a [Git](https://www.nodion.com/docs/git) repo. If the scan finds a compose file with at least one app service, a **Docker Compose** choice appears. It is never preselected. Click it to review the plan, then create.

### Which file

The shallowest of these names wins:

-   `docker-compose.yml` / `docker-compose.yaml`
-   `compose.yml` / `compose.yaml`

A file with only databases or caches (no app service) is ignored. A parse error is ignored. A compose file deep in a large repo can be missed if the scan is truncated.

### What gets created

One [application](https://www.nodion.com/docs/applications), not one app per service. Extra services become extra **processes** on that app. The wizard lets you pick package and replicas (1-16) before create. `deploy.replicas` in the file is ignored.

Compose image name contains

Nodion creates

`postgres`, `postgis`

Managed Postgres

`pgvector`

Managed pgvector

`mysql`, `mariadb`

Managed MySQL

`redis`, `valkey`

Managed Valkey

`clickhouse`

Managed ClickHouse

`minio`

A [bucket](https://www.nodion.com/docs/buckets)

Anything else, or a `build:`

A process on the app

Image tags such as `postgres:16` do not pick the managed engine version. Nodion uses its current default for that engine. Database users and passwords come from Nodion, not from the compose env on the database service.

If an app service env value points at another service as host (`postgres://…@db:5432/…`, `redis://cache:6379`), that key becomes an attach binding and is injected on deploy. Otherwise Postgres-style databases bind as `DATABASE_URL`, Valkey as `REDIS_URL`, and MinIO as the usual AWS/S3 keys.

Only the primary app service’s remaining environment is copied onto the app. Keys that look like secrets are marked secret in the form.

### Volumes

Named volumes become [volumes](https://www.nodion.com/docs/volumes) (default 5 GB, editable in the wizard) and mount on the matching processes. Bind mounts (`./data:/data`) and anonymous volumes are skipped.

### How the app builds after that

The app’s strategy is still [Dockerfile](https://www.nodion.com/docs/dockerfile) or [Buildpacks](https://www.nodion.com/docs/buildpacks), from the same repo scan. Compose `build.context` and `build.dockerfile` are not copied into those settings. There is one Git build per app. A second service with its own `build:` shares that image.

A service that only has `image:` (and is not a mapped database) keeps that image and runs it as a process. The primary service with `build:` is renamed `web`.

First deploy waits until attached databases and buckets are ready. After create, change processes, env, and resources in the dashboard. Editing the compose file in Git does not update the plan.

### What is ignored

-   Networks, profiles, and Compose healthchecks
-   `depends_on` as startup order (a wait-only helper container is skipped)
-   Bind mounts
-   Per-service builds beyond the one app image

If a managed engine or object storage is not available in the region, that resource is skipped and the app is still created.

---

Source: https://www.nodion.com/docs/registries

# Registries

## A container registry in each region you use.

Open [Registries](https://app.nodion.com/registries). Each region shows a host and, per project, robot credentials for push and pull.

### Credentials

Generate credentials on the project row. Show them when you need the secret again, or rotate to issue a new password. Only someone who can manage that project can do this. Copy the password when it is shown.

Docker login uses the host on the card and the robot username.

### External registries

On the same page, add credentials for Docker Hub, GHCR, GitLab, Quay, or a custom host. Nodion uses them to pull a private **Prebuilt image** at deploy time.

### Deploy the image

Create an application with source **Prebuilt image** and point it at the image you pushed, or at a private image from an external registry. See [Applications](https://www.nodion.com/docs/applications).

---

Source: https://www.nodion.com/docs/presets

# One-click apps

## Presets that create an app and the resources it needs.

On [New application](https://app.nodion.com/applications/new), choose **Preset**, then pick the app. The form fills in the image, processes, and any databases, volumes, or buckets the blueprint asks for. You still pick a project and a region.

### From a coding agent

Connected over [MCP](https://www.nodion.com/docs/mcp), the agent lists the catalog with `presets.list` (optional `category` or `q`; rows are key, name, description, category), loads one key with `presets.get`, then calls `apps.create` with `preset_key` (for example `twenty`), a name, and a region. It does not send a blueprint. The first release starts when attached databases are ready; the agent should poll `apps.get` rather than call `deploy`.

### From the website

The [deploy catalog](https://www.nodion.com/deploy) has a button per app. It opens `https://app.nodion.com/applications/new?preset=key`. The `key` is lowercase and must match the catalog. Sign in first if you are not already.

### Catalog

These keys are the built-in presets. A Deploy link opens the create form with that preset selected.

App

Description

Key

[Activepieces](https://www.nodion.com/deploy/activepieces)

Open-source Zapier alternative, backed by PostgreSQL with pgvector and Valkey.

`activepieces`

[Deploy](https://app.nodion.com/applications/new?preset=activepieces)

[Actual Budget](https://www.nodion.com/deploy/actual-budget)

Local-first envelope budgeting you can sync across devices.

`actual-budget`

[Deploy](https://app.nodion.com/applications/new?preset=actual-budget)

[Answer](https://www.nodion.com/deploy/answer)

Team Q and A community, backed by PostgreSQL.

`answer`

[Deploy](https://app.nodion.com/applications/new?preset=answer)

[Authorizer](https://www.nodion.com/deploy/authorizer)

Self-hosted login and OAuth, backed by PostgreSQL and Valkey.

`authorizer`

[Deploy](https://app.nodion.com/applications/new?preset=authorizer)

[Automatisch](https://www.nodion.com/deploy/automatisch)

Workflow automation, backed by PostgreSQL and Valkey.

`automatisch`

[Deploy](https://app.nodion.com/applications/new?preset=automatisch)

[Baserow](https://www.nodion.com/deploy/baserow)

No-code database and Airtable alternative, backed by PostgreSQL and Valkey.

`baserow`

[Deploy](https://app.nodion.com/applications/new?preset=baserow)

[Beszel](https://www.nodion.com/deploy/beszel)

Lightweight server monitoring hub with Docker stats, history, and alerts.

`beszel`

[Deploy](https://app.nodion.com/applications/new?preset=beszel)

[Bytebase](https://www.nodion.com/deploy/bytebase)

Schema review and rollout for databases, backed by PostgreSQL.

`bytebase`

[Deploy](https://app.nodion.com/applications/new?preset=bytebase)

[ByteStash](https://www.nodion.com/deploy/bytestash)

Code snippet manager, backed by PostgreSQL.

`bytestash`

[Deploy](https://app.nodion.com/applications/new?preset=bytestash)

[Campfire](https://www.nodion.com/deploy/campfire-once)

Super simple group chat from Basecamp ONCE, with SQLite on disk.

`campfire-once`

[Deploy](https://app.nodion.com/applications/new?preset=campfire-once)

[Cap](https://www.nodion.com/deploy/cap)

Self-hosted CAPTCHA server, backed by Valkey.

`cap`

[Deploy](https://app.nodion.com/applications/new?preset=cap)

[Cap.so](https://www.nodion.com/deploy/cap-so)

Open-source Loom alternative for shareable screen recordings, backed by MySQL and object storage.

`cap-so`

[Deploy](https://app.nodion.com/applications/new?preset=cap-so)

[Carbone](https://www.nodion.com/deploy/carbone)

Generate PDF, DOCX, XLSX and more from templates and JSON.

`carbone`

[Deploy](https://app.nodion.com/applications/new?preset=carbone)

[Castopod](https://www.nodion.com/deploy/castopod)

Self-hosted podcast platform, backed by MySQL and object storage.

`castopod`

[Deploy](https://app.nodion.com/applications/new?preset=castopod)

[ChartDB](https://www.nodion.com/deploy/chartdb)

Visualize and edit database schemas from a Smart Query. No server database.

`chartdb`

[Deploy](https://app.nodion.com/applications/new?preset=chartdb)

[Chatwoot](https://www.nodion.com/deploy/chatwoot)

Live chat and omnichannel support, backed by PostgreSQL with pgvector and Valkey.

`chatwoot`

[Deploy](https://app.nodion.com/applications/new?preset=chatwoot)

[Chevereto](https://www.nodion.com/deploy/chevereto)

Self-hosted image hosting, backed by MySQL.

`chevereto`

[Deploy](https://app.nodion.com/applications/new?preset=chevereto)

[ChiefOnboarding](https://www.nodion.com/deploy/chiefonboarding)

Employee onboarding sequences, backed by PostgreSQL.

`chiefonboarding`

[Deploy](https://app.nodion.com/applications/new?preset=chiefonboarding)

[CiviCRM](https://www.nodion.com/deploy/civicrm)

Open-source CRM for nonprofits, backed by MySQL.

`civicrm`

[Deploy](https://app.nodion.com/applications/new?preset=civicrm)

[Claper](https://www.nodion.com/deploy/claper)

Live polls and audience interaction, backed by PostgreSQL.

`claper`

[Deploy](https://app.nodion.com/applications/new?preset=claper)

[Cockpit](https://www.nodion.com/deploy/cockpit)

Headless CMS for structured content, with SQLite on a volume.

`cockpit`

[Deploy](https://app.nodion.com/applications/new?preset=cockpit)

[code-server](https://www.nodion.com/deploy/code-server)

VS Code in the browser, with a persistent workspace volume.

`code-server`

[Deploy](https://app.nodion.com/applications/new?preset=code-server)

[ConvertX](https://www.nodion.com/deploy/convertx)

Convert files between a thousand formats in the browser.

`convertx`

[Deploy](https://app.nodion.com/applications/new?preset=convertx)

[Corteza](https://www.nodion.com/deploy/corteza)

Low-code CRM and workspace, backed by managed PostgreSQL.

`corteza`

[Deploy](https://app.nodion.com/applications/new?preset=corteza)

[Dexio](https://www.nodion.com/deploy/dexio)

Wiki for people and AI agents, backed by managed PostgreSQL and object storage.

`dexio`

[Deploy](https://app.nodion.com/applications/new?preset=dexio)

[Docmost](https://www.nodion.com/deploy/docmost)

Collaborative wiki and documentation, backed by PostgreSQL and Valkey.

`docmost`

[Deploy](https://app.nodion.com/applications/new?preset=docmost)

[Documenso](https://www.nodion.com/deploy/documenso)

Open-source document signing, backed by PostgreSQL.

`documenso`

[Deploy](https://app.nodion.com/applications/new?preset=documenso)

[DocuSeal](https://www.nodion.com/deploy/docuseal)

Open-source document filling and signing, backed by PostgreSQL.

`docuseal`

[Deploy](https://app.nodion.com/applications/new?preset=docuseal)

[Dolibarr](https://www.nodion.com/deploy/dolibarr)

ERP and CRM for companies, backed by managed MySQL.

`dolibarr`

[Deploy](https://app.nodion.com/applications/new?preset=dolibarr)

[Easy!Appointments](https://www.nodion.com/deploy/easy-appointments)

Customer booking calendar, backed by managed MySQL.

`easy-appointments`

[Deploy](https://app.nodion.com/applications/new?preset=easy-appointments)

[Engram](https://www.nodion.com/deploy/engram)

Sync memory for AI coding agents, backed by managed PostgreSQL.

`engram`

[Deploy](https://app.nodion.com/applications/new?preset=engram)

[EspoCRM](https://www.nodion.com/deploy/espocrm)

Open-source CRM, backed by PostgreSQL.

`espocrm`

[Deploy](https://app.nodion.com/applications/new?preset=espocrm)

[Faraday](https://www.nodion.com/deploy/faraday)

Vulnerability management workspace, backed by PostgreSQL and Valkey.

`faraday`

[Deploy](https://app.nodion.com/applications/new?preset=faraday)

[Fider](https://www.nodion.com/deploy/fider)

Collect and prioritize product feedback, backed by PostgreSQL.

`fider`

[Deploy](https://app.nodion.com/applications/new?preset=fider)

[FileGator](https://www.nodion.com/deploy/filegator)

Multi-user file manager with files on object storage.

`filegator`

[Deploy](https://app.nodion.com/applications/new?preset=filegator)

[Flagsmith](https://www.nodion.com/deploy/flagsmith)

Open-source feature flags and remote config, backed by PostgreSQL.

`flagsmith`

[Deploy](https://app.nodion.com/applications/new?preset=flagsmith)

[Fleet](https://www.nodion.com/deploy/fleet)

Device inventory and osquery management, backed by MySQL and Valkey.

`fleet`

[Deploy](https://app.nodion.com/applications/new?preset=fleet)

[Formbricks](https://www.nodion.com/deploy/formbricks)

Open-source surveys and feedback, backed by PostgreSQL with pgvector.

`formbricks`

[Deploy](https://app.nodion.com/applications/new?preset=formbricks)

[FreeScout](https://www.nodion.com/deploy/freescout)

Shared inbox and help desk, backed by PostgreSQL.

`freescout`

[Deploy](https://app.nodion.com/applications/new?preset=freescout)

[FreshRSS](https://www.nodion.com/deploy/freshrss)

Self-hosted feed reader, backed by PostgreSQL.

`freshrss`

[Deploy](https://app.nodion.com/applications/new?preset=freshrss)

[GeoServer](https://www.nodion.com/deploy/geoserver)

Share maps and geospatial data over HTTPS. Layers and styles persist on a data volume.

`geoserver`

[Deploy](https://app.nodion.com/applications/new?preset=geoserver)

[GlitchTip](https://www.nodion.com/deploy/glitchtip)

Sentry-compatible error tracking, backed by PostgreSQL.

`glitchtip`

[Deploy](https://app.nodion.com/applications/new?preset=glitchtip)

[GLPI](https://www.nodion.com/deploy/glpi)

IT asset management and helpdesk, backed by MySQL.

`glpi`

[Deploy](https://app.nodion.com/applications/new?preset=glpi)

[Gokapi](https://www.nodion.com/deploy/gokapi)

Share files that expire after a set time or number of downloads. Uploads go to object storage.

`gokapi`

[Deploy](https://app.nodion.com/applications/new?preset=gokapi)

[Gotify](https://www.nodion.com/deploy/gotify)

Push notifications with a web UI, REST API, and clients, backed by PostgreSQL.

`gotify`

[Deploy](https://app.nodion.com/applications/new?preset=gotify)

[Hi.Events](https://www.nodion.com/deploy/hi-events)

Event pages and ticketing, backed by PostgreSQL and Valkey. Uploads go to object storage.

`hi-events`

[Deploy](https://app.nodion.com/applications/new?preset=hi-events)

[Horilla](https://www.nodion.com/deploy/horilla)

HR management for employees, leave, payroll, and recruiting, backed by PostgreSQL and Valkey.

`horilla`

[Deploy](https://app.nodion.com/applications/new?preset=horilla)

[Huginn](https://www.nodion.com/deploy/huginn)

Build agents that watch the web and act for you, backed by MySQL.

`huginn`

[Deploy](https://app.nodion.com/applications/new?preset=huginn)

[HumHub](https://www.nodion.com/deploy/humhub)

Private social network for teams and communities, backed by MySQL.

`humhub`

[Deploy](https://app.nodion.com/applications/new?preset=humhub)

[imagor](https://www.nodion.com/deploy/imagor)

On-demand image resize, crop, and conversion with signed URLs.

`imagor`

[Deploy](https://app.nodion.com/applications/new?preset=imagor)

[Infisical](https://www.nodion.com/deploy/infisical)

Secrets, certificates, and access management, backed by PostgreSQL and Valkey.

`infisical`

[Deploy](https://app.nodion.com/applications/new?preset=infisical)

[Inkvoice](https://www.nodion.com/deploy/inkvoice)

Invoices, expenses, and online payments for freelancers, stored in a local database.

`inkvoice`

[Deploy](https://app.nodion.com/applications/new?preset=inkvoice)

[Instatic](https://www.nodion.com/deploy/instatic)

Visual CMS and static site publisher, backed by PostgreSQL.

`instatic`

[Deploy](https://app.nodion.com/applications/new?preset=instatic)

[InvenTree](https://www.nodion.com/deploy/inventree)

Inventory and stock control, backed by PostgreSQL, Valkey, and object storage.

`inventree`

[Deploy](https://app.nodion.com/applications/new?preset=inventree)

[InvoiceShelf](https://www.nodion.com/deploy/invoiceshelf)

Invoices, estimates, and expenses, backed by PostgreSQL.

`invoiceshelf`

[Deploy](https://app.nodion.com/applications/new?preset=invoiceshelf)

[Jean](https://www.nodion.com/deploy/jean)

Headless workspace for coding agents, with a token-protected web UI.

`jean`

[Deploy](https://app.nodion.com/applications/new?preset=jean)

[Kanboard](https://www.nodion.com/deploy/kanboard)

Visual task boards, backed by PostgreSQL.

`kanboard`

[Deploy](https://app.nodion.com/applications/new?preset=kanboard)

[Kaneo](https://www.nodion.com/deploy/kaneo)

Project management for teams, backed by PostgreSQL and object storage.

`kaneo`

[Deploy](https://app.nodion.com/applications/new?preset=kaneo)

[Keila](https://www.nodion.com/deploy/keila)

Newsletters and signup forms, backed by PostgreSQL.

`keila`

[Deploy](https://app.nodion.com/applications/new?preset=keila)

[Kellnr](https://www.nodion.com/deploy/kellnr)

Private Rust crate registry, backed by PostgreSQL.

`kellnr`

[Deploy](https://app.nodion.com/applications/new?preset=kellnr)

[Kener](https://www.nodion.com/deploy/kener)

Status page and incident management, backed by PostgreSQL and Valkey.

`kener`

[Deploy](https://app.nodion.com/applications/new?preset=kener)

[Keycloak](https://www.nodion.com/deploy/keycloak)

Open-source identity and access management, backed by PostgreSQL.

`keycloak`

[Deploy](https://app.nodion.com/applications/new?preset=keycloak)

[Kimai](https://www.nodion.com/deploy/kimai)

Time tracking and invoicing, backed by MySQL.

`kimai`

[Deploy](https://app.nodion.com/applications/new?preset=kimai)

[Komari Monitor](https://www.nodion.com/deploy/komari-monitor)

Lightweight server monitoring panel with a web dashboard.

`komari-monitor`

[Deploy](https://app.nodion.com/applications/new?preset=komari-monitor)

[Kutt](https://www.nodion.com/deploy/kutt)

URL shortener with custom domains, backed by PostgreSQL and Valkey.

`kutt`

[Deploy](https://app.nodion.com/applications/new?preset=kutt)

[Label Studio](https://www.nodion.com/deploy/label-studio)

Data labeling and annotation, backed by PostgreSQL.

`label-studio`

[Deploy](https://app.nodion.com/applications/new?preset=label-studio)

[Langflow](https://www.nodion.com/deploy/langflow)

Visual builder for AI agents and RAG flows, backed by PostgreSQL.

`langflow`

[Deploy](https://app.nodion.com/applications/new?preset=langflow)

[Langfuse](https://www.nodion.com/deploy/langfuse)

LLM tracing and prompt management, backed by PostgreSQL, ClickHouse, and Valkey.

`langfuse`

[Deploy](https://app.nodion.com/applications/new?preset=langfuse)

[Leantime](https://www.nodion.com/deploy/leantime)

Project management for small teams, backed by MySQL.

`leantime`

[Deploy](https://app.nodion.com/applications/new?preset=leantime)

[LibreDB Studio](https://www.nodion.com/deploy/libredb-studio)

Browser SQL IDE for many databases. Saved connections stay on a local store.

`libredb-studio`

[Deploy](https://app.nodion.com/applications/new?preset=libredb-studio)

[Libredesk](https://www.nodion.com/deploy/libredesk)

Omnichannel customer support desk, backed by PostgreSQL and Valkey.

`libredesk`

[Deploy](https://app.nodion.com/applications/new?preset=libredesk)

[Lightdash](https://www.nodion.com/deploy/lightdash)

Open-source BI on top of dbt, backed by PostgreSQL.

`lightdash`

[Deploy](https://app.nodion.com/applications/new?preset=lightdash)

[LimeSurvey](https://www.nodion.com/deploy/limesurvey)

Feature-rich surveys and polls, backed by MySQL.

`limesurvey`

[Deploy](https://app.nodion.com/applications/new?preset=limesurvey)

[Linkwarden](https://www.nodion.com/deploy/linkwarden)

Bookmark and archive manager, backed by PostgreSQL.

`linkwarden`

[Deploy](https://app.nodion.com/applications/new?preset=linkwarden)

[listmonk](https://www.nodion.com/deploy/listmonk)

Newsletter and mailing lists, backed by PostgreSQL.

`listmonk`

[Deploy](https://app.nodion.com/applications/new?preset=listmonk)

[Louez](https://www.nodion.com/deploy/louez)

Rental storefront and dashboard, backed by MySQL.

`louez`

[Deploy](https://app.nodion.com/applications/new?preset=louez)

[Matomo](https://www.nodion.com/deploy/matomo)

Privacy-focused web analytics, backed by MySQL.

`matomo`

[Deploy](https://app.nodion.com/applications/new?preset=matomo)

[Mautic](https://www.nodion.com/deploy/mautic)

Marketing automation for campaigns and contacts, backed by MySQL.

`mautic`

[Deploy](https://app.nodion.com/applications/new?preset=mautic)

[MCP Context Forge](https://www.nodion.com/deploy/mcp-context-forge)

IBM MCP gateway and registry, backed by PostgreSQL.

`mcp-context-forge`

[Deploy](https://app.nodion.com/applications/new?preset=mcp-context-forge)

[Metabase](https://www.nodion.com/deploy/metabase)

Business intelligence and dashboards, backed by PostgreSQL.

`metabase`

[Deploy](https://app.nodion.com/applications/new?preset=metabase)

[n8n](https://www.nodion.com/deploy/n8n)

Workflow automation, backed by PostgreSQL.

`n8n`

[Deploy](https://app.nodion.com/applications/new?preset=n8n)

[nao](https://www.nodion.com/deploy/nao)

Open-source analytics agent chat, backed by PostgreSQL and object storage.

`nao`

[Deploy](https://app.nodion.com/applications/new?preset=nao)

[NocoDB](https://www.nodion.com/deploy/nocodb)

Open-source Airtable alternative, backed by PostgreSQL.

`nocodb`

[Deploy](https://app.nodion.com/applications/new?preset=nocodb)

[NodeBB](https://www.nodion.com/deploy/nodebb)

Modern community forum, backed by PostgreSQL.

`nodebb`

[Deploy](https://app.nodion.com/applications/new?preset=nodebb)

[nopCommerce](https://www.nodion.com/deploy/nopcommerce)

Open-source ASP.NET storefront, backed by PostgreSQL.

`nopcommerce`

[Deploy](https://app.nodion.com/applications/new?preset=nopcommerce)

[Odoo](https://www.nodion.com/deploy/odoo)

Open-source ERP and business apps, backed by PostgreSQL.

`odoo`

[Deploy](https://app.nodion.com/applications/new?preset=odoo)

[Openinary](https://www.nodion.com/deploy/openinary)

Self-hosted image and video CDN, with object storage and SQLite.

`openinary`

[Deploy](https://app.nodion.com/applications/new?preset=openinary)

[OpenPanel](https://www.nodion.com/deploy/openpanel)

Open-source product analytics, backed by PostgreSQL, ClickHouse, and Valkey.

`openpanel`

[Deploy](https://app.nodion.com/applications/new?preset=openpanel)

[OpenProject](https://www.nodion.com/deploy/openproject)

Project management with work packages, backed by PostgreSQL.

`openproject`

[Deploy](https://app.nodion.com/applications/new?preset=openproject)

[OpenSEO](https://www.nodion.com/deploy/open-seo)

Open-source SEO research and site audits. Bring your own DataForSEO key.

`open-seo`

[Deploy](https://app.nodion.com/applications/new?preset=open-seo)

[OrangeHRM](https://www.nodion.com/deploy/orangehrm)

HR management for people and leave, backed by MySQL.

`orangehrm`

[Deploy](https://app.nodion.com/applications/new?preset=orangehrm)

[Outline](https://www.nodion.com/deploy/outline)

Team knowledge base and wiki, backed by PostgreSQL.

`outline`

[Deploy](https://app.nodion.com/applications/new?preset=outline)

[Paperless-ngx](https://www.nodion.com/deploy/paperless-ngx)

Document archive with OCR, backed by PostgreSQL and Valkey.

`paperless-ngx`

[Deploy](https://app.nodion.com/applications/new?preset=paperless-ngx)

[PicoShare](https://www.nodion.com/deploy/picoshare)

Minimalist file sharing with an admin passphrase.

`picoshare`

[Deploy](https://app.nodion.com/applications/new?preset=picoshare)

[Plausible](https://www.nodion.com/deploy/plausible)

Privacy-friendly web analytics, backed by PostgreSQL and ClickHouse.

`plausible`

[Deploy](https://app.nodion.com/applications/new?preset=plausible)

[Pocket ID](https://www.nodion.com/deploy/pocket-id)

Passkey OIDC provider, backed by PostgreSQL.

`pocket-id`

[Deploy](https://app.nodion.com/applications/new?preset=pocket-id)

[Postiz](https://www.nodion.com/deploy/postiz)

Social media scheduling with AI, backed by PostgreSQL.

`postiz`

[Deploy](https://app.nodion.com/applications/new?preset=postiz)

[ProjectSend](https://www.nodion.com/deploy/projectsend)

Client file sharing, backed by MySQL and Valkey.

`projectsend`

[Deploy](https://app.nodion.com/applications/new?preset=projectsend)

[Rallly](https://www.nodion.com/deploy/rallly)

Schedule group meetings with polls, backed by PostgreSQL and object storage.

`rallly`

[Deploy](https://app.nodion.com/applications/new?preset=rallly)

[Reactive Resume](https://www.nodion.com/deploy/reactive-resume)

Privacy-first resume builder, backed by PostgreSQL and object storage.

`reactive-resume`

[Deploy](https://app.nodion.com/applications/new?preset=reactive-resume)

[RStudio Server](https://www.nodion.com/deploy/rstudio-server)

Browser IDE for R on a Linux server.

`rstudio-server`

[Deploy](https://app.nodion.com/applications/new?preset=rstudio-server)

[Rustrak](https://www.nodion.com/deploy/rustrak)

Sentry-compatible error tracking, backed by PostgreSQL.

`rustrak`

[Deploy](https://app.nodion.com/applications/new?preset=rustrak)

[Saltcorn](https://www.nodion.com/deploy/saltcorn)

No-code database application builder, backed by PostgreSQL.

`saltcorn`

[Deploy](https://app.nodion.com/applications/new?preset=saltcorn)

[SendDock](https://www.nodion.com/deploy/senddock)

Self-hosted email marketing with your own SMTP, backed by PostgreSQL and Valkey.

`senddock`

[Deploy](https://app.nodion.com/applications/new?preset=senddock)

[SendRec](https://www.nodion.com/deploy/sendrec)

Open-source Loom alternative for shareable screen recordings, backed by PostgreSQL and object storage.

`sendrec`

[Deploy](https://app.nodion.com/applications/new?preset=sendrec)

[Shlink](https://www.nodion.com/deploy/shlink)

Self-hosted URL shortener with a web client, backed by PostgreSQL.

`shlink`

[Deploy](https://app.nodion.com/applications/new?preset=shlink)

[Snipe-IT](https://www.nodion.com/deploy/snipe-it)

IT asset and license management, backed by MySQL and object storage.

`snipe-it`

[Deploy](https://app.nodion.com/applications/new?preset=snipe-it)

[SolidPing](https://www.nodion.com/deploy/solidping)

Uptime monitoring and status pages, backed by PostgreSQL and object storage.

`solidping`

[Deploy](https://app.nodion.com/applications/new?preset=solidping)

[Sure](https://www.nodion.com/deploy/sure)

Personal finance tracking, backed by PostgreSQL, Valkey, and object storage.

`sure`

[Deploy](https://app.nodion.com/applications/new?preset=sure)

[Termix](https://www.nodion.com/deploy/termix)

Browser SSH and server manager, backed by PostgreSQL.

`termix`

[Deploy](https://app.nodion.com/applications/new?preset=termix)

[Tianji](https://www.nodion.com/deploy/tianji)

Website analytics, uptime checks, and status pages, backed by PostgreSQL.

`tianji`

[Deploy](https://app.nodion.com/applications/new?preset=tianji)

[ToolJet](https://www.nodion.com/deploy/tooljet)

Build internal tools, backed by PostgreSQL and Valkey.

`tooljet`

[Deploy](https://app.nodion.com/applications/new?preset=tooljet)

[Trilium](https://www.nodion.com/deploy/trilium)

Hierarchical personal knowledge base. Notes stay on a persistent volume.

`trilium`

[Deploy](https://app.nodion.com/applications/new?preset=trilium)

[Twenty](https://www.nodion.com/deploy/twenty)

Open-source Salesforce alternative, backed by PostgreSQL.

`twenty`

[Deploy](https://app.nodion.com/applications/new?preset=twenty)

[Umami](https://www.nodion.com/deploy/umami)

Privacy-focused web analytics, backed by PostgreSQL.

`umami`

[Deploy](https://app.nodion.com/applications/new?preset=umami)

[Unleash](https://www.nodion.com/deploy/unleash)

Open-source feature management platform, backed by PostgreSQL.

`unleash`

[Deploy](https://app.nodion.com/applications/new?preset=unleash)

[Vikunja](https://www.nodion.com/deploy/vikunja)

Team tasks and to-dos, backed by PostgreSQL and object storage.

`vikunja`

[Deploy](https://app.nodion.com/applications/new?preset=vikunja)

[Wakapi](https://www.nodion.com/deploy/wakapi)

WakaTime-compatible coding stats, backed by MySQL.

`wakapi`

[Deploy](https://app.nodion.com/applications/new?preset=wakapi)

[Waxum](https://www.nodion.com/deploy/waxum)

WhatsApp REST API gateway, backed by PostgreSQL.

`waxum`

[Deploy](https://app.nodion.com/applications/new?preset=waxum)

[Weblate](https://www.nodion.com/deploy/weblate)

Continuous localization, backed by PostgreSQL and Valkey.

`weblate`

[Deploy](https://app.nodion.com/applications/new?preset=weblate)

[Wiki.js](https://www.nodion.com/deploy/wiki-js)

Modern wiki and documentation, backed by PostgreSQL.

`wiki-js`

[Deploy](https://app.nodion.com/applications/new?preset=wiki-js)

[XWiki](https://www.nodion.com/deploy/xwiki)

Enterprise wiki and knowledge base, backed by PostgreSQL.

`xwiki`

[Deploy](https://app.nodion.com/applications/new?preset=xwiki)

[YOURLS](https://www.nodion.com/deploy/yourls)

Self-hosted URL shortener, backed by MySQL.

`yourls`

[Deploy](https://app.nodion.com/applications/new?preset=yourls)

### After it is up

The application page shows the preset name. From there it behaves like any other app: processes, env, domains, logs. See [Applications](https://www.nodion.com/docs/applications).

---

Source: https://www.nodion.com/docs/buildpacks

# Buildpacks

## Commit source. Nodion detects the language, installs a runtime, and builds an image.

On [Applications → New](https://app.nodion.com/applications/new), connect a [Git](https://www.nodion.com/docs/git) repo and pick **Buildpacks**. Nodion uses the default builder unless you choose another one. Point **Base directory** at the app folder in a monorepo.

Use a [Dockerfile](https://www.nodion.com/docs/dockerfile) instead when you already have one, or when the repo is not a supported language tree.

### What they are

Nodion Buildpacks are [Cloud Native Buildpacks](https://buildpacks.io). Detect, build, and launch follow that spec. The language packs, the Ubuntu stack, and the runtime versions are Nodion’s. They are not Paketo, Heroku, or Google buildpacks.

The current stack is **nodion-26**: Ubuntu 26.04 LTS. The build image has compilers and headers. The run image has common client libraries (Postgres, MySQL, ImageMagick, CA certificates, and similar). The process runs as a non-root user. Extra system packages go in an Aptfile or `project.toml`.

### What a build does

1.  Looks at the files in the base directory and picks the first matching language group.
2.  Resolves a runtime from your pin (or the default), then installs that version.
3.  Installs dependencies from the lockfile or manifest.
4.  Runs the language build (assets, `mix release`, `go build`, and so on).
5.  Sets a default `web` process. A Procfile overrides that.

Listen on `PORT`. Nodion sets it. Most default commands fall back to 8080 if it is unset.

### Detection

Groups are tried from the top. The first group whose required files are all present wins. Extra Debian packages are optional in every group.

If the tree has

Nodion uses

`package.json` and a static frontend

[Node.js](https://www.nodion.com/docs/nodejs), then [static](https://www.nodion.com/docs/static)

`composer.json` and `package.json`

[PHP](https://www.nodion.com/docs/php) plus Node (Laravel with Vite, for example)

`Gemfile` and `package.json`

[Ruby](https://www.nodion.com/docs/ruby) plus Node (Rails with JS)

`composer.json`

PHP

`Gemfile`

Ruby

`requirements.txt`, `Pipfile`, or `pyproject.toml`

[Python](https://www.nodion.com/docs/python)

`go.mod`

[Go](https://www.nodion.com/docs/go)

`Cargo.toml`

[Rust](https://www.nodion.com/docs/rust)

`mix.exs`

[Elixir](https://www.nodion.com/docs/elixir)

`pom.xml` or Gradle files

[Java](https://www.nodion.com/docs/java)

`*.csproj`, `*.fsproj`, or `*.sln`

[.NET](https://www.nodion.com/docs/dotnet)

`package.json` only (a server app)

Node.js

`static.toml` and no `package.json`

Static site

`Procfile` only

Your process types, no language install

The dashboard scan warns when it sees no supported marker. You can still pick Buildpacks, or switch to a Dockerfile, or set a different base directory.

### Supported versions

Nodion keeps a language line while it is not end-of-life, and for up to three months after. Request a minor and you get the latest published patch of that minor. A version below the oldest published line fails as end-of-life. A version newer than anything built yet fails as not available yet.

Go and Rust are the exception: the newest published toolchain builds the app. Older `go.mod` or `rust-version` values still compile.

Lines below are current as of September 2026. Patches move as we publish them. Pin a file from the language page if you care which minor you get.

Language

Default

Published lines

[Node.js](https://www.nodion.com/docs/nodejs)

24

22, 24, 25, 26

[Python](https://www.nodion.com/docs/python)

3.13

3.10-3.14

[PHP](https://www.nodion.com/docs/php)

8.3

8.2-8.5

[Ruby](https://www.nodion.com/docs/ruby)

3.4

3.3, 3.4, 4.0

[Go](https://www.nodion.com/docs/go)

1.26

Newest toolchain (currently 1.25-1.27)

[Rust](https://www.nodion.com/docs/rust)

1.96

Newest toolchain (currently 1.95-1.98)

[Java](https://www.nodion.com/docs/java)

21

11, 17, 21, 25, 26

[.NET](https://www.nodion.com/docs/dotnet)

10

8, 9, 10

[Elixir](https://www.nodion.com/docs/elixir)

1.20

1.15-1.20 (Erlang/OTP 26-29, default 28)

### Procfile

A `Procfile` in the base directory defines process types. `web` is the default if present, otherwise the first line. Language defaults apply only when there is no Procfile.

```
web: gunicorn myapp.wsgi --bind 0.0.0.0:$PORT
worker: python worker.py
```

Each type is its own process on the app. Scale replicas and the command on the **Processes** tab.

### Extra Debian packages

Prefer `project.toml`. An `Aptfile` (one package or `.deb` URL per line) still works. `project.toml` wins if both exist.

```
[com.nodion.buildpacks.deb-packages]
install = ["ffmpeg", "pandoc"]
```

Packages are extracted into the image. Maintainer scripts do not run, so packages that create system users or start services will not work. A direct `https://…/*.deb` URL is downloaded as-is, without dependency resolution.

---

Source: https://www.nodion.com/docs/nodejs

# Node.js

## Detected from package.json. npm, yarn, pnpm, or bun from the lockfile.

See [Buildpacks](https://www.nodion.com/docs/buildpacks) for how detection and version policy work. A repo that also looks like a static frontend is built here, then served by the [static](https://www.nodion.com/docs/static) buildpack.

### Detects

`package.json` in the base directory.

### Versions

Default is Node.js 24. Published lines as of September 2026: 22, 24, 25, 26. You get the latest patch of the requested minor.

Pin, in this order:

-   `.node-version`
-   `.nvmrc`
-   `engines.node` in `package.json` (a range such as `^22` picks the highest matching published version)

A leading `v` is stripped.

### Install and build

The lockfile picks the package manager: `bun.lock` or `bun.lockb` first (or `package.json` `"packageManager": "bun@…"`), then `pnpm-lock.yaml`, then `yarn.lock`, otherwise npm. A lockfile is required (`npm ci` or a frozen install). The build fails without one.

If `package.json` has a `build` script, that runs (`bun run build` for Bun, `npm run build` otherwise). A `heroku-postbuild` script runs after that, if present. Dev dependencies are pruned for the run image, except Next.js apps that start with a TypeScript `next.config.*` (those keep typescript at launch).

Yarn and pnpm go through Corepack. Bun is installed from the Nodion binary mirror (not bun.sh at app-build time) and stays on `PATH` at launch so a start script that calls `bun` works. The default process is still the start script or `node`, not rewritten to Bun. Launch sets `NODE_ENV=production` and puts `node_modules/.bin` on `PATH`.

### Start command

First match wins:

1.  The `start` script in `package.json`
2.  A known SSR framework default (see below)
3.  `node server.js`, `index.js`, or `app.js` if that file exists
4.  `node .`

Override with a Procfile. Listen on `PORT`.

### Frameworks

-   **Next.js**: `next start`, unless `output: 'export'`, which is a static site (`out/`).
-   **Nuxt**: `node .output/server/index.mjs`
-   **SvelteKit**: static with `adapter-static` (`build/`), or `node build` with `adapter-node`
-   **Remix / React Router**: `npx remix-serve ./build/server/index.js`
-   **Astro**: static `dist/`, or `node ./dist/server/entry.mjs` when output is `server` or `hybrid`
-   **Angular, Gatsby, Create React App, Eleventy, Vite**: treated as static output

PHP + Node (Laravel with Vite) and Ruby + Node (Rails with JS) are polyglot groups. See [PHP](https://www.nodion.com/docs/php) and [Ruby](https://www.nodion.com/docs/ruby).

---

Source: https://www.nodion.com/docs/static

# Static sites

## Build the files, then serve them with a static web server.

This pack does not compile a language runtime. For JS frontends, [Node.js](https://www.nodion.com/docs/nodejs) runs `npm run build` first. See [Buildpacks](https://www.nodion.com/docs/buildpacks) for detection order.

### Detects

-   `static.toml` in the base directory, or
-   A known static JS framework (Vite, Astro without a server adapter, Angular, Gatsby, and similar), or
-   `package.json` with a `build` script and no server entrypoint (`server.js`, `index.js`, …)

Next.js, Nuxt, and other SSR frameworks stay on the Node pack and are not served as static files, unless Next is set to `output: 'export'`.

### Output directory

Resolved in this order:

1.  `output-dir` in `static.toml`
2.  The framework default (`dist`, `out`, `build`, `public`, `_site`, Angular’s nested `dist/…/browser`)
3.  The first of those folders that contains `index.html`

```
output-dir = "dist"
fallback = "index.html"
```

`fallback` is the SPA rewrite. If you omit it and `index.html` exists, Nodion uses that.

### Start command

`static-web-server` on `0.0.0.0:$PORT` (8080 if `PORT` is unset), with compression. Override with a Procfile if you must.

---

Source: https://www.nodion.com/docs/python

# Python

## Detected from requirements.txt, Pipfile, or pyproject.toml.

See [Buildpacks](https://www.nodion.com/docs/buildpacks) for how detection and version policy work.

### Detects

`requirements.txt`, `Pipfile`, or `pyproject.toml` in the base directory.

### Versions

Default is Python 3.13. Published lines as of September 2026: 3.10-3.14. You get the latest patch of the requested minor.

Pin, in this order:

-   `.python-version`
-   `runtime.txt` (`python-3.12` is fine)
-   `requires-python` in `pyproject.toml` (a range picks the highest matching published version)

### Install and build

-   `poetry.lock`: Poetry, `poetry install --no-dev`
-   `Pipfile.lock`: Pipenv, `pipenv install --deploy --system`
-   `requirements.txt`: `pip install -r requirements.txt`
-   `pyproject.toml` with `[tool.poetry]` and no lockfile: Poetry
-   Otherwise: `pip install .`

Django apps (`manage.py` plus a Django dependency) run `collectstatic --noinput`. A failure there is logged and does not fail the build.

Launch sets `PYTHONUNBUFFERED=1`. Django also gets `DJANGO_ENV=production` and, when a `*/wsgi.py` file exists, `DJANGO_SETTINGS_MODULE`.

### Start command

-   **Django**: `gunicorn <dir>.wsgi --bind 0.0.0.0:$PORT --workers 3`
-   **FastAPI / Starlette**: `uvicorn main:app --host 0.0.0.0 --port $PORT` (or `app:app` if that file holds the app)
-   **Flask**: Gunicorn on `app:app`, `application:app`, or `wsgi:app`
-   Otherwise `python app.py` or `python main.py`, or a simple HTTP server

Put `gunicorn` or `uvicorn` in your dependencies if you rely on those defaults. Override with a Procfile. Listen on `PORT`.

---

Source: https://www.nodion.com/docs/php

# PHP

## Detected from composer.json. Served with FrankenPHP.

See [Buildpacks](https://www.nodion.com/docs/buildpacks) for how detection and version policy work. A tree that also has `package.json` gets [Node.js](https://www.nodion.com/docs/nodejs) in the same build (Laravel + Vite).

### Detects

`composer.json` in the base directory.

### Versions

Default is PHP 8.3. Published lines as of September 2026: 8.2-8.5. You get the latest patch of the requested minor.

Pin, in this order:

-   `.php-version`
-   `require.php` in `composer.json` (a range picks the highest matching published version)

Composer itself is a build tool. You do not pin it.

### Install and build

`composer install --no-dev --optimize-autoloader`. Laravel (`artisan`) then caches config, routes, views, and events when those Artisan commands exist. Symfony (`bin/console` plus `symfony.lock`) runs `cache:warmup --env=prod`.

Launch defaults: Laravel `APP_ENV=production`, `LOG_CHANNEL=stderr`, `APP_DEBUG=false`. Symfony `APP_ENV=prod`, `APP_DEBUG=0`.

### Start command

Document root is `public/`, or `web/`, or the app root.

-   Laravel Octane (lockfile lists `laravel/octane`): `php artisan octane:frankenphp --port=$PORT --host=0.0.0.0`
-   Otherwise: `frankenphp php-server --listen :$PORT --root <docroot>`

Override with a Procfile. Listen on `PORT`.

---

Source: https://www.nodion.com/docs/ruby

# Ruby

## Detected from a Gemfile. Bundler installs gems without development and test groups.

See [Buildpacks](https://www.nodion.com/docs/buildpacks) for how detection and version policy work. A tree that also has `package.json` gets [Node.js](https://www.nodion.com/docs/nodejs) in the same build (Rails with a JS pipeline).

### Detects

`Gemfile` in the base directory.

### Versions

Default is Ruby 3.4. Published lines as of September 2026: 3.3, 3.4, 4.0. You get the latest patch of the requested minor.

Pin, in this order:

-   `.ruby-version` (a `ruby-` prefix is stripped)
-   A `ruby "3.4.10"` line in the Gemfile (full `x.y.z`)

Bundler comes from the `BUNDLED WITH` stanza in `Gemfile.lock`, or 2.5.6 if that stanza is missing.

### Install and build

`bundle install` with `BUNDLE_WITHOUT=development:test` and deployment mode. Rails apps (`config/environment.rb`) run `rake assets:precompile` when that task exists. The precompile uses `RAILS_ENV=production` and `SECRET_KEY_BASE_DUMMY=1`.

Launch defaults include `RAILS_ENV` and `RACK_ENV` as production, logs to stdout, and `RAILS_SERVE_STATIC_FILES=enabled`.

### Start command

-   `config/puma.rb`: `bundle exec puma -C config/puma.rb`
-   `config.ru`: `bundle exec rackup config.ru -p $PORT` (5000 if `PORT` is unset)
-   Otherwise: `bundle exec ruby app.rb`

Make Puma or Rack listen on `PORT`. Override with a Procfile.

---

Source: https://www.nodion.com/docs/go

# Go

## Detected from go.mod. The newest published toolchain compiles the app.

See [Buildpacks](https://www.nodion.com/docs/buildpacks) for how detection and version policy work.

### Detects

`go.mod` in the base directory.

### Versions

Default is Go 1.26. Published toolchains as of September 2026 include 1.25-1.27. Go on Nodion always uses the newest published toolchain. An older `go` line in `go.mod` still builds.

The requested version is read from, in this order:

-   `.go-version`
-   The `go` directive in `go.mod`

The toolchain itself is not shipped in the run image. Only your binary is.

### Install and build

`go mod download` when `go.sum` exists. Then:

-   Each subdirectory of `cmd/` that contains `.go` files is built as its own binary.
-   If none, `go build` of `.` produces a binary named `app`.

Default `CGO_ENABLED=0` and `-ldflags=-s -w`. Override with env `CGO_ENABLED` and `GOFLAGS_LDFLAGS`. Native libraries you need at compile time go in an Aptfile or `project.toml`.

Gin apps get `GIN_MODE=release` when that module is in `go.sum`.

### Start command

Default `web` is the binary named `server`, `api`, `web`, or `app` if one of those was built, otherwise the first. Extra `cmd/` binaries become extra process types. Override with a Procfile. Listen on `PORT`.

---

Source: https://www.nodion.com/docs/rust

# Rust

## Detected from Cargo.toml. The newest published toolchain compiles the release binary.

See [Buildpacks](https://www.nodion.com/docs/buildpacks) for how detection and version policy work.

### Detects

`Cargo.toml` in the base directory.

### Versions

Default is Rust 1.96. Published toolchains as of September 2026 include 1.95-1.98. Rust on Nodion always uses the newest published toolchain. An older `rust-version` still builds.

The requested version is read from, in this order:

-   `rust-toolchain.toml` `channel` (numeric channels only; `stable` / `nightly` fall through)
-   `rust-toolchain`
-   `rust-version` in `Cargo.toml`

The toolchain is not shipped in the run image. Only your binaries are.

### Install and build

`cargo build --release`. With a `Cargo.lock`, the build is `--locked`.

### Start command

Default `web` is the binary that matches the Cargo package name, then `server`, `api`, `web`, or `app`, otherwise the first executable in `target/release`. Extra binaries become extra process types. Override with a Procfile. Listen on `PORT`.

---

Source: https://www.nodion.com/docs/java

# Java

## Detected from Maven or Gradle files. Builds with a wrapper when you commit one.

See [Buildpacks](https://www.nodion.com/docs/buildpacks) for how detection and version policy work.

### Detects

`pom.xml` (or polyglot `pom.*`), `build.gradle`, `build.gradle.kts`, `settings.gradle`, `settings.gradle.kts`, `mvnw`, or `gradlew`.

### Versions

Default is Java 21. Published lines as of September 2026: 11, 17, 21, 25, 26. You get the latest patch of the requested line. The build uses an Eclipse Temurin JDK. The run image uses the matching JRE.

Pin in `system.properties`:

```
java.runtime.version=21
```

Forms like `21`, `21.0.12`, or `temurin-21` work. Java 8 is not supported.

### Install and build

-   `gradlew`: `./gradlew build -x test --no-daemon`
-   `mvnw`: `./mvnw -B -DskipTests clean package`
-   A Maven POM without a wrapper: Nodion’s Maven, same goals

A Gradle project without `gradlew` fails. Commit the wrapper.

Launch sets `JAVA_HOME` to the JRE and defaults `JAVA_TOOL_OPTIONS` to `-XX:MaxRAMPercentage=80.0`. Override that env if you need different heap behavior.

### Start command

`java -Dserver.port=$PORT $JAVA_OPTS -jar <jar>`. The jar is the largest file in `target/` or `build/libs/`, ignoring `-plain`, `-sources`, and `-javadoc` jars. If none is found, add a Procfile. Listen on `PORT`.

---

Source: https://www.nodion.com/docs/dotnet

# .NET

## Detected from a project or solution file. Published framework-dependent.

See [Buildpacks](https://www.nodion.com/docs/buildpacks) for how detection and version policy work.

### Detects

A `*.csproj`, `*.fsproj`, or `*.sln` at the base directory, or `global.json`.

### Versions

Default is .NET 10. Published lines as of September 2026: 8, 9, 10. You get the latest patch of the requested line. The build uses the SDK. The run image uses the matching ASP.NET Core runtime.

Pin, in this order:

-   `sdk.version` in `global.json`
-   The first `TargetFramework` / `TargetFrameworks` `netN.0` in a root project file

### Install and build

`dotnet publish -c Release` of one project. If the base directory has more than one `.csproj` / `.fsproj`, set env `DOTNET_PROJECT` to the file to publish. Zero project files at the root is the same: set `DOTNET_PROJECT` to the path.

Launch sets `DOTNET_ROOT` and `DOTNET_CLI_TELEMETRY_OPTOUT=1`.

### Start command

`ASPNETCORE_URLS=http://0.0.0.0:$PORT dotnet <app>.dll`. Override with a Procfile. Listen on `PORT`.

---

Source: https://www.nodion.com/docs/elixir

# Elixir

## Detected from mix.exs. Builds a Mix release. Erlang and Elixir stay out of the run image.

See [Buildpacks](https://www.nodion.com/docs/buildpacks) for how detection and version policy work.

### Detects

`mix.exs` in the base directory.

### Versions

Default is Elixir 1.20 on Erlang/OTP 28. Published Elixir lines as of September 2026: 1.15-1.20. Published OTP lines: 26-29. You get the latest patch of the requested line.

Pin Elixir with, in this order:

-   An `elixir` entry in `.tool-versions` (asdf style `1.18.2-otp-27` uses the part before the hyphen)
-   `.elixir-version`

The `elixir:` requirement in `mix.exs` is a range, not a pin. Nodion does not use it. An old `~> 1.17` still runs on a newer default.

Pin Erlang with an `erlang` entry in `.tool-versions`.

### Install and build

`mix local.hex`, `mix local.rebar`, `mix deps.get --only prod`. If `mix assets.deploy` exists, that runs next. Then `mix release --overwrite`.

The app must be set up for Mix releases. The release bundles ERTS, so the run image is the release only.

Launch sets `PHX_SERVER=true` so a Phoenix endpoint starts. Harmless on non-Phoenix releases.

### Start command

`<release>/bin/<app> start`, preferring the OTP app name from `mix.exs`. Override with a Procfile. Listen on `PORT` (Phoenix reads `PORT` when the release is generated that way).

---

Source: https://www.nodion.com/docs/api

# API

## HTTP API for projects, apps, and the rest of the platform.

Every resource you see in the dashboard has an HTTP endpoint. Use this from the [CLI](https://www.nodion.com/docs/cli), CI, scripts, or any client that can send JSON.

-   Base: `https://api.nodion.com`
-   Interactive docs: [api.nodion.com/v2/docs](https://api.nodion.com/v2/docs)
-   OpenAPI: [api.nodion.com/v2/openapi.yaml](https://api.nodion.com/v2/openapi.yaml)

### Authenticate

Send a bearer token on every request:

httpAuthorization: Bearer nodion\_…

There are two kinds of token:

-   **Personal API keys** (`nodion_…`) act as you. You choose scopes and can limit the key to specific projects. Create them under [Account → Security](https://app.nodion.com/account/security). The token is shown once.
-   **Project keys** (`nodion_proj_…`) belong to one project, not a person, so CI keeps working when someone leaves. Create them on the project’s **API keys** tab.

Scopes on a personal key:

-   `read`: list and fetch resources
-   `write`: create, update, and delete
-   `deploy`: trigger deployments
-   `env:read` / `env:write`: environment variable values
-   `logs:read`: application logs

Reads need `read`, writes need `write`, unless an operation asks for a tighter scope (for example `deploy`). Project keys are not scoped. They can do anything in that project. Billing and 2FA stay in the dashboard; API keys cannot call those.

### Pick a project

Nested routes look like `/v2/projects/{id}/…`. If you work in one project, use the short path and send the project id as a header:

httpX-Nodion-Project: prj\_…

### First request

bashcurl https://api.nodion.com/v2/applications \\
  -H "Authorization: Bearer $NODION\_TOKEN" \\
  -H "X-Nodion-Project: $NODION\_PROJECT"

Trigger a deploy (needs the `deploy` scope on a personal key):

bashcurl -X POST https://api.nodion.com/v2/applications/$APP\_ID/deployments \\
  -H "Authorization: Bearer $NODION\_TOKEN"

### Lists, errors, and limits

Collection responses look like `{ "data": [ … ], "next_cursor": null }`. Pass `?limit=` and the previous `next_cursor` as `?cursor=` to page.

Errors use [RFC 9457](https://www.rfc-editor.org/rfc/rfc9457) (`application/problem+json`) with a stable `code` and a `request_id`. Quote that id to support. The public catalog is [`GET /v2/errors`](https://api.nodion.com/v2/errors).

Key-authenticated calls are rate limited per account. Responses include `RateLimit-Limit`, `RateLimit-Remaining`, and `RateLimit-Reset`. A `429` also sends `Retry-After`. Every response has `X-Request-Id`.

For request bodies and a try-it console, use the [interactive docs](https://api.nodion.com/v2/docs). The pages below are the same endpoints, in this site’s look.

### Endpoints

Generated from the public OpenAPI document. 269 operations, grouped as in the spec.

[#### Identity

Validate a token, discover reachable projects, and list error codes. 4 endpoints.](https://www.nodion.com/docs/api/identity)[#### Projects

Projects, the container every other resource belongs to. 7 endpoints.](https://www.nodion.com/docs/api/projects)[#### Applications

Deployable applications and their settings, logs and metrics. 18 endpoints.](https://www.nodion.com/docs/api/applications)[#### Previews

Ephemeral preview environments for a branch or pull request. 5 endpoints.](https://www.nodion.com/docs/api/previews)[#### Environment

Application environment variables. 3 endpoints.](https://www.nodion.com/docs/api/environment)[#### Deployments

Build-and-run deployments and auto-deploy. 7 endpoints.](https://www.nodion.com/docs/api/deployments)[#### Processes

An application's process types and their scaling. 6 endpoints.](https://www.nodion.com/docs/api/processes)[#### Cron jobs

Scheduled one-shot commands on an application's active release. 9 endpoints.](https://www.nodion.com/docs/api/cron-jobs)[#### Domains

Custom domains for applications. 8 endpoints.](https://www.nodion.com/docs/api/domains)[#### Databases

Managed databases, replicas, endpoints and attachments. 43 endpoints.](https://www.nodion.com/docs/api/databases)[#### Volumes

Persistent storage volumes. 8 endpoints.](https://www.nodion.com/docs/api/volumes)[#### Object storage

S3 buckets and access keys. 27 endpoints.](https://www.nodion.com/docs/api/object-storage)[#### DNS

Authoritative DNS zones and records. 23 endpoints.](https://www.nodion.com/docs/api/dns)[#### CDN

CDN zones, custom domains and cache purging. 16 endpoints.](https://www.nodion.com/docs/api/cdn)[#### Email

Email sending domains and relay zones. 21 endpoints.](https://www.nodion.com/docs/api/email)[#### Observers

Uptime and metric monitors with notifiers. 16 endpoints.](https://www.nodion.com/docs/api/observers)[#### Integrations

Git provider integrations and shared repositories. 25 endpoints.](https://www.nodion.com/docs/api/integrations)[#### Registries

Nodion container registries and per-project robot accounts. 11 endpoints.](https://www.nodion.com/docs/api/registries)[#### AI

Model catalog and per-project usage. Inference itself is the separate OpenAI-compatible API. 3 endpoints.](https://www.nodion.com/docs/api/ai)[#### Reference

Read-only catalogs (regions, packages, engines, presets). 9 endpoints.](https://www.nodion.com/docs/api/reference)

---

Source: https://www.nodion.com/docs/cli

# CLI

## Manage apps from the terminal.

The `nodion` CLI talks to the same v2 HTTP API as the dashboard. Use it yourself, from CI, or from an agent that can run shell commands.

### Install

macOS and Linux:

bashcurl -fsSL https://cli.nodion.net/install.sh | bash

Windows (PowerShell):

powershellirm https://cli.nodion.net/install.ps1 | iex

The installer puts `nodion` in `~/.local/bin` on Unix or `%LocalAppData%\Programs\nodion` on Windows, verifies a signed release manifest, and will replace a Classic `nodion` already on your `PATH`. Override the directory with `NODION_INSTALL_DIR`. Rollback to Classic: `curl -fsSL https://cli.nodion.com/install.sh | bash`.

Windows verification needs Python 3 (`python3`, `python`, or `py -3`).

### Sign in

`nodion login` starts a browser device-code flow. If you have no account yet, the same page signs you up (GitHub, Google, or email). Confirm the code. When email confirmation is required, open the mail, return to the page, and approve again. The CLI stores a personal API key in `~/.config/nodion/config.yml` (mode `0600`). Agents should follow [auth.md](https://www.nodion.com/auth.md) and must not print the token.

bashnodion login
nodion whoami

Keys must start with `nodion_` or `nodion_proj_`. Older `nk_` keys are rejected. Create a personal key under [Account → Security](https://app.nodion.com/account/security) if you want to skip the browser flow.

For CI, skip `login` and pass a token. It is never written to disk:

bashexport NODION\_API\_TOKEN=nodion\_…
# or a project key that survives when someone leaves
export NODION\_API\_TOKEN=nodion\_proj\_…

`nodion logout` revokes the personal key from `login` and deletes the local config. It does not revoke project keys or `NODION_API_TOKEN`.

### Project and app

Most commands need a project and an application. Resolution order:

1.  `--project` / `--app`
2.  `NODION_PROJECT` / `NODION_APP_ID`
3.  `nodion.yml`, searched from the current directory upward
4.  Account default from the dashboard picker (or `nodion projects use`)

bashnodion projects list
nodion projects use prj\_…
nodion link

`nodion link` writes a `nodion.yml` in this directory. The file is safe to commit. It only stores ids:

yamlproject: prj\_…
app: app\_…

### Quickstart

bashnodion login
nodion projects use prj\_…
nodion apps list
nodion link
nodion deploy --wait

Create, delete, deploy, and scale ask for confirmation. In CI pass `--yes`.

### Common commands

bash\# Applications
nodion apps list
nodion apps get
nodion apps create --name my-api --region REGION --strategy dockerfile
nodion apps delete APP

# Deployments
nodion deploy --wait
nodion deployments list
nodion deployments get DEPLOYMENT

# Environment
nodion env list
nodion env set FOO=bar
nodion env set SECRET=value --secret
nodion env unset FOO

# Runtime
nodion logs --container web --tail 200
nodion processes list
nodion processes scale PROCESS --replicas 2

# Domains
nodion domains list
nodion domains add www.example.com
nodion domains verify DOMAIN

`apps create` strategies are `dockerfile`, `buildpacks`, and `prebuilt_image`. Git is a source, not a strategy: pass `--integration`, `--repo`, and `--branch` when the app should deploy from a repository. See [Applications](https://www.nodion.com/docs/applications).

`nodion logs` needs `--container` (the process name, such as `web`).

### Version and updates

bashnodion version
nodion update

`nodion update` fetches the signed manifest from `cli.nodion.net`, checks the digest, and replaces this binary in place. It refuses package-managed or symlink installs (Homebrew, `/usr/bin`). Use `--force` only to downgrade. There is no silent auto-replace.

On an interactive TTY the CLI may print one line pointing at `nodion update` when a newer release exists (at most once a day, fail-open, no credentials). Disable with `NODION_NO_UPDATE_CHECK=1`. The check is off in CI and whenever `NODION_API_TOKEN` is set.

### Other commands

bashnodion databases list
nodion volumes list
nodion buckets list
nodion dns list
nodion cdn list
nodion email-domains list
nodion observers list
nodion regions

Same flags as the app commands. Sandboxes are not in the CLI yet.

### JSON and flags

Every list and get command accepts `--output json`:

bashnodion apps list --output json

Global flags:

-   `--api URL`: API origin (default `https://app.nodion.com`)
-   `--token TOKEN`: API key for this invocation only
-   `--project ID` / `--app ID`
-   `--output table|json`
-   `--yes`: skip confirmation

Environment:

-   `NODION_API`: same as `--api`
-   `NODION_API_TOKEN`: overrides the config file, never persisted
-   `NODION_PROJECT` / `NODION_APP_ID`
-   `NODION_NO_UPDATE_CHECK=1`: skip the TTY version hint

The CLI sends `X-Nodion-Project` like the [HTTP API](https://www.nodion.com/docs/api). Interactive request bodies live in the [API console](https://api.nodion.com/v2/docs).

---

Source: https://www.nodion.com/docs/mcp

# MCP

## Drive Nodion from your coding agent.

Nodion hosts a remote [Model Context Protocol](https://modelcontextprotocol.io) server. Your agent uses the same account you use in the dashboard: create a project, deploy an app, set env vars, read logs, without a local daemon.

-   Server: `https://mcp.nodion.net/mcp`
-   One-click setup for Cursor, Claude Code, and Claude Desktop: [Connect Nodion to your agent](https://www.nodion.com/connect)

### Authenticate

New account? Tell the agent to follow [auth.md](https://www.nodion.com/auth.md) or run `nodion login`. You approve in the browser. The CLI stores a personal key in `~/.config/nodion/config.yml` — do not paste that token into chat.

For MCP, create a personal key under [Account → Security](https://app.nodion.com/account/security) (shown once) and set `Authorization: Bearer nodion_…`. Do not copy the CLI config file into chat.

### OpenCode

OpenCode has its own config format. Add Nodion to `opencode.json`:

json{
  "mcp": {
    "nodion": {
      "type": "remote",
      "url": "https://mcp.nodion.net/mcp",
      "headers": {
        "Authorization": "Bearer nodion\_…"
      }
    }
  }
}

### Any other client

Windsurf, Zed, VS Code Copilot, and custom agents can use the same URL. A typical config:

json{
  "mcpServers": {
    "nodion": {
      "url": "https://mcp.nodion.net/mcp",
      "headers": {
        "Authorization": "Bearer nodion\_…"
      }
    }
  }
}

### What the agent can do

Once connected, ask in plain language. Typical work: create a project, deploy an app from the current repo or a [one-click preset](https://www.nodion.com/docs/presets) (Twenty, n8n, Plausible, …), attach a database, set environment variables, read logs, and check that a release is live. Write actions ask you to confirm before they run.

A **local** agent with a shell and network (Cursor or Claude Code, API key from Account → Security) can deploy a folder that is not a Git repository: `apps.create` with `source_kind=managed_git` (the create response has no push URL or password), then the agent calls `apps.git_remote` itself (the dashboard does not show the password; each call issues a new one and revokes the previous one), then `git push` with GIT\_ASKPASS (do not put the password in the URL, `.git/config`, argv, shell history, logs, or chat), then `deploy`. For a catalog app, the agent calls `presets.list` (pass `category` or `q` when the user names a kind of app), `presets.get`, then `apps.create` with `preset_key` (for example `twenty`). After that create, do not call `deploy`: the first release starts when attached databases are ready. Poll `apps.get` or `deployments.list` and report `url`. Hosted ChatGPT/OAuth does not get `apps.git_remote` (there is no connector or dashboard toggle for it). Those clients can still ship HTML/CSS/JS from the chat: `apps.create` with `source_kind=managed_git` and `deployment_strategy=buildpacks`, then `apps.git_files`, then `deploy`. A local folder on disk still needs Cursor or Claude Code with a write key. Connected GitHub remains an option when the user already has a repo.

### ChatGPT, Codex, and Claude Desktop

ChatGPT, Codex, and Claude Desktop (claude.ai, mobile, Cowork) use OAuth, not an API key. Sign in or create an account on the Nodion authorize page, bind one or more projects, then deploy a catalog preset with `preset_key`, HTML/CSS/JS from the chat with `apps.git_files`, or a Git repository you have already connected. Secrets stay in the dashboard; the connection does not collect passwords or environment values in chat. Hosted Claude connectors are brokered by Anthropic.

Cursor and Claude Code still need a key from Account → Security. ChatGPT, Codex, and Claude Desktop open an account on the authorize page.

---

Source: https://www.nodion.com/docs/api/identity

# Identity

## Validate a token, discover reachable projects, and list error codes.

Base `https://api.nodion.com`. Short paths need `X-Nodion-Project` unless the path already has `/v2/projects/{id}`. Request bodies are in the [interactive docs](https://api.nodion.com/v2/docs).

GET `/v2/errors`

List error codes

Public catalog of problem \`code\` values. No authentication.

No authentication [Interactive docs](https://api.nodion.com/v2/docs#listErrorCodes)

---

Source: https://www.nodion.com/docs/api/projects

# Projects

## Projects, the container every other resource belongs to.

Base `https://api.nodion.com`. Short paths need `X-Nodion-Project` unless the path already has `/v2/projects/{id}`. Request bodies are in the [interactive docs](https://api.nodion.com/v2/docs).

GET `/v2/projects`

List projects

Scope `read` [Interactive docs](https://api.nodion.com/v2/docs#listProjects)

---

Source: https://www.nodion.com/docs/api/applications

# Applications

## Deployable applications and their settings, logs and metrics.

Base `https://api.nodion.com`. Short paths need `X-Nodion-Project` unless the path already has `/v2/projects/{id}`. Request bodies are in the [interactive docs](https://api.nodion.com/v2/docs).

GET `/v2/applications`

List applications in the current project

Scope `read` [Interactive docs](https://api.nodion.com/v2/docs#listApplications)

---

Source: https://www.nodion.com/docs/api/previews

# Previews

## Ephemeral preview environments for a branch or pull request.

Base `https://api.nodion.com`. Short paths need `X-Nodion-Project` unless the path already has `/v2/projects/{id}`. Request bodies are in the [interactive docs](https://api.nodion.com/v2/docs).

GET `/v2/applications/{id}/previews`

List preview environments for an application

Scope `read` [Interactive docs](https://api.nodion.com/v2/docs#listPreviews)

---

Source: https://www.nodion.com/docs/api/environment

# Environment

## Application environment variables.

Base `https://api.nodion.com`. Short paths need `X-Nodion-Project` unless the path already has `/v2/projects/{id}`. Request bodies are in the [interactive docs](https://api.nodion.com/v2/docs).

GET `/v2/applications/{id}/env`

List environment variables

Scope `env:read` [Interactive docs](https://api.nodion.com/v2/docs#listEnvVars)

---

Source: https://www.nodion.com/docs/api/deployments

# Deployments

## Build-and-run deployments and auto-deploy.

Base `https://api.nodion.com`. Short paths need `X-Nodion-Project` unless the path already has `/v2/projects/{id}`. Request bodies are in the [interactive docs](https://api.nodion.com/v2/docs).

GET `/v2/applications/{id}/deployments`

List deployments

Scope `read` [Interactive docs](https://api.nodion.com/v2/docs#listDeployments)

---

Source: https://www.nodion.com/docs/api/processes

# Processes

## An application's process types and their scaling.

Base `https://api.nodion.com`. Short paths need `X-Nodion-Project` unless the path already has `/v2/projects/{id}`. Request bodies are in the [interactive docs](https://api.nodion.com/v2/docs).

GET `/v2/applications/{id}/processes`

List processes

Scope `read` [Interactive docs](https://api.nodion.com/v2/docs#listProcesses)

---

Source: https://www.nodion.com/docs/api/cron-jobs

# Cron jobs

## Scheduled one-shot commands on an application's active release.

Base `https://api.nodion.com`. Short paths need `X-Nodion-Project` unless the path already has `/v2/projects/{id}`. Request bodies are in the [interactive docs](https://api.nodion.com/v2/docs).

GET `/v2/applications/{id}/cron_jobs`

List cron jobs

Scope `read` [Interactive docs](https://api.nodion.com/v2/docs#listCronJobs)

---

Source: https://www.nodion.com/docs/api/domains

# Domains

## Custom domains for applications.

Base `https://api.nodion.com`. Short paths need `X-Nodion-Project` unless the path already has `/v2/projects/{id}`. Request bodies are in the [interactive docs](https://api.nodion.com/v2/docs).

PUT `/v2/applications/{id}/default_hostnames`

Turn public routing of Nodion default hostnames on or off

Scope `write` [Interactive docs](https://api.nodion.com/v2/docs#setDefaultHostnames)

---

Source: https://www.nodion.com/docs/api/databases

# Databases

## Managed databases, replicas, endpoints and attachments.

Base `https://api.nodion.com`. Short paths need `X-Nodion-Project` unless the path already has `/v2/projects/{id}`. Request bodies are in the [interactive docs](https://api.nodion.com/v2/docs).

GET `/v2/databases`

List databases in the current project

Scope `read` [Interactive docs](https://api.nodion.com/v2/docs#listDatabases)

---

Source: https://www.nodion.com/docs/api/volumes

# Volumes

## Persistent storage volumes.

Base `https://api.nodion.com`. Short paths need `X-Nodion-Project` unless the path already has `/v2/projects/{id}`. Request bodies are in the [interactive docs](https://api.nodion.com/v2/docs).

GET `/v2/volume_size_limits`

List allowed volume size limits

Scope `read` [Interactive docs](https://api.nodion.com/v2/docs#listVolumeSizeLimits)

---

Source: https://www.nodion.com/docs/api/object-storage

# Object storage

## S3 buckets and access keys.

Base `https://api.nodion.com`. Short paths need `X-Nodion-Project` unless the path already has `/v2/projects/{id}`. Request bodies are in the [interactive docs](https://api.nodion.com/v2/docs).

GET `/v2/buckets`

List buckets in the current project

Scope `read` [Interactive docs](https://api.nodion.com/v2/docs#listBuckets)

---

Source: https://www.nodion.com/docs/api/dns

# DNS

## Authoritative DNS zones and records.

Base `https://api.nodion.com`. Short paths need `X-Nodion-Project` unless the path already has `/v2/projects/{id}`. Request bodies are in the [interactive docs](https://api.nodion.com/v2/docs).

GET `/v2/dns_zones`

List DNS zones in the current project

Scope `read` [Interactive docs](https://api.nodion.com/v2/docs#listZones)

---

Source: https://www.nodion.com/docs/api/cdn

# CDN

## CDN zones, custom domains and cache purging.

Base `https://api.nodion.com`. Short paths need `X-Nodion-Project` unless the path already has `/v2/projects/{id}`. Request bodies are in the [interactive docs](https://api.nodion.com/v2/docs).

GET `/v2/cdn_zones`

List CDN zones in the current project

Scope `read` [Interactive docs](https://api.nodion.com/v2/docs#listCdnZones)

---

Source: https://www.nodion.com/docs/api/email

# Email

## Email sending domains and relay zones.

Base `https://api.nodion.com`. Short paths need `X-Nodion-Project` unless the path already has `/v2/projects/{id}`. Request bodies are in the [interactive docs](https://api.nodion.com/v2/docs).

GET `/v2/email_domains`

List email domains in the current project

Scope `read` [Interactive docs](https://api.nodion.com/v2/docs#listEmailDomains)

---

Source: https://www.nodion.com/docs/api/observers

# Observers

## Uptime and metric monitors with notifiers.

Base `https://api.nodion.com`. Short paths need `X-Nodion-Project` unless the path already has `/v2/projects/{id}`. Request bodies are in the [interactive docs](https://api.nodion.com/v2/docs).

GET `/v2/observer_price`

Get the monthly observer list price for the create form

Scope `read` [Interactive docs](https://api.nodion.com/v2/docs#getObserverPrice)

---

Source: https://www.nodion.com/docs/api/integrations

# Integrations

## Git provider integrations and shared repositories.

Base `https://api.nodion.com`. Short paths need `X-Nodion-Project` unless the path already has `/v2/projects/{id}`. Request bodies are in the [interactive docs](https://api.nodion.com/v2/docs).

GET `/v2/repositories`

List repositories shared into the current project

Scope `read` [Interactive docs](https://api.nodion.com/v2/docs#listRepositories)

---

Source: https://www.nodion.com/docs/api/registries

# Registries

## Nodion container registries and per-project robot accounts.

Base `https://api.nodion.com`. Short paths need `X-Nodion-Project` unless the path already has `/v2/projects/{id}`. Request bodies are in the [interactive docs](https://api.nodion.com/v2/docs).

GET `/v2/registries/nodion`

List Nodion container registries with the caller's projects and robot state

Scope `read` [Interactive docs](https://api.nodion.com/v2/docs#listNodionRegistries)

---

Source: https://www.nodion.com/docs/api/ai

# AI

## Model catalog and per-project usage. Inference itself is the separate OpenAI-compatible API.

Base `https://api.nodion.com`. Short paths need `X-Nodion-Project` unless the path already has `/v2/projects/{id}`. Request bodies are in the [interactive docs](https://api.nodion.com/v2/docs).

GET `/v2/ai/models`

List the public AI model catalog

Scope `read` [Interactive docs](https://api.nodion.com/v2/docs#listAIModels)

---

Source: https://www.nodion.com/docs/api/reference

# Reference

## Read-only catalogs (regions, packages, engines, presets).

Base `https://api.nodion.com`. Short paths need `X-Nodion-Project` unless the path already has `/v2/projects/{id}`. Request bodies are in the [interactive docs](https://api.nodion.com/v2/docs).

GET `/v2/regions`

List available regions

Scope `read` [Interactive docs](https://api.nodion.com/v2/docs#listRegions)