Skip to main content
Flowise can be deployed using Docker in multiple ways. This guide covers both Docker Compose and standalone Docker deployments. Docker Compose is the easiest way to deploy Flowise with all necessary configurations.

​
Quick Start

1

Clone the repository

git clone https://github.com/FlowiseAI/Flowise.git
cd Flowise
2

Navigate to docker folder

cd docker
3

Create environment file

Copy the example environment file and customize it:
cp .env.example .env
Edit the .env file with your preferred settings. At minimum, set:
PORT=3000
4

Start the services

docker compose up -d
5

Access Flowise

Open your browser and navigate to http://localhost:3000

​
Docker Compose Configuration

The default docker-compose.yml includes:
docker-compose.yml
version: '3.1'

services:
    flowise:
        image: flowiseai/flowise:latest
        restart: always
        environment:
            - PORT=${PORT}
            - DATABASE_PATH=${DATABASE_PATH}
            # ... other environment variables
        ports:
            - '${PORT}:${PORT}'
        healthcheck:
            test: ['CMD', 'curl', '-f', 'http://localhost:${PORT}/api/v1/ping']
            interval: 10s
            timeout: 5s
            retries: 5
            start_period: 30s
        volumes:
            - ~/.flowise:/root/.flowise
        entrypoint: /bin/sh -c "sleep 3; flowise start"

​
Managing Docker Compose

docker compose up -d

​
Persistent Data

By default, Flowise stores data in ~/.flowise on the host machine. This includes:
  • Database files (if using SQLite)
  • Uploaded files
  • Configuration data
  • Secret keys
The volume mount ensures your data persists across container restarts: 
volumes:
    - ~/.flowise:/root/.flowise

​
Standalone Docker

You can also run Flowise using standalone Docker commands.

​
Using Pre-built Image

docker run -d \
  --name flowise \
  -p 3000:3000 \
  -v ~/.flowise:/root/.flowise \
  flowiseai/flowise:latest

​
Building Custom Image

If you need to customize the Flowise image:
1

Clone the repository

git clone https://github.com/FlowiseAI/Flowise.git
cd Flowise
2

Build the image

docker build --no-cache -t flowise .
The Dockerfile includes:
  • Node.js 20 Alpine base
  • Chromium for Puppeteer
  • All system dependencies
  • Application source code
3

Run your custom image

docker run -d --name flowise -p 3000:3000 flowise

​
Dockerfile Overview

Dockerfile
FROM node:20-alpine

# Install system dependencies and build tools
RUN apk update && \
    apk add --no-cache \
        libc6-compat \
        python3 \
        make \
        g++ \
        build-base \
        cairo-dev \
        pango-dev \
        chromium \
        curl && \
    npm install -g pnpm

ENV PUPPETEER_SKIP_DOWNLOAD=true
ENV PUPPETEER_EXECUTABLE_PATH=/usr/bin/chromium-browser
ENV NODE_OPTIONS=--max-old-space-size=8192

WORKDIR /usr/src/flowise

# Copy app source
COPY . .

# Install dependencies and build
RUN pnpm install && \
    pnpm build

# Switch to non-root user
RUN chown -R node:node .
USER node

EXPOSE 3000

CMD [ "pnpm", "start" ]

​
Docker with External Database

For production deployments, use an external database like PostgreSQL:
docker-compose.yml
version: '3.1'

services:
    flowise:
        image: flowiseai/flowise:latest
        restart: always
        environment:
            - PORT=3000
            - DATABASE_TYPE=postgres
            - DATABASE_HOST=postgres
            - DATABASE_PORT=5432
            - DATABASE_NAME=flowise
            - DATABASE_USER=flowise
            - DATABASE_PASSWORD=your_secure_password
        ports:
            - '3000:3000'
        volumes:
            - ~/.flowise:/root/.flowise
        depends_on:
            - postgres

    postgres:
        image: postgres:16-alpine
        restart: always
        environment:
            POSTGRES_DB: flowise
            POSTGRES_USER: flowise
            POSTGRES_PASSWORD: your_secure_password
        volumes:
            - postgres_data:/var/lib/postgresql/data
        ports:
            - '5432:5432'

volumes:
    postgres_data:

​
Health Checks

Flowise includes a built-in health check endpoint: 
curl -f http://localhost:3000/api/v1/ping
The Docker Compose configuration includes automatic health monitoring: 
healthcheck:
    test: ['CMD', 'curl', '-f', 'http://localhost:${PORT}/api/v1/ping']
    interval: 10s
    timeout: 5s
    retries: 5
    start_period: 30s

​
Troubleshooting

​
Container won’t start

docker logs flowise
# or for docker compose
docker compose logs flowise
Ensure port 3000 (or your configured port) is not already in use:
lsof -i :3000
Ensure the ~/.flowise directory has proper permissions:
ls -la ~/.flowise
chmod -R 755 ~/.flowise

​
Database connection issues

If using an external database, ensure:
  • Database server is running and accessible
  • Credentials are correct
  • Database exists and user has proper permissions
  • Network connectivity between containers (use depends_on in docker-compose)

​
Memory issues

If you encounter memory-related errors, increase the Node.js heap size: 
environment:
    - NODE_OPTIONS=--max-old-space-size=8192

​
Updating Flowise

# Pull latest image
docker compose pull

# Restart services
docker compose up -d

​
Next Steps

Environment Variables

Configure Flowise with environment variables

Authentication

Set up user authentication and security

Cloud Providers

Deploy to AWS, Azure, GCP, and more

Build docs developers (and LLMs) love

Get started for freeTalk to us