Installation

Install Brokoli in under a minute. No dependencies required.

Prerequisites

Operating system: Linux, macOS, or Windows (WSL)
Optional: Python 3.9+ (only needed for Code nodes and the Python SDK)
Optional: Go 1.22+ (only for go install or building from source)

Install methods

Binary download (recommended)

Linux

curl -L https://github.com/Tnsor-Labs/brokoli/releases/latest/download/broked-linux-amd64 -o broked
chmod +x broked
sudo mv broked /usr/local/bin/

macOS

curl -L https://github.com/Tnsor-Labs/brokoli/releases/latest/download/broked-darwin-amd64 -o broked
chmod +x broked
sudo mv broked /usr/local/bin/

Windows (WSL)

curl -L https://github.com/Tnsor-Labs/brokoli/releases/latest/download/broked-linux-amd64 -o broked
chmod +x broked
sudo mv broked /usr/local/bin/

Docker

Build the image from source, then run:

git clone https://github.com/Tnsor-Labs/brokoli.git
cd brokoli/broked
docker build -t broked .
docker run -d -p 8080:8080 -v brokoli-data:/data broked

Go install

Requires Go 1.22 or later:

go install github.com/Tnsor-Labs/brokoli/broked@latest

Build from source

git clone https://github.com/Tnsor-Labs/brokoli.git
cd brokoli/broked
go build -o broked .

Verify installation

broked --help

Expected output:

A data-aware orchestration engine with a minimalist UI. Built on top of BrokoliSQL.

Usage:
  broked [command]

Available Commands:
  assert        Run a pipeline and validate assertions against its output
  completion    Generate the autocompletion script for the specified shell
  export        Export a pipeline to YAML
  generate-key  Generate a new API key
  help          Help about any command
  import        Import a pipeline from a YAML file
  migrate       Migrate data between databases (SQLite <-> PostgreSQL or vice versa)
  run           Trigger a pipeline run and wait for completion
  serve         Start the Broked server
  test          Validate a pipeline YAML file for CI/CD

Flags:
  -h, --help   help for broked

Use "broked [command] --help" for more information about a command.

CLI commands

`serve` -- Start the server

broked serve

Flag	Default	Description
`--port`, `-p`	`8080`	HTTP server port
`--db`	`./broked.db`	SQLite database path or PostgreSQL connection string
`--api-key`	(none)	Enable API key authentication
`--mode`	`all`	Run mode: `all`, `api`, `scheduler`, `worker`

# Custom port with API key auth
broked serve --port 3000 --api-key brk_your_key_here

# Use PostgreSQL instead of SQLite
broked serve --db "postgres://user:pass@localhost:5432/brokoli?sslmode=disable"

# Run only the API server (distributed mode)
broked serve --mode api

`generate-key` -- Generate an API key

broked generate-key

Prints a new random API key to stdout. Pass it to broked serve --api-key to enable key-based authentication.

`run` -- Trigger a pipeline run

broked run <pipeline-id>

Triggers a pipeline run on a remote server and polls until completion.

Flag	Default	Description
`--server`	`http://localhost:8080`	Brokoli server URL
`--api-key`	(none)	API key for authentication
`--timeout`	`300`	Timeout in seconds

broked run abc123 --server https://brokoli.example.com --api-key brk_key

`assert` -- Run pipeline with assertions

broked assert <pipeline-id> --assertions assertions.yaml

Triggers a pipeline run in test mode and evaluates assertions from a YAML file. Exits 0 if all pass, 1 if any fail.

Flag	Default	Description
`--assertions`, `-a`	`assertions.yaml`	Assertions YAML file
`--server`	`http://localhost:8080`	Brokoli server URL
`--api-key`	(none)	API key for authentication

`migrate` -- Migrate between databases

broked migrate --from <source> --to <target>

Migrates all data between SQLite and PostgreSQL (in either direction). Includes verification after migration.

Flag	Default	Description
`--from`	(required)	Source database URI
`--to`	(required)	Target database URI
`--dry-run`	`false`	Show row counts without migrating

# SQLite to PostgreSQL
broked migrate --from ./broked.db --to "postgres://user:pass@host:5432/brokoli"

# Dry run first
broked migrate --from ./broked.db --to "postgres://..." --dry-run

`import` -- Import pipeline from YAML

broked import <file.yaml>

Parses a pipeline YAML file and writes it to the local database. Uses the --db flag from serve to locate the database.

`export` -- Export pipeline to YAML

broked export <pipeline-id>

Exports a pipeline definition to YAML format.

Flag	Default	Description
`--output`, `-o`	(stdout)	Output file path

# Print to stdout
broked export abc123

# Save to file
broked export abc123 --output pipeline.yaml

`test` -- Validate pipeline YAML for CI/CD

broked test <pipeline.yaml>

Parses and validates a pipeline YAML file without running it. Exits 0 on success, 1 on failure. Useful in CI/CD pipelines.

Flag	Default	Description
`--json`	`false`	Output results as JSON

# Human-readable output
broked test my-pipeline.yaml

# JSON output for CI systems
broked test my-pipeline.yaml --json

Start the server

broked serve

That's it. The server starts on http://localhost:8080 with an embedded SQLite database.

Next steps

Quick Start -- create your first pipeline in 5 minutes
Configuration -- all environment variables and options

On this page