Windmill

https://www.windmill.dev/docs
Admin
Windmill is a fast, open-source workflow engine and developer platform designed to build...
Tokens:702,543
Snippets:5,625
Trust Score:7.5
Update:1 month ago
Show doc for...
Tokens:
Raw
### Start full-code app dev server

Source: https://www.windmill.dev/docs/getting_started/full_code_apps_quickstart

Navigate into the generated app directory, install dependencies, and start the local development server with hot reload at http://localhost:4000.

```bash
cd f/folder/my_app.raw_app
npm install
wmill app dev
```

--------------------------------

### Install, run, and build custom React component

Source: https://www.windmill.dev/docs/apps/react_components

Commands to install dependencies, start the development server, and build the IIFE for a custom React component in Windmill apps.

```bash
npm install
```

```bash
npm run dev
```

```bash
npm run build
```

--------------------------------

### Example script using WM_MOCKED_API_FILE

Source: https://www.windmill.dev/docs/advanced/local_development

Shows how to set the WM_MOCKED_API_FILE environment variable and use the windmill-client to set and get variables and resources. The script writes an empty JSON file, sets the environment variable, then performs set and get operations.

```typescript
import * as wmill from "windmill-client@1.450.0-beta.2"

export async function main(x: string) {
  await Bun.write("./foo.json", '{}')
  process.env["WM_MOCKED_API_FILE"] = "./foo.json"
  await wmill.setVariable("foo", "foobar")
  await wmill.setResource({ "we": 42}, "foo")
  console.log(await wmill.getResource("foo"))
  return x
}
```

--------------------------------

### Start interactive psql session with wmill datatable psql

Source: https://www.windmill.dev/docs/advanced/cli/datatable

Starts a proxy server and launches an interactive psql session connected to it. Options include -n/--name (default: main), --port (default: first available 5433-5500), --host (default: 127.0.0.1), and --password (default: randomly generated). Requires the psql client to be installed.

```bash
wmill datatable psql [options]
```

--------------------------------

### Locate Bun installation path

Source: https://www.windmill.dev/docs/misc/windows_workers

Find where Bun is installed on Windows. The example output shows a typical path.

```powershell
where.exe bun
```

```plaintext
C:\Users\Alex\.bun\bin\bun.exe
```

--------------------------------

### Start the stack with docker compose

Source: https://www.windmill.dev/docs/advanced/self_host/postgres_18_upgrade

Start the stack after the upgrade.

```bash
docker compose up -d
```

--------------------------------

### Pipeline run examples

Source: https://www.windmill.dev/docs/advanced/cli/pipeline

Examples of running pipelines: full cascade, dry-run, bounded slice, mid-DAG rebuild, backfill, and feeding a data_upload entry point.

```bash
# Full cascade from the folder's root
wmill pipeline run ecommerce

# Preview the plan without running anything
wmill pipeline run ecommerce --dry-run

# Bounded slice: run everything needed to produce daily_kpis and stop there
wmill pipeline run ecommerce --to daily_kpis

# Rebuild a mid-DAG model and everything downstream of it (dbt `--select model+`)
wmill pipeline run ecommerce --from fct_orders_daily

# Backfill one day from local working-tree files, without deploying
wmill pipeline run ecommerce --local --partition 2026-06-30

# Feed a data_upload entry point with a local file
wmill pipeline run ecommerce --upload ingest_events=./events.json
```

--------------------------------

### Get job details example

Source: https://www.windmill.dev/docs/advanced/cli/job

Gets details for the job with the given ID.

```bash
wmill job get 019d447b-114f-a018-0b72-9e541fb77c02
```

--------------------------------

### Start flow and stream progress with curl

Source: https://www.windmill.dev/docs/core_concepts/streaming

Start a flow asynchronously with the jobs/run/f endpoint and then open the SSE stream on the returned job id. Pass fast=true for quicker updates (100ms, then 500ms, then every 3s) and no_logs=true to only get step statuses.

```bash
BASE="https://app.windmill.dev/api/w/<workspace>"

JOB_ID=$(curl -s -X POST "$BASE/jobs/run/f/f/examples/onboarding" \
	-H "Authorization: Bearer $TOKEN" \
	-H "Content-Type: application/json" \
	-d '{"email": "jane@example.com"}')

curl -N "$BASE/jobs_u/getupdate_sse/$JOB_ID?fast=true&no_logs=true" \
	-H "Authorization: Bearer $TOKEN"
```

--------------------------------

### Audit log examples

Source: https://www.windmill.dev/docs/advanced/cli/user

Example: list audit entries for user alice after 2026-01-01, and get the audit entry with id 1234.

```bash
# Recent activity by a user
wmill audit list --username alice --after 2026-01-01

# Inspect a single event
wmill audit get 1234
```

--------------------------------

### Start Windmill with docker compose up

Source: https://www.windmill.dev/docs/advanced/self_host

Starts the Windmill stack in the foreground. After running, you should be greeted with the login screen at your domain.

```bash
docker compose up
```

--------------------------------

### List installed .NET SDKs

Source: https://www.windmill.dev/docs/misc/windows_workers

Check that .NET 9.0 SDK is installed by listing all installed SDKs.

```powershell
dotnet --list-sdks
```

--------------------------------

### Install app dependencies

Source: https://www.windmill.dev/docs/full_code_apps/cli_workflow

Installs dependencies for the scaffolded app. Run from the app directory after scaffolding.

```bash
cd f/folder/my_app.raw_app   # or my_app__raw_app
npm install
```

--------------------------------

### Example wmill datatable serve with output

Source: https://www.windmill.dev/docs/advanced/cli/datatable

Example invocation of the proxy server and its output. The output shows the connection strings for each datatable and instructs to press Ctrl+C to stop.

```bash
wmill datatable serve
```

```text
Serving datatables on 127.0.0.1:5433 via Postgres wire protocol

Available datatables:
  psql 'postgresql://wmill:a1b2c3d4e5f6@127.0.0.1:5433/main'
  psql 'postgresql://wmill:a1b2c3d4e5f6@127.0.0.1:5433/analytics'

Press Ctrl+C to stop.
```

--------------------------------

### Install CLI and sync workspace content

Source: https://www.windmill.dev/docs/core_concepts/infrastructure_as_code

Install the Windmill CLI globally, add a workspace with a token, pull workspace content to local files, then push changes back with the --yes flag.

```bash
npm install -g windmill-cli

wmill workspace add my-workspace https://windmill.example.com/ --token <your-token>

wmill sync pull

wmill sync push --yes
```

--------------------------------

### Install uv for Python executor

Source: https://www.windmill.dev/docs/misc/windows_workers

Install the uv package manager using PowerShell. Alternative installation methods are available in the official documentation.

```powershell
powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"
```

--------------------------------

### Global settings configuration example

Source: https://www.windmill.dev/docs/core_concepts/infrastructure_as_code

Example of the global_settings section. All fields are optional; include only the settings you want to manage. Covers base URL, retention, timeouts, SMTP, OAuth, OpenTelemetry, custom tags, alert channels, and package registries.

```yaml
global_settings:
  base_url: "https://windmill.example.com"
  retention_period_secs: 2592000    # 30 days
  job_default_timeout: 900          # 15 minutes
  request_size_limit_mb: 50
  expose_metrics: true
  dev_instance: false

  # License key (Enterprise)
  license_key: "your-license-key"

  # SMTP for sending emails
  smtp_settings:
    smtp_host: "smtp.example.com"
    smtp_port: 587
    smtp_from: "windmill@example.com"
    smtp_tls_implicit: false
    smtp_username: "windmill"
    smtp_password: "smtp-password"

  # OAuth / SSO providers
  oauths:
    google:
      id: "google-client-id"
      secret: "google-client-secret"
      login_config:
        auth_url: "https://accounts.google.com/o/oauth2/v2/auth"
        token_url: "https://oauth2.googleapis.com/token"
        userinfo_url: "https://openidconnect.googleapis.com/v1/userinfo"
        scopes: ["openid", "profile", "email"]

  # OpenTelemetry
  otel:
    otel_exporter_otlp_endpoint: "http://otel-collector:4317"
    tracing_enabled: true
    metrics_enabled: true
    logs_enabled: false

  # Custom worker tags
  custom_tags:
    - gpu
    - high-mem

  # Critical error alert channels
  critical_error_channels:
    - email: "ops@example.com"

  # Python/npm registries
  pip_index_url: "https://pypi.example.com/simple"
  npm_config_registry: "https://npm.example.com"

```

--------------------------------

### Install Puppeteer via npm on Windmill EE image

Source: https://www.windmill.dev/docs/advanced/preinstall_binaries

Extends the enterprise edition image (ghcr.io/windmill-labs/windmill-ee:main) to install Node.js, Puppeteer, and required system libraries. The example uses Node 20 and includes the necessary apt packages for Puppeteer.

```dockerfile
FROM ghcr.io/windmill-labs/windmill-ee:main

RUN apt update
RUN apt install npm -y
RUN mkdir -p /etc/apt/keyrings
RUN curl -fsSL https://deb.nodesource.com/gpgkey/nodesource-repo.gpg.key |  gpg --dearmor -o /etc/apt/keyrings/nodesource.gpg
RUN echo "deb [signed-by=/etc/apt/keyrings/nodesource.gpg] https://deb.nodesource.com/node_20.x nodistro main" | tee /etc/apt/sources.list.d/nodesource.list
RUN apt-get update -y
RUN apt install nodejs libnss3-dev  libatk1.0-0 libatk-bridge2.0-0 libcups2-dev  libdrm-dev libxkbcommon-dev libxcomposite-dev libxdamage-dev libxrandr-dev\
  libgbm-dev libpango-1.0 libcairo-dev libasound-dev -y
RUN npm install -g puppeteer -y

CMD ["windmill"]
```

--------------------------------

### Use npm install with //npm

Source: https://www.windmill.dev/docs/getting_started/scripts_quickstart/typescript

Add this comment at the top of a TypeScript (Bun) script to use `npm install` instead of `bun install` for dependencies. Useful as an escape hatch for cases not supported by bun, and exclusive to Cloud plans and Self-Hosted Enterprise edition.

```ts
//npm
```

--------------------------------

### React frontend example

Source: https://www.windmill.dev/docs/full_code_apps/frontend

React example showing how to call a backend runnable from a component using useEffect and render the results in a table.

```tsx
// App.tsx

  const [loading, setLoading] = useState(true);

  useEffect(() => {
    backend.get_users({ limit: 50 })
      .then(setUsers)
      .finally(() => setLoading(false));
  }, []);

  if (loading) return <div>Loading...</div>;

  return (
    <table>
      <thead>
        <tr><th>Name</th><th>Email</th></tr>
      </thead>
      <tbody>
        {users.map((u) => (
          <tr key={u.id}><td>{u.name}</td><td>{u.email}</td></tr>
        ))}
      </tbody>
    </table>
  );
}
```

--------------------------------

### wmill docs example queries

Source: https://www.windmill.dev/docs/advanced/cli

Example invocations of wmill docs with a query and with --json piped to jq to extract the answer field.

```bash
wmill docs "how do I create a flow?"
wmill docs "what are resources?" --json | jq .answer
```

--------------------------------

### Install Playwright via uv tool

Source: https://www.windmill.dev/docs/advanced/preinstall_binaries

Commands to install Playwright using uv tool, then install the browser binaries and system dependencies. The uv tool bin path is already in the worker's PATH, so installed binaries are directly runnable.

```bash
uv tool install playwright
playwright install
playwright install-deps
```

--------------------------------

### Verify wmill installation

Source: https://www.windmill.dev/docs/advanced/cli/installation

Verifies the installation by printing the installed version of wmill.

```bash
wmill --version
```

--------------------------------

### Example output of wmill datatable list

Source: https://www.windmill.dev/docs/advanced/cli/datatable

Example of listing datatables and the resulting table output showing the Name, Resource Type, and Resource Path for each datatable.

```bash
wmill datatable list
```

```text
+------------+---------------+---------------+
| Name       | Resource Type | Resource Path |
+------------+---------------+---------------+
| main       | postgresql    | f/db/main     |
| analytics  | postgresql    | f/db/stats    |
+------------+---------------+---------------+
```

--------------------------------

### wmill script preview examples

Source: https://www.windmill.dev/docs/advanced/cli/dev-preview

Examples of using wmill script preview with different options: regular script, --tag to route to dev workers, codebase script (bundled before preview), and --silent for piping output to jq.

```bash
# Regular script
wmill script preview u/admin/my_script.ts --data '{"x": 5}'

# Route the preview to dev workers instead of the script's default tag
wmill script preview u/admin/my_script.ts --data '{"x": 5}' --tag dev

# Codebase script (bundled before preview)
wmill script preview f/codebase_test/my_script.ts --data '{"x": 7}'

# Silent mode for piping
wmill script preview f/scripts/hello.ts -d '{"n":3}' --silent | jq
```

--------------------------------

### Svelte frontend example

Source: https://www.windmill.dev/docs/full_code_apps/frontend

Svelte example showing how to call a backend runnable from a component using $effect and render the results in a table.

```html
<!-- App.svelte -->
<script lang="ts">

  let users = $state([]);
  let loading = $state(true);

  $effect(() => {
    backend.get_users({ limit: 50 })
      .then((data) => { users = data; })
      .finally(() => { loading = false; });
  });
</script>

{#if loading}
  <div>Loading...</div>
{:else}
  <table>
    <thead>
      <tr><th>Name</th><th>Email</th></tr>
    </thead>
    <tbody>
      {#each users as user}
        <tr><td>{user.name}</td><td>{user.email}</td></tr>
      {/each}
    </tbody>
  </table>
{/if}
```

--------------------------------

### Start dev server with wmill app dev

Source: https://www.windmill.dev/docs/advanced/cli/app

Starts a local development server with hot reload and WebSocket backend. Options: --port, --host, --entry, --no-open.

```bash
wmill app dev
```

--------------------------------

### Group management example

Source: https://www.windmill.dev/docs/advanced/cli/user

Example workflow: list groups, create a group named data-team with summary "Data engineering", add user alice, and remove user bob.

```bash
# List all groups and create a new one
wmill group list
wmill group create data-team --summary "Data engineering"

# Manage membership
wmill group add-user data-team alice
wmill group remove-user data-team bob
```

--------------------------------

### wmill flow preview examples

Source: https://www.windmill.dev/docs/advanced/cli/dev-preview

Examples of using wmill flow preview with a payload and with --tag to route the preview to dev workers. The --tag option is threaded through to individual steps when combined with --step.

```bash
wmill flow preview f/my_flows/etl__flow --data '{"date":"2026-01-01"}'

# Route the preview to dev workers instead of the flow's default tag
wmill flow preview f/my_flows/etl__flow --data '{"date":"2026-01-01"}' --tag dev
```

--------------------------------

### Absolute import example

Source: https://www.windmill.dev/docs/advanced/sharing_common_logic

Shows an absolute import using the /f/ path. The example is incomplete in the source, so only the visible code is included.

```typescript

	util();
}
```

--------------------------------

### Installation

Source: https://www.windmill.dev/docs/advanced/clients/python_client

Install the wmill package via pip.

```APIDOC
## Installation

### Description
Install the Windmill Python client library using pip.

### Command
```bash
pip install wmill
```
```

--------------------------------

### Compute input example

Source: https://www.windmill.dev/docs/apps/app_configuration_settings/aggrid_table

Compute input example for the AgGrid table component. The code is incomplete in the source, showing only the return statement.

```javascript

	return res.json();
}
```

--------------------------------

### Define per-workspace specificItems for prod and dev

Source: https://www.windmill.dev/docs/advanced/cli/environment-specific-items

Defines different patterns per workspace when resources only exist in certain workspaces. For example, `prod_kafka_*` triggers only get the workspace suffix on `prod` and do not exist in `dev`. Most setups use `commonSpecificItems` instead.

```yaml
workspaces:
  prod:
    specificItems:
      variables:
        - "u/alex/prod_*"
      resources:
        - "u/alex/production/**"
      triggers:
        - "u/alex/prod_kafka_*"
      folders:
        - "f/prod_config"
      settings: true

  dev:
    specificItems:
      variables:
        - "u/alex/dev_*"
      resources:
        - "u/alex/development/**"
      triggers:
        - "u/alex/dev_kafka_*"
      folders:
        - "f/dev_config"
      settings: true
```

--------------------------------

### Install Windmill with Helm

Source: https://www.windmill.dev/docs/advanced/self_host/azure_entra_id

Installs Windmill into the 'windmill' namespace using the provided values.yaml. For Enterprise Edition, set enterprise.enabled: true in values.yaml.

```bash
helm install windmill windmill/windmill \
  --namespace windmill \
  --create-namespace \
  -f values.yaml
```

--------------------------------

### Frontend script example: read outputs, state, and interact with app

Source: https://www.windmill.dev/docs/apps/app-runnable-panel

This JavaScript example shows how to read outputs and ctx, use a global state store, and interact with components. It demonstrates that reactivity requires assigning a value rather than modifying in place, and shows how to set values, navigate, recompute, and set tabs.

```javascript
// read outputs and ctx
console.log(ctx.email);

// access a global state store
if (!state.foo) {
	state.foo = 0;
}
state.foo += 1;

// for reactivity to work, you need to assign a value and not modify it in place
// e.g: state.foo.push(1) will not work but 'state.foo = [...state.foo, 1]' will.
// you may also just reassign as next statement 'state.foo = state.foo'

// you can also navigate (goto), recompute a script (recompute), or set a tab (setTab)
// Inputs and display components support settings their value directly
setValue('a', 'Bar');

// Tables support setting their selected index (setSelectedIndex)

return state.foo;
```

--------------------------------

### Start WindmillWorker with NSSM

Source: https://www.windmill.dev/docs/misc/windows_workers

Starts the WindmillWorker service after it has been installed and configured with NSSM.

```powershell
nssm start WindmillWorker
```

--------------------------------

### Neon.tech Postgres resource JSON example

Source: https://www.windmill.dev/docs/core_concepts/persistent_storage/structured_databases

Example of a Postgres resource configuration for Neon.tech, parsed from a connection string like `psql postgres://daniel:<password>@ep-restless-rice.us-east-2.aws.neon.tech/neondb`. The `sslmode` should be "require" and the port is the default PostgreSQL port 5432.

```json
{
	"host": "ep-restless-rice.us-east-2.aws.neon.tech",
	"port": 5432,
	"user": "daniel",
	"dbname": "neondb",
	"sslmode": "require",
	"password": "<password>"
}
```

--------------------------------

### Push app from ./my_app.json

Source: https://www.windmill.dev/docs/advanced/cli/app

Example of pushing the app located at ./my_app.json.

```bash
wmill app push ./my_app.json
```

--------------------------------

### Start the development server with wmill app dev

Source: https://www.windmill.dev/docs/full_code_apps

Navigate to the app directory and run this command to start the development server with hot reload. The directory suffix may be .raw_app or __raw_app depending on your sync settings.

```bash
cd f/folder/my_app.raw_app   # or my_app__raw_app
wmill app dev .
```

--------------------------------

### Static input example

Source: https://www.windmill.dev/docs/apps/app_configuration_settings/aggrid_table

Static input example for the AgGrid table component. The array contains objects with id, name, and age fields.

```json
[
	{
		"id": 1,
		"name": "John Doe",
		"age": 25
	},
	{
		"id": 2,
		"name": "Jane Doe",
		"age": 30
	}
]
```

--------------------------------

### Go imports example

Source: https://www.windmill.dev/docs/advanced/imports

Shows how to import dependencies in a Go script. The dependencies and their versions are contained in the script, so no additional steps are needed.

```go
import (
	"rsc.io/quote"
    wmill "github.com/windmill-labs/windmill-go-client"
)
```

--------------------------------

### Bootstrap a Deno script with summary and description

Source: https://www.windmill.dev/docs/advanced/cli/script

Creates a new Deno script at f/scripts/auspicious_script with a summary and description.

```bash
wmill script bootstrap --summary 'Great script' --description 'This script does this and that' f/scripts/auspicious_script deno
```

--------------------------------

### Get flow job logs example

Source: https://www.windmill.dev/docs/advanced/cli/job

Gets logs for a flow job, showing aggregated logs from all steps with labeled headers.

```bash
wmill job logs 019d447b-114f-a018-0b72-9e541fb77c02
```

--------------------------------

### Hello World with name input

Source: https://www.windmill.dev/docs/getting_started/scripts_quickstart/go

Simplified Hello World example that takes a user's name and returns a greeting. Removes unused imports and changes the return type to (string, error).

```go
package inner

import (
	"fmt"
)

func main(name string) (string, error) {
	return fmt.Sprintf("Hello %s", name), nil
}
```

--------------------------------

### Install wmill CLI with npm

Source: https://www.windmill.dev/docs/advanced/cli/installation

Installs the Windmill CLI globally using npm. Requires Node.js version greater than v20.

```bash
npm install -g windmill-cli
```

--------------------------------

### waitJob - wait for a job

Source: https://www.windmill.dev/docs/full_code_apps/frontend

Use to wait for a previously started async job to complete. The example shows starting a job with backendAsync and then waiting for it with waitJob.

```typescript
const jobId = await backendAsync.process_data({ file: "input.csv" });
// Do other work...
const result = await waitJob(jobId);
```

--------------------------------

### Initialize Windmill roles as superuser

Source: https://www.windmill.dev/docs/advanced/self_host

Download and run the init-db-as-superuser.sql script to create the windmill_user and windmill_admin roles with proper privileges. Replace <DATABASE_URL> with your actual database URL.

```bash
curl https://raw.githubusercontent.com/windmill-labs/windmill/main/init-db-as-superuser.sql -o init-db-as-superuser.sql
psql <DATABASE_URL> -f init-db-as-superuser.sql
```

--------------------------------

### Hourly partition with start date and manual token replacement

Source: https://www.windmill.dev/docs/core_concepts/pipelines/partitioning

Declares an hourly partition with a start date. The `partition` argument is auto-declared and the token is replaced manually in the URI constant.

```ts
// pipeline
// partitioned hourly start="2026-01-01"

const DATA_URI = 's3:///lake/{partition}/data.parquet';

export async function main(partition: string) {
	// partition e.g. "2026-05-16T09"; nothing materialized before 2026-01-01
	const key = DATA_URI.replace('s3:///', '').replace('{partition}', partition);
	await wmill.writeS3File({ s3: key }, await build(partition));
}
```

--------------------------------

### Puppeteer (Bun) - Browser automation example

Source: https://www.windmill.dev/docs/advanced/browser_automation

Example of using Puppeteer with Bun to open a page, navigate to google.com, get the title, and close the browser. Requires a worker with the 'chromium' tag and the --no-sandbox flag.

```typescript
const page = await browser.newPage();
  await page.goto("https://google.com");

  const title = await page.title();

  await browser.close();

  return title;
}
```

--------------------------------

### Switch to workspace MyWorkspace

Source: https://www.windmill.dev/docs/advanced/cli/workspace-management

Example of switching to the workspace named "MyWorkspace".

```bash
 wmill workspace switch MyWorkspace
```

--------------------------------

### Playwright (Bun) - Browser automation example

Source: https://www.windmill.dev/docs/advanced/browser_automation

Example of using Playwright with Bun to open a page, navigate to google.com, get the title, and close the browser. Requires a worker with the 'chromium' tag and the --no-sandbox flag.

```typescript
const page = await browser.newPage();
  await page.goto("https://google.com");

  const title = await page.title();

  await browser.close()

  return title
}
```

--------------------------------

### Add user with specified password

Source: https://www.windmill.dev/docs/advanced/cli/user

Creates a user with the email example@example.com and the specified password mypassword123.

```bash
wmill user add example@example.com mypassword123
```

--------------------------------

### backendAsync - asynchronous call

Source: https://www.windmill.dev/docs/full_code_apps/frontend

Use to start a backend runnable asynchronously and immediately get a job ID without waiting for completion.

```typescript
// Starts the runnable, returns job ID without waiting
const jobId = await backendAsync.long_running_task({ input: data });
```

--------------------------------

### Run wmill dev for live preview

Source: https://www.windmill.dev/docs/advanced/local_development

Starts a local live-reload server and opens a Windmill dev page. The first command shows the workspace picker; the second jumps directly into a flow using --path; the third auto-detects the flow when run from inside its folder.

```bash
# Workspace picker — flows, scripts, and raw apps grouped by folder / user
wmill dev
```

```bash
# Jump straight into a flow
wmill dev --path f/my_flows/etl
```

```bash
# Auto-detected when run from inside a flow folder
cd f/my_flows/etl__flow && wmill dev
```

--------------------------------

### Set and get custom flow state in TypeScript and Python

Source: https://www.windmill.dev/docs/flows/architecture

Set and retrieve a custom flow state value from any step in a flow. The state persists for the lifetime of the flow job. The TypeScript example uses setFlowUserState and getFlowUserState; the Python example uses set_flow_user_state and get_flow_user_state.

```typescript
import * as wmill from "windmill-client@1.297.0"

export async function main(x: string) {
  await wmill.setFlowUserState("FOO", 42)
  return await wmill.getFlowUserState("FOO")

}
```

```python
import wmill
#extra_requirements:
#wmill==1.297.0

def main(x: str):
    wmill.set_flow_user_state("foobar", 43)
    return wmill.get_flow_user_state("foobar")
```

--------------------------------

### Create PostgreSQL Flexible Server

Source: https://www.windmill.dev/docs/advanced/self_host/azure_entra_id

Creates a GeneralPurpose tier server with Standard_D4s_v3 SKU, 256 GiB storage, and admin user 'windmill'. Use a strong password and specify your server name and resource group.

```bash
az postgres flexible-server create \
  --name <pg-server> \
  --resource-group <rg> \
  --tier GeneralPurpose \
  --sku-name Standard_D4s_v3 \
  --storage-size 256 \
  --admin-user windmill \
  --admin-password '<strong-password>' \
  --version 16
```

--------------------------------

### Dynamic volume name for ADK state

Source: https://www.windmill.dev/docs/misc/guides/adk_agent

Dynamic volume name example for multi-user or multi-tenant setups, scoping the volume per workspace or input.

```plaintext
// volume: $workspace-adk-state .adk
```

--------------------------------

### streamJob - stream job output

Source: https://www.windmill.dev/docs/full_code_apps/frontend

Use to stream results from a running job, calling a callback for each update. The example shows starting a job and then streaming its output.

```typescript
const jobId = await backendAsync.generate_report({ query: "SELECT *" });

const finalResult = await streamJob(jobId, (update) => {
  if (update.new_result_stream) {
    console.log("Streaming chunk:", update.new_result_stream);
  }
});
```

--------------------------------

### Absolute import example

Source: https://www.windmill.dev/docs/advanced/dependencies_in_typescript

Shows using an absolute import path starting with /f/ to reference a script in the f folder. Requires the generated tsconfig.wmill.json for local editor resolution.

```typescript
import { util } from "/f/foo.ts";

util();
```

--------------------------------

### Initialize Windmill roles as superuser

Source: https://www.windmill.dev/docs/advanced/self_host

Downloads and runs the init-db-as-superuser.sql script with a privileged role to create the required Windmill roles. Must be run before the first start when the database user is not a superuser.

```bash
curl https://raw.githubusercontent.com/windmill-labs/windmill/main/init-db-as-superuser.sql -o init-db-as-superuser.sql
psql <PRIVILEGED_DATABASE_URL> -f init-db-as-superuser.sql
```

--------------------------------

### Get and set user-defined variables with Windmill client

Source: https://www.windmill.dev/docs/core_concepts/variables_and_secrets

Retrieve and set user-defined variables using the Windmill client. The Python example imports the wmill module and calls get_variable and set_variable with the key 'u/user/foo'. The TypeScript examples use the global getVariable and setVariable functions with the same key. All variables are encrypted with a workspace-specific symmetric key.

```python
import wmill

wmill.get_variable("u/user/foo")
wmill.set_variable("u/user/foo", value)
```

```typescript

getVariable('u/user/foo');
setVariable('u/user/foo', value);
```

```typescript

getVariable('u/user/foo');
setVariable('u/user/foo', value);
```

--------------------------------

### Create new full-code app with wmill app new

Source: https://www.windmill.dev/docs/advanced/cli/app

Interactive wizard to scaffold a new full-code app with React, Svelte, or Vue.

```bash
wmill app new
```

--------------------------------

### Flow job step tree output

Source: https://www.windmill.dev/docs/advanced/cli/job

Example output of `wmill job get` for a flow job, showing the hierarchical step tree with statuses, labels, durations, and sub-job IDs.

```text
ID:       019d447b-114f-a018-0b72-9e541fb77c02
Type:     flow
Status:   success
...

Steps:
  ✓ a: Generate list    (019d447b-2a3f-...)  1.2s
  ✓ b: Process items    (019d447b-3b4c-...)  3.4s
    ✓ iteration 0       (019d447b-4c5d-...)  1.1s
    ✓ iteration 1       (019d447b-5d6e-...)  1.2s
    ✓ iteration 2       (019d447b-6e7f-...)  1.1s
  ✓ c: Aggregate        (019d447b-7f80-...)  0.8s
```

--------------------------------

### raw_app.yaml configuration example

Source: https://www.windmill.dev/docs/full_code_apps/project_structure

Main configuration file for a full-code app. Defines metadata, custom URL path, public/guest access, and data table access. The execution policy is auto-generated at deployment time and does not need to be specified here.

```yaml
summary: "My dashboard app"

# Optional: custom URL path (admin only)
custom_path: "my-dashboard"

# Optional: make the app publicly accessible (no login)
public: false

# Optional: open the app to guests (an identity required, no Windmill account needed)
guests: false

# Optional: data table access configuration
data:
  datatable: "main"           # Datatable name
  tables:                     # Tables to whitelist
    - "users"
    - "orders"
  schema: "app1"              # Schema within the datatable

```

--------------------------------

### Python top-level import in Windmill

Source: https://www.windmill.dev/docs/advanced/imports

Example of a Python import in Windmill. Only top-level imports are considered for automatic dependency installation; imports inside functions, conditional blocks, or other nested scopes are not detected.

```python
import os

# etc.

```

--------------------------------

### Stream flow progress with EventSource in TypeScript

Source: https://www.windmill.dev/docs/core_concepts/streaming

TypeScript example that starts a flow asynchronously and subscribes to the SSE stream using EventSource. Because EventSource cannot set headers, the token is passed as a query argument. The handler ignores non-update events and logs each step's id and type, then closes on completion.

```ts
const base = 'https://app.windmill.dev/api/w/<workspace>';

const jobId = await fetch(`${base}/jobs/run/f/f/examples/onboarding`, {
	method: 'POST',
	headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' },
	body: JSON.stringify({ email: 'jane@example.com' })
}).then((r) => r.text());

// EventSource cannot set headers, so the token is passed as a query arg
const events = new EventSource(
	`${base}/jobs_u/getupdate_sse/${jobId}?fast=true&no_logs=true&token=${token}`
);

events.onmessage = (e) => {
	const update = JSON.parse(e.data);
	if (update.type !== 'update') return; // ping, timeout, notfound, error

	for (const step of update.flow_status?.modules ?? []) {
		console.log(step.id, step.type); // e.g. "b InProgress"
	}
	if (update.completed) {
		console.log('result', update.job.result);
		events.close();
	}
};
```

--------------------------------

### Create and enter a local workspace folder

Source: https://www.windmill.dev/docs/advanced/local_development

Creates an empty folder and changes into it, as the first step to clone a Windmill workspace locally.

```bash
mkdir myworkspace
cd myworkspace
```

--------------------------------

### SSE update event with flow_status

Source: https://www.windmill.dev/docs/core_concepts/streaming

Example SSE update event from the job progress endpoint. The modules array lists each top-level step with its type (WaitingForPriorSteps, WaitingForExecutor, WaitingForEvents, InProgress, Success, Failure) and job id once started. The last event has completed:true and a job field with the result.

```json
{
	"type": "update",
	"running": true,
	"flow_status": {
		"step": 1,
		"modules": [
			{ "type": "Success", "id": "a", "job": "0199...", "skipped": false },
			{ "type": "InProgress", "id": "b", "job": "0199..." },
			{ "type": "WaitingForPriorSteps", "id": "c" }
		]
		// other flow_status fields omitted
	}
}
```

--------------------------------

### R script with main function using httr and jsonlite

Source: https://www.windmill.dev/docs/getting_started/scripts_quickstart/r

Example R script for Windmill. It defines a main function that makes an HTTP GET request using the httr package and returns a list with the status, parsed body, and a message. Windmill parses library() calls to manage CRAN dependencies automatically.

```r
library(httr)
library(jsonlite)

main <- function(url = "https://httpbin.org/get", message = "Hello from Windmill!") {
  response <- GET(url, query = list(message = message))

  list(
    status = status_code(response),
    body = content(response, as = "parsed"),
    message = "Request completed successfully"
  )
}

```

--------------------------------

### Example krb5.conf configuration

Source: https://www.windmill.dev/docs/triggers/kafka_triggers

A standard krb5.conf file configuration for Kerberos authentication, including settings for containerized environments.

```ini
[libdefaults]
    default_realm = EXAMPLE.COM
    dns_lookup_realm = false
    dns_lookup_kdc = false
    # Recommended for containerized environments - see troubleshooting below
    dns_canonicalize_hostname = false

[realms]
    EXAMPLE.COM = {
        kdc = kdc.example.com
        admin_server = kdc.example.com
    }

[domain_realm]
    .example.com = EXAMPLE.COM
    example.com = EXAMPLE.COM
```

--------------------------------

### Install renv package

Source: https://www.windmill.dev/docs/misc/windows_workers

Installs the renv package, which Windmill uses to resolve and install R package dependencies.

```powershell
Rscript -e "install.packages('renv', repos='https://cloud.r-project.org')"
```

--------------------------------

### Get logs for a specific step

Source: https://www.windmill.dev/docs/advanced/cli/job

Gets logs for a specific step using the sub-job ID from `job get`.

```bash
wmill job logs 019d447b-2a3f-...
```

--------------------------------

### Install Playwright in Windmill Dockerfile

Source: https://www.windmill.dev/docs/advanced/preinstall_binaries

Base image for installing Playwright in a Windmill worker. Uses the enterprise edition (windmill-ee) as the base. Installs Playwright via uv, then installs browsers and system dependencies.

```dockerfile
FROM ghcr.io/windmill-labs/windmill-ee:main

RUN uv tool install playwright
RUN playwright install
RUN playwright install-deps

CMD ["windmill"]
```

--------------------------------

### Locate .NET installation

Source: https://www.windmill.dev/docs/misc/windows_workers

Find where .NET is installed on your system.

```powershell
where.exe dotnet
```

--------------------------------

### Path-based runnables: script, flow, hubscript

Source: https://www.windmill.dev/docs/full_code_apps/backend_runnables

Three YAML examples showing how to reference an existing workspace script, flow, or hub script as a backend runnable.

```yaml
# backend/process_order.yaml
type: script
path: f/production/process_order
```

```yaml
# backend/onboarding.yaml
type: flow
path: f/flows/user_onboarding
```

```yaml
# backend/send_email.yaml
type: hubscript
path: hub/123/sendgrid/send_email
```

--------------------------------

### Verify Nu installation

Source: https://www.windmill.dev/docs/misc/windows_workers

Verifies that Nushell is installed and can be entered from PowerShell.

```powershell
nu
```

--------------------------------

### POST /w/{workspace}/apps/create_raw_source

Source: https://www.windmill.dev/docs/full_code_apps/deployment

Create an app from its sources. Requires path, value, summary and policy, and returns 201.

```APIDOC
## POST /w/{workspace}/apps/create_raw_source

### Description
Create an app from its sources. Requires `path`, `value`, `summary` and `policy`, and returns `201`.

### Method
POST

### Endpoint
/w/{workspace}/apps/create_raw_source

### Parameters
#### Path Parameters
- **workspace** (string) - Required - The workspace identifier.

#### Request Body
- **path** (string) - Required - The path of the app.
- **value** (object) - Required - The app sources, containing `files`, `runnables`, and `data`.
- **summary** (string) - Required - A summary of the app.
- **policy** (object) - Required - The execution policy.

### Response
#### Success Response (201)
- **status** (string) - Created.

```

--------------------------------

### Variable specification example

Source: https://www.windmill.dev/docs/advanced/cli/variable

Example variable specification in JSON format.

```JSON
{
"value": "finland does not actually exist",
"is_secret": false,
"description": "This item is not secret",
"account": null,
"is_oauth": false,
"is_expired": false
}
```

--------------------------------

### Add user with auto-generated password

Source: https://www.windmill.dev/docs/advanced/cli/user

Creates a user with the email example@example.com and automatically generates a password.

```bash
wmill user add example@example.com
```

--------------------------------

### Worker group configurations example

Source: https://www.windmill.dev/docs/core_concepts/infrastructure_as_code

Example of the worker_configs section. Define one entry per worker group; the key is the group name. Shows default, native, and gpu groups with tags, init scripts, static env vars, cache clearing, dedicated workers, and autoscaling.

```yaml
worker_configs:
  default:
    worker_tags:
      - deno
      - python3
      - bun
      - go
      - bash
      - powershell
    init_bash: "echo 'Worker ready'"
    env_vars_static:
      MY_VAR: "value"
    cache_clear: 7

  native:
    worker_tags:
      - nativets

  gpu:
    worker_tags:
      - gpu-task
    dedicated_worker: "f/gpu_scripts/inference"
    autoscaling:
      enabled: true
      min_workers: 0
      max_workers: 4

```

--------------------------------

### Verify R installation

Source: https://www.windmill.dev/docs/misc/windows_workers

Verifies that R is installed and Rscript.exe is accessible from PowerShell.

```powershell
Rscript --version
```

--------------------------------

### Return resume URL for prompt (Go)

Source: https://www.windmill.dev/docs/flows/flow_approval

Returns the resume URL for a prompt that can be self-approved. The 'resume' key is required; 'default_args' and 'enums' are optional.

```go
package inner

import (
	wmill "github.com/windmill-labs/windmill-go-client"
)

func main() (map[string]interface{}, error) {
	urls, err := wmill.GetResumeUrls("approver1")
	if err != nil {
		return nil, err
	}
	return map[string]interface{}{
		"resume":      urls.Resume,
		"default_args": make(map[string]interface{}), // optional
		"enums":       make(map[string]interface{}), // optional
	}, nil
}
```

--------------------------------

### wmill audit get

Source: https://www.windmill.dev/docs/advanced/cli/user

Gets a single audit log entry by ID.

```APIDOC
## wmill audit get

### Description
Gets a single audit log entry by ID.

### Usage
```bash
wmill audit get <id>
```

### Arguments
- `id` (string) - Required - The ID of the audit log entry.

### Examples
```bash
wmill audit get 1234
```
```

--------------------------------

### wmill group get

Source: https://www.windmill.dev/docs/advanced/cli/user

Gets details of a specific workspace group by name.

```APIDOC
## wmill group get

### Description
Gets details of a specific workspace group.

### Usage
```bash
wmill group get <name>
```

### Arguments
- `name` (string) - Required - The name of the group.
```

--------------------------------

### Example output of where.exe Rscript.exe

Source: https://www.windmill.dev/docs/misc/windows_workers

Example output from the where.exe Rscript.exe command.

```plaintext
C:\Program Files\R\R-4.6.1\bin\Rscript.exe
```

--------------------------------

### Initialize client

Source: https://www.windmill.dev/docs/advanced/clients/rust_client

Create a Windmill client instance using default environment variables or custom configuration.

```APIDOC
## Initialize client

### Description
Create a Windmill client instance using default environment variables or custom configuration.

### Method
Constructor

### Endpoint
Windmill::default() / Windmill::new(token, workspace, base_url)

### Parameters
- **token** (Option<String>) - Optional - Custom authentication token.
- **workspace** (Option<String>) - Optional - Workspace name.
- **base_url** (Option<String>) - Optional - Base URL of the Windmill API.

### Request Example
```rust
use wmill::Windmill;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Read config from env vars
    let wm = Windmill::default()?;

    // Or override specific values
    let wm = Windmill::new(
        Some("custom_token".to_string()),
        Some("my_workspace".to_string()),
        Some("http://localhost:8000".to_string())
    )?;

    Ok(())
}
```

### Response
Returns a `Windmill` client instance.
```

--------------------------------

### Install WindmillWorker with NSSM

Source: https://www.windmill.dev/docs/misc/windows_workers

Installs the WindmillWorker service using NSSM, which opens a GUI for configuration.

```powershell
nssm install WindmillWorker
```

--------------------------------

### Set WM_STATE_PATH for local state (Deno and Node/Bun)

Source: https://www.windmill.dev/docs/advanced/local_development/run_locally

Sets WM_STATE_PATH to the script's path so getState and setState work locally. The first uses Deno.env.set; the second uses process.env for Node/Bun. Both derive the path from import.meta.url.

```ts
let fullUrl = import.meta.url;
let pathS = fullUrl.substring(8, fullUrl.length - 3).split('/');
const path = pathS.slice(pathS.length - 3, pathS.length).join('/');
Deno.env.set('WM_STATE_PATH', path);
```

```ts
let fullUrl = import.meta.url;
let pathS = fullUrl.substring(8, fullUrl.length - 3).split('/');
const path = pathS.slice(pathS.length - 3, pathS.length).join('/');
process.env.WM_STATE_PATH = path;
```

--------------------------------

### Install requirements.yml from cloned repo

Source: https://www.windmill.dev/docs/getting_started/scripts_quickstart/ansible

Installs roles and collections from requirements.yml files in the cloned repository before the playbook runs. The worker looks for requirements.yml, requirements.yaml, collections/requirements.yml, and roles/requirements.yml at the root and runs ansible-galaxy install commands on each match.

```yaml
delegate_to_git_repo:
  resource: u/user/git_repo_resource
  playbook: playbooks/site.yml
  install_requirements: true
```

--------------------------------

### Manage dependencies with ls and cat

Source: https://www.windmill.dev/docs/core_concepts/workspace_dependencies

Use these commands to list available dependency files and view the content of a specific dependency file.

```bash
# List available dependency files
ls dependencies

# View dependency file content
cat dependencies/frontend.package.json
```

--------------------------------

### Check URL reachability in Bash, PowerShell, and Nu

Source: https://www.windmill.dev/docs/getting_started/scripts_quickstart/bash

These are the code examples for Bash, PowerShell, and Nu scripts that check if a URL is reachable. The Bash example is the primary script, and the PowerShell and Nu examples are alternative implementations for the same functionality.

```powershell
param($url = "default value")

$status_code = (Invoke-WebRequest -Uri $url -Method Get).StatusCode

if ($status_code -like "2*" -or $status_code -like "3*") {
    Write-Host "The URL is reachable!"
} else {
    Write-Host "The URL is not reachable."
}
```

```python
def main [
  url: string = "default value"
] {
  try {
    # Nu will throw an error automatically if request fails
    http get $url
    echo "The URL is reachable!"
  } catch {
    echo "The URL is not reachable."
  }
}
```

--------------------------------

### Install wmill package

Source: https://www.windmill.dev/docs/advanced/clients/python_client

Install the wmill package via pip to use the Windmill Python client.

```bash
pip install wmill
```

--------------------------------

### Get job result

Source: https://www.windmill.dev/docs/advanced/cli/job

Gets the result of a completed job as JSON. Useful for scripting and piping to other commands.

```bash
wmill job result <id>
```

--------------------------------

### Example oneOf selection result

Source: https://www.windmill.dev/docs/core_concepts/json_schema_and_parsing

Example result of a oneOf selection when the user picks Option 2 and enters a custom value.

```json
{
    "label": "Option 2",
    "other_attribute": "Value that the user entered"
}
```
Tokens:
Raw