> ## Documentation Index
> Fetch the complete documentation index at: https://docs.sevalla.com/llms.txt
> Use this file to discover all available pages before exploring further.

> ## Agent Instructions
> These are the docs for Sevalla, a platform for deploying applications, databases, static sites, object storage and load balancers. The dashboard is at https://app.sevalla.com.
> Bold text in steps is an exact dashboard label.
> To act on a Sevalla account, prefer the Sevalla MCP server (https://mcp.sevalla.com/mcp, see https://docs.sevalla.com/ai-agents/overview.md), then the Sevalla CLI (https://docs.sevalla.com/developer-tools/cli.md), then the REST API (https://api-docs.sevalla.com, OpenAPI spec at https://api.sevalla.com/v3/openapi.json).
> Every page index is at https://docs.sevalla.com/llms.txt.

# Deploy Langflow

> Run Langflow from its official Docker image with PostgreSQL, a fixed secret key and sign-in required, then run a Claude flow through Langflow's API with an API key.

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](#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](#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](https://console.anthropic.com/).

## Create the database

**1. Open the create form**

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

**2. Choose PostgreSQL**

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

**3. 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**.

**4. Create it**

Click **Create database** and wait for the status **Ready**.

## Create the application

**1. 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)**.

**2. Name, place and size it**

Enter the **Name** `langflow`, choose the database's **Data center**, and choose the **Size** **M1**.

**3. 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](#upgrade-langflow).

## Connect the database

**1. Open the database's networking**

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

**2. Add the connection**

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

**3. 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.

**4. 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:

```bash theme={"theme":{"light":"github-dark-default","dark":"github-dark-default"}}
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**:

```bash .env theme={"theme":{"light":"github-dark-default","dark":"github-dark-default"}}
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](#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.

**1. Open the web process**

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

**2. 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`.

**3. Save**

Click **Update process**.

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

## Deploy Langflow

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

1. On the **Deployments** tab, the deployment's status is **Deployed**. With the API, [Get deployment](https://api-docs.sevalla.com/v3/applications/get-deployment) (`getDeploymentV3`) returns `"status": "success"`.

2. The health check answers once Langflow can reach PostgreSQL:

   ```bash theme={"theme":{"light":"github-dark-default","dark":"github-dark-default"}}
   curl -s https://langflow-x7k2m.sevalla.app/health_check
   ```

   ```json theme={"theme":{"light":"github-dark-default","dark":"github-dark-default"}}
   {"status":"ok","chat":"ok","db":"ok"}
   ```

3. The version endpoint answers without signing in:

   ```bash theme={"theme":{"light":"github-dark-default","dark":"github-dark-default"}}
   curl -s https://langflow-x7k2m.sevalla.app/api/v1/version
   ```

   ```json theme={"theme":{"light":"github-dark-default","dark":"github-dark-default"}}
   {"version":"1.13.0","main_version":"1.13.0","package":"Langflow"}
   ```

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

## Build a flow with Claude

**1. 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**.

**2. 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`.

**3. 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.

**1. 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.

**2. Run the flow**

Send a message to the flow's run endpoint:

```bash theme={"theme":{"light":"github-dark-default","dark":"github-dark-default"}}
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'
```

```text theme={"theme":{"light":"github-dark-default","dark":"github-dark-default"}}
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](https://docs.sevalla.com/applications/environment-variables.md), 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.

> [!WARNING]
>
> 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:

**1. 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**.

**2. 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](https://docs.sevalla.com/applications/disks.md)): during each deployment, Langflow didn't answer for about 110 seconds.

## Upgrade Langflow

1. Read the release notes of every version between yours and the new one on [Langflow's GitHub releases](https://github.com/langflow-ai/langflow/releases).
2. Back up `langflow-db`: on its **Backups** tab, create a manual backup. See [Backups](https://docs.sevalla.com/databases/backups.md).
3. On the application's **Settings** tab, in the **Source** section, click **Update source**, change the tag in **Docker image**, and click **Update source**.
4. 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](https://docs.sevalla.com/domains/overview.md).

## 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](#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](#keep-uploaded-files) 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](https://docs.sevalla.com/developer-tools/api-keys.md) 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.

**1. Choose the location and sizes**

[List clusters](https://api-docs.sevalla.com/v3/resources/list-clusters) (`listClustersV3`), [List process resource types](https://api-docs.sevalla.com/v3/resources/list-process-resource-types) (`listProcessResourceTypesV3`) and [List database resource types](https://api-docs.sevalla.com/v3/resources/list-database-resource-types) (`listDatabaseResourceTypesV3`). Pick the location by its region ID, here Frankfurt:

```bash theme={"theme":{"light":"github-dark-default","dark":"github-dark-default"}}
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`.

**2. Create the database**

[Create database](https://api-docs.sevalla.com/v3/databases/create-database) (`createDatabaseV3`). The API doesn't return the password later, so generate it here:

```bash theme={"theme":{"light":"github-dark-default","dark":"github-dark-default"}}
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.

**3. Wait for the database**

[Get database](https://api-docs.sevalla.com/v3/databases/get-database) (`getDatabaseV3`) until `status` is `ready`, then read the internal hostname:

```bash theme={"theme":{"light":"github-dark-default","dark":"github-dark-default"}}
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`.

**4. Create the application**

[Create application](https://api-docs.sevalla.com/v3/applications/create-application) (`createApplicationV3`) with the Docker image source. It doesn't start a deployment:

```bash theme={"theme":{"light":"github-dark-default","dark":"github-dark-default"}}
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](https://api-docs.sevalla.com/v3/applications/list-application-domains) (`listApplicationDomainsV3`) and [List processes](https://api-docs.sevalla.com/v3/applications/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`.

**5. Size the web process and add the readiness probe**

[Update process](https://api-docs.sevalla.com/v3/applications/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:

```bash theme={"theme":{"light":"github-dark-default","dark":"github-dark-default"}}
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
```

```text theme={"theme":{"light":"github-dark-default","dark":"github-dark-default"}}
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.

**6. Connect the database**

[Create internal connection](https://api-docs.sevalla.com/v3/applications/create-internal-connection) (`createApplicationInternalConnectionV3`). Unlike the dashboard, it adds no variables:

```bash theme={"theme":{"light":"github-dark-default","dark":"github-dark-default"}}
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.

**7. Add the environment variables**

[Create environment variable](https://api-docs.sevalla.com/v3/applications/create-environment-variable) (`createEnvironmentVariableV3`), once per variable. Store the secret key and the password somewhere safe before you send them:

```bash theme={"theme":{"light":"github-dark-default","dark":"github-dark-default"}}
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`.

**8. Deploy**

[Trigger deployment](https://api-docs.sevalla.com/v3/applications/trigger-deployment) (`triggerDeploymentV3`):

```bash theme={"theme":{"light":"github-dark-default","dark":"github-dark-default"}}
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`.

**9. Wait for the deployment**

[Get deployment](https://api-docs.sevalla.com/v3/applications/get-deployment) (`getDeploymentV3`) until `status` is final (`success`, `failed`, `cancelled` or `skipped`), for up to 30 minutes; [Get application deployment logs](https://api-docs.sevalla.com/v3/applications/get-application-deployment-logs) (`getApplicationDeploymentLogsV3`) shows why one failed:

```bash theme={"theme":{"light":"github-dark-default","dark":"github-dark-default"}}
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"
```

```text theme={"theme":{"light":"github-dark-default","dark":"github-dark-default"}}
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`.

**10. Check Langflow**

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

```bash theme={"theme":{"light":"github-dark-default","dark":"github-dark-default"}}
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
```

```text theme={"theme":{"light":"github-dark-default","dark":"github-dark-default"}}
{"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](#build-a-flow-with-claude).


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.