Deploy Langflow

Langflow runs on Sevalla as an application from its official Docker image, langflowai/langflow: the web process serves the visual editor and the API that runs your flows, and a Sevalla PostgreSQL database keeps users, flows, API keys and global variables. Sign-in is required, the admin account comes from environment variables, and your model provider’s API key becomes an encrypted global variable, so no secret sits in a flow.

At a glance


Source	The `langflowai/langflow:1.13.0` Docker image
Start command	The image’s own, `langflow run`
Port	`8080`, from `LANGFLOW_PORT` (Langflow’s default is `7860`)
Processes	Web process
Services	PostgreSQL 18 over an internal connection
Disk	None. Add one only to keep uploaded files
Health check	`GET /health_check` returns `200` once Langflow can reach its database (readiness probe)
Size	M1 (0.5 vCPU, 2 GB). S1 (1 GB) is too small: Langflow is stopped with exit code `137` (out of memory) while it starts

Environment variables

Variable	Required	Available during	Secret	Value
`LANGFLOW_DATABASE_URL`	Yes	Runtime	Yes	`DB_URL` from the internal connection, renamed, with `postgres://` changed to `postgresql://`
`LANGFLOW_SECRET_KEY`	Yes	Runtime	Yes	Generate with `python3 -c "import secrets; print(secrets.token_urlsafe(32))"`
`LANGFLOW_SUPERUSER`	Yes	Runtime	No	The admin’s username, for example `admin`
`LANGFLOW_SUPERUSER_PASSWORD`	Yes	Runtime	Yes	A strong password
`LANGFLOW_AUTO_LOGIN`	Yes	Runtime	No	`false`
`LANGFLOW_PORT`	Yes	Runtime	No	`8080`, the web process port
`LANGFLOW_ENABLE_SIGNUP`	Yes	Runtime	No	`false`
`LANGFLOW_CUSTOM_COMPONENT_ADMIN_ONLY`	Yes	Runtime	No	`true`
`ANTHROPIC_API_KEY`	For Claude models	Runtime	Yes	Your Anthropic API key. Langflow stores it as a global variable

An application from a Docker image has no build, so every variable is a runtime variable. Set the environment variables explains each one.

Before you begin

A Sevalla company with a payment method: Langflow needs the M1 size or larger.
Python 3 on your computer, to generate the secret key (python3 --version).
An API key from your model provider. This guide uses Anthropic.

Create the database

Open the create form

In the sidebar, click Databases, then click Create database.

Choose PostgreSQL

Click PostgreSQL and choose the newest version. This guide was tested with PostgreSQL 18.

Name and place it

Enter the Display name langflow-db, choose the Data center where Langflow will run, and choose the Size. This guide was tested on DB1.

Create it

Click Create database and wait for the status Ready.

Create the application

Choose the image

In the sidebar, click Applications, then click Create > Application. Under Source, click Docker image and enter langflowai/langflow:1.13.0 in Docker image. Keep the Registry credential at None (public image).

Name, place and size it

Enter the Name langflow, choose the database’s Data center, and choose the Size M1.

Create it without deploying

Click Create application. The application opens with the status Not deployed yet.

The tag pins one Langflow release: 1.13.0 is the current one. The image is 785 MB to download and runs Langflow on Python 3.14 as an unprivileged user. Langflow migrates its database when a new version starts, so pin a version and upgrade on purpose.

Connect the database

Open the database's networking

In the sidebar, click Databases, then click langflow-db. Click the Networking tab.

Add the connection

Under Private networking, in Connected applications, click Add internal connection, and choose the langflow Application.

Keep only the URL

Turn on Add environment variables to the application. Change the key DB_URL to LANGFLOW_DATABASE_URL, and in its value change postgres:// at the start to postgresql://. Click the trash icon next to the other five variables.

Save

Click Add internal connection.

Langflow checks the URL with SQLAlchemy, which knows the scheme postgresql:// but not postgres://. With the URL as the dashboard writes it, Langflow stops at start with Invalid database_url provided: 'postgres://***:***@...'.

Set the environment variables

Generate the secret key on your computer, and store it in your password manager:

python3 -c "import secrets; print(secrets.token_urlsafe(32))"

On the application’s Environment variables tab, click Add environment variables, paste these lines into the first key field, replace the secret key, the password and the Anthropic key with yours, and click Add environment variables:

.env

LANGFLOW_SECRET_KEY=yHkq3cP0Wq2s5Jr7Vv9mXzL1bN4tD6fG8hK0aS2eR4u
LANGFLOW_SUPERUSER=admin
LANGFLOW_SUPERUSER_PASSWORD=choose-a-long-password
LANGFLOW_AUTO_LOGIN=false
LANGFLOW_PORT=8080
LANGFLOW_ENABLE_SIGNUP=false
LANGFLOW_CUSTOM_COMPONENT_ADMIN_ONLY=true
ANTHROPIC_API_KEY=sk-ant-your-key

Variable	Why Langflow needs it on Sevalla
`LANGFLOW_SECRET_KEY`	Encrypts the global variables and API keys Langflow stores, and signs sign-in tokens. Without it, Langflow generates a key into its configuration folder, which the next deployment deletes. See Keep the secret key.
`LANGFLOW_SUPERUSER`, `LANGFLOW_SUPERUSER_PASSWORD`	Create the admin account at the first start.
`LANGFLOW_AUTO_LOGIN`	`false` requires everyone to sign in. The image already defaults to `false`; setting it keeps that true if a future image changes the default.
`LANGFLOW_PORT`	Langflow listens on `7860` unless told otherwise, and doesn’t read `PORT`. `8080` matches the web process port. The image already listens on all interfaces.
`LANGFLOW_ENABLE_SIGNUP`	Turns off public sign-up. Without it, anyone who finds the domain can create an account, which an admin then has to activate. With it, sign-up answers `403` with `{"detail":"Public user registration is disabled."}`.
`LANGFLOW_CUSTOM_COMPONENT_ADMIN_ONLY`	Only admins can write custom component code, which runs inside the server. Without it, Langflow logs a `SECURITY:` warning at every start: any active user could run code on the instance.
`ANTHROPIC_API_KEY`	At start, Langflow stores it as the global variable `ANTHROPIC_API_KEY`, encrypted with `LANGFLOW_SECRET_KEY`, and offers Anthropic’s models in its model lists. Use the same pattern for other providers, for example `OPENAI_API_KEY`.

Add a readiness probe

Langflow takes about 50 seconds to start. A readiness probe keeps sending requests to the running version until the new one is ready.

Open the web process

Click the Processes tab, click ⋯ on the web process, then click Update process.

Turn on the probe

Under Health checks, turn on Readiness probe, enter the Path /health_check, the Initial delay 10 and the Timeout 5. Keep the Port at 8080.

Save

Click Update process.

In the tests, every request succeeded during a deployment with the probe.

Click the Overview tab, click Deploy now, then click Deploy. The deployment pulls the image and starts the web process; there’s no build. The first start creates the tables in PostgreSQL, the admin account and the ANTHROPIC_API_KEY global variable.

Verify the deployment

On the Deployments tab, the deployment’s status is Deployed. With the API, Get deployment (getDeploymentV3) returns "status": "success".

The health check answers once Langflow can reach PostgreSQL:

curl -s https://langflow-x7k2m.sevalla.app/health_check

{"status":"ok","chat":"ok","db":"ok"}

The version endpoint answers without signing in:

curl -s https://langflow-x7k2m.sevalla.app/api/v1/version

{"version":"1.13.0","main_version":"1.13.0","package":"Langflow"}

Open the domain. Langflow shows Sign in to Langflow. Sign in with LANGFLOW_SUPERUSER and LANGFLOW_SUPERUSER_PASSWORD.

Build a flow with Claude

Start from a template

Click Create first flow (New Flow once you have flows), then click Browse more… and pick Basic Prompting. The flow has a Chat Input, a Prompt Template, a Language Model and a Chat Output.

Choose the model

In the Language Model component, open the Language Model list and choose claude-haiku-5-5, Anthropic’s fastest and cheapest current model. The template shows the first model in the list before you choose one, but saves no model: if claude-haiku-5-5 is already shown, choose another model first, then claude-haiku-5-5.

Try it

Click Playground and send a message. The answer comes from Claude.

The flow’s ID is the part of the address after /flow/, for example d1b19062-7061-451b-9259-4f42f5baadce in https://langflow-x7k2m.sevalla.app/flow/d1b19062-7061-451b-9259-4f42f5baadce/folder/.... The same screen also offers to build a flow from a description. That assistant runs on claude-sonnet-5-5 with the same Anthropic key, so it spends from your account too.

Run the flow through the API

Every request that runs a flow needs a Langflow API key in the x-api-key header. A key has the permissions of the user who created it.

Create an API key

Click your profile icon, then Settings. Click Langflow API Keys, then Add New. Enter a name, for example storefront, click Create API Key, and copy the key: Langflow shows it once.

Run the flow

Send a message to the flow’s run endpoint:

curl -s -X POST "https://langflow-x7k2m.sevalla.app/api/v1/run/$FLOW_ID" \
  -H "x-api-key: $LANGFLOW_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"input_value":"In one sentence, what is Sevalla?","input_type":"chat","output_type":"chat"}' \
  | jq -r '.outputs[0].outputs[0].results.message.text'

Sevalla is a cloud platform that lets you deploy and host web apps, databases, and static sites directly from your Git repository, so you can get your next project live quickly and with minimal setup!

The model writes the answer in its own words, so yours can differ; .outputs[0].outputs[0].results.message.sender_name is always AI, and .properties.usage in the same message holds the token counts. In the test, a run used 58 input and 186 output tokens. Without the header, the endpoint answers 403 with {"detail":"An API key must be passed as query or header"}. Add ?stream=true to the URL to receive the answer as Server-Sent Events (text/event-stream): one token event per piece of text, then an end event. Through Cloudflare and Sevalla’s proxy, the tokens of a 46-token answer arrived one by one over 1 second, the first after 0.94 s, without buffering. Store the API key in the calling application’s environment variables, never in front-end code: anyone with the key can run your flows on your model account. Set a spending limit in your model provider’s console.

Keep the secret key

LANGFLOW_SECRET_KEY must stay the same for the life of the instance.

If you change LANGFLOW_SECRET_KEY, Langflow can no longer read the global variables you created in its settings: they show no value, and the log shows API key decryption failed after retry. This may indicate a corrupted key or SECRET_KEY mismatch. Everyone is signed out. Keep a copy of the key outside Sevalla, so deleting the variable or the application doesn’t lose it.

Variables Langflow loads from environment variables, such as ANTHROPIC_API_KEY, come back at the next start. In the tests, putting the original key back made the other variables readable again.

Keep uploaded files

Flows, users, API keys and global variables are in PostgreSQL. Files you upload in Langflow (My Files, the File component) and knowledge bases are written under /app/data, the image’s home folder, which every deployment wipes: after a deployment, a file uploaded before it returns 404 with File not found. To keep them, add a disk:

Create the disk

On the application’s Disks tab, click Create disk. Pick the web process, enter the Path /app/data, pick the Size 10 GB, and click Create disk.

Deploy

Deploy the application. Langflow writes to the disk from this deployment on.

In the tests, an uploaded file was still there after the next deployment. A process with a disk runs 1 instance and stops before the new version starts (Persistent storage): during each deployment, Langflow didn’t answer for about 110 seconds.

Upgrade Langflow

Read the release notes of every version between yours and the new one on Langflow’s GitHub releases.
Back up langflow-db: on its Backups tab, create a manual backup. See Backups.
On the application’s Settings tab, in the Source section, click Update source, change the tag in Docker image, and click Update source.
Deploy. Langflow migrates the database when the new version starts.

To go back, restore the backup and set the previous tag.

Add a custom domain

To serve Langflow from your own domain, such as flows.example.com, add it on the application’s Domains tab and create the DNS records Sevalla shows; the web process must be larger than H1, which M1 is. See Custom domains.

Troubleshoot

Symptom	Cause	Fix
The domain answers `no healthy upstream`, and the process’s exit code is `137`	The web process is smaller than M1: Langflow runs out of memory while it starts	Use M1 or larger
The log shows `Invalid database_url provided: 'postgres://*:*@...'`	`LANGFLOW_DATABASE_URL` starts with `postgres://`	Change the start to `postgresql://` and deploy
A run returns `Error building Component Language Model: A model selection is required`	The flow has no saved model	Choose the model in the Language Model component again. See Build a flow with Claude
A run returns `403` with `{"detail":"An API key must be passed as query or header"}`	The request has no `x-api-key` header	Create an API key and send it in `x-api-key`
Global variables show no value, and the log shows `API key decryption failed after retry`	`LANGFLOW_SECRET_KEY` changed	Set it back to the original key and deploy
An uploaded file returns `404` after a deployment	The application has no disk	Add a disk at `/app/data`

Deploy with the API

These calls create the same deployment without the dashboard: the database, the application, the variables, the readiness probe and the first deployment. They need:

An API key that can create applications and databases, in SEVALLA_API_KEY, and your Anthropic key in ANTHROPIC_API_KEY.
curl, jq, openssl and python3.

The application comes from a public Docker image, so no Git provider needs to be connected.

Choose the location and sizes

List clusters (listClustersV3), List process resource types (listProcessResourceTypesV3) and List database resource types (listDatabaseResourceTypesV3). Pick the location by its region ID, here Frankfurt:

API=https://api.sevalla.com/v3
AUTH="Authorization: Bearer $SEVALLA_API_KEY"
CLUSTER_ID=$(curl -s "$API/resources/clusters" -H "$AUTH" | jq -r '.[] | select(.location == "eu-frankfurt-1") | .id')
M1=$(curl -s "$API/resources/process-resource-types" -H "$AUTH" | jq -r '.[] | select(.name == "m1") | .id')
DB1=$(curl -s "$API/resources/database-resource-types" -H "$AUTH" | jq -r '.[] | select(.name == "db1") | .id')

CLI: sevalla resources clusters, sevalla resources process-types and sevalla resources db-types. MCP: get_platform_options.

Create the database

Create database (createDatabaseV3). The API doesn’t return the password later, so generate it here:

DB_PASSWORD=$(openssl rand -hex 16)
DB_ID=$(curl -s -X POST "$API/databases" -H "$AUTH" -H "Content-Type: application/json" \
  -d "$(jq -n --arg c "$CLUSTER_ID" --arg r "$DB1" --arg p "$DB_PASSWORD" \
    '{display_name:"langflow-db", type:"postgresql", version:"18", cluster_id:$c, resource_type_id:$r, db_name:"langflow", db_user:"langflow", db_password:$p}')" \
  | jq -r .id)

CLI:

sevalla databases create --name langflow-db --type postgresql --db-version 18 --cluster $CLUSTER_ID --resource-type $DB1 --db-name langflow --db-user langflow --db-password $DB_PASSWORD

. MCP: sevalla_api_create with createDatabaseV3 and the same body.

Wait for the database

Get database (getDatabaseV3) until status is ready, then read the internal hostname:

for i in $(seq 1 60); do [ "$(curl -s "$API/databases/$DB_ID" -H "$AUTH" | jq -r .status)" = ready ] && break; sleep 10; done
DB_HOST=$(curl -s "$API/databases/$DB_ID" -H "$AUTH" | jq -r .internal_hostname)

CLI: sevalla databases get $DB_ID. MCP: get_database.

Create the application

Create application (createApplicationV3) with the Docker image source. It doesn’t start a deployment:

APP_ID=$(curl -s -X POST "$API/applications" -H "$AUTH" -H "Content-Type: application/json" \
  -d "$(jq -n --arg c "$CLUSTER_ID" '{display_name:"langflow", cluster_id:$c, source:"dockerImage", docker_image:"langflowai/langflow:1.13.0"}')" \
  | jq -r .id)
for i in $(seq 1 30); do APP_HOST=$(curl -s "$API/applications/$APP_ID/domains" -H "$AUTH" | jq -r '.data[] | select(.is_primary) | .name'); [ -n "$APP_HOST" ] && break; sleep 2; done
WEB_ID=$(curl -s "$API/applications/$APP_ID/processes" -H "$AUTH" | jq -r '.data[] | select(.type == "web") | .id')

The last two calls are List application domains (listApplicationDomainsV3) and List processes (listProcessesV3). CLI: sevalla apps create --name langflow --cluster $CLUSTER_ID --source dockerImage --docker-image langflowai/langflow:1.13.0. MCP: create_application with deploy: false, then get_application.

Size the web process and add the readiness probe

Update process (updateProcessV3). The API creates the web process at S1, which is too small for Langflow. Always send timeoutSeconds: without it, the probe gets 120 seconds instead of the dashboard’s 1:

curl -s -X PATCH "$API/applications/$APP_ID/processes/$WEB_ID" -H "$AUTH" -H "Content-Type: application/json" \
  -d "$(jq -n --arg r "$M1" '{resource_type_id:$r, readiness_probe:{httpGet:{path:"/health_check", port:8080}, initialDelaySeconds:10, periodSeconds:5, timeoutSeconds:5, successThreshold:1, failureThreshold:3}}')" \
  | jq -r .resource_type_name

m1

CLI: sevalla apps processes update $WEB_ID --app-id $APP_ID --resource-type $M1 (the CLI can’t set a probe). MCP: sevalla_api_update with updateProcessV3 and the same body.

Connect the database

Create internal connection (createApplicationInternalConnectionV3). Unlike the dashboard, it adds no variables:

curl -s -X POST "$API/applications/$APP_ID/internal-connections" -H "$AUTH" -H "Content-Type: application/json" \
  -d "$(jq -n --arg t "$DB_ID" '{target_id:$t, target_type:"database"}')"

CLI: sevalla apps internal-connections create $APP_ID --target-id $DB_ID --target-type database. MCP: sevalla_api_create with createApplicationInternalConnectionV3. MCP’s create_database with connect_to_application_id and env_var_name: LANGFLOW_DATABASE_URL does this step and the URL in one call, with a postgresql:// URL.

Add the environment variables

Create environment variable (createEnvironmentVariableV3), once per variable. Store the secret key and the password somewhere safe before you send them:

LANGFLOW_SECRET_KEY=$(python3 -c "import secrets; print(secrets.token_urlsafe(32))")
LANGFLOW_SUPERUSER_PASSWORD=$(openssl rand -hex 16)
add_var() {
  curl -s -X POST "$API/applications/$APP_ID/env-vars" -H "$AUTH" -H "Content-Type: application/json" \
    -d "$(jq -n --arg k "$1" --arg v "$2" '{key:$k, value:$v, is_runtime:true, is_buildtime:false}')" | jq -r .key
}
add_var LANGFLOW_DATABASE_URL "postgresql://langflow:$DB_PASSWORD@$DB_HOST:5432/langflow"
add_var LANGFLOW_SECRET_KEY "$LANGFLOW_SECRET_KEY"
add_var LANGFLOW_SUPERUSER admin
add_var LANGFLOW_SUPERUSER_PASSWORD "$LANGFLOW_SUPERUSER_PASSWORD"
add_var LANGFLOW_AUTO_LOGIN false
add_var LANGFLOW_PORT 8080
add_var LANGFLOW_ENABLE_SIGNUP false
add_var LANGFLOW_CUSTOM_COMPONENT_ADMIN_ONLY true
add_var ANTHROPIC_API_KEY "$ANTHROPIC_API_KEY"

Each call prints the key it added. CLI: sevalla apps env-vars create $APP_ID --key LANGFLOW_PORT --value 8080, once per variable; the CLI makes each variable available during runtime and build, which makes no difference for an image. MCP: set_environment_variables with all of them in variables.

Deploy

Trigger deployment (triggerDeploymentV3):

DEPLOYMENT_ID=$(curl -s -X POST "$API/applications/$APP_ID/deployments" -H "$AUTH" -H "Content-Type: application/json" -d '{}' | jq -r .id)

CLI: sevalla apps deployments trigger $APP_ID. MCP: trigger_deployment.

Wait for the deployment

Get deployment (getDeploymentV3) until status is final (success, failed, cancelled or skipped), for up to 30 minutes; Get application deployment logs (getApplicationDeploymentLogsV3) shows why one failed:

for i in $(seq 1 120); do
  STATUS=$(curl -s "https://api.sevalla.com/v3/applications/$APP_ID/deployments/$DEPLOYMENT_ID" \
    -H "Authorization: Bearer $SEVALLA_API_KEY" | jq -r '.status // empty')
  case $STATUS in success|failed|cancelled|skipped) break ;; esac
  sleep 15
done
echo "$STATUS"

success

CLI: sevalla apps deployments get $DEPLOYMENT_ID --app-id $APP_ID and sevalla apps deployments logs $DEPLOYMENT_ID --app-id $APP_ID. MCP: get_deployment and get_deployment_logs.

Check Langflow

The health check answers, and the admin account can sign in and create an API key with Langflow’s own API:

curl -s -w "\n" "https://$APP_HOST/health_check"
TOKEN=$(curl -s -X POST "https://$APP_HOST/api/v1/login" \
  --data-urlencode "username=admin" --data-urlencode "password=$LANGFLOW_SUPERUSER_PASSWORD" | jq -r .access_token)
LANGFLOW_API_KEY=$(curl -s -X POST "https://$APP_HOST/api/v1/api_key/" -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" -d '{"name":"storefront"}' | jq -r .api_key)
curl -s "https://$APP_HOST/api/v1/models/enabled_providers" -H "x-api-key: $LANGFLOW_API_KEY" | jq -c .enabled_providers

{"status":"ok","chat":"ok","db":"ok"}
["Anthropic"]

CLI: sevalla apps logs runtime $APP_ID --search ERROR shows start errors. MCP: search_runtime_logs.

Then sign in at https://$APP_HOST and build the flow.

Get started

Migrate

AI

JavaScript

Python

PHP

Ruby

Go

Rust

Java and Kotlin

.NET

Elixir

Static site generators

Deploy Langflow

At a glance

Environment variables

Before you begin

Create the database

Create the application

Connect the database

Set the environment variables

Add a readiness probe

Deploy Langflow

Verify the deployment

Build a flow with Claude

Run the flow through the API

Keep the secret key

Keep uploaded files

Upgrade Langflow

Add a custom domain

Troubleshoot

Deploy with the API

​At a glance

​Environment variables

​Before you begin

​Create the database

​Create the application

​Connect the database

​Set the environment variables

​Add a readiness probe

​Deploy Langflow

​Verify the deployment

​Build a flow with Claude

​Run the flow through the API

​Keep the secret key

​Keep uploaded files

​Upgrade Langflow

​Add a custom domain

​Troubleshoot

​Deploy with the API

At a glance

Environment variables

Before you begin

Create the database

Create the application

Connect the database

Set the environment variables

Add a readiness probe

Deploy Langflow

Verify the deployment

Build a flow with Claude

Run the flow through the API

Keep the secret key

Keep uploaded files

Upgrade Langflow

Add a custom domain

Troubleshoot

Deploy with the API