45f256a5a1 feat: accept MCP access tokens from an external OIDC issuer (#12085)
* feat: accept MCP access tokens from an external OIDC issuer

With the mcp_external_idp instance setting, every MCP URL also accepts an
access token of an external OIDC issuer, told apart from Windmill's own
by its iss. The token's OAuth client is mapped to a workspace and a
selection of tools; the request acts as the existing Windmill user with
the token's email, under that selection. Runs record the client in
mcp_client and give it to steps as WM_MCP_CLIENT; tool calls and
refusals are audited with both identities.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix: harden external MCP token verification

Refuse ID tokens, tokens before their nbf, and emails the issuer marks
unverified; let a cached signing key expire so a withdrawn key stops
verifying; fall back to the token's asymmetric alg for keys published
without one; reject clients configured without an issuer or with an id
longer than the column recording it.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix: refuse deactivated accounts and untyped tokens on external MCP auth

Read password.disabled, since instance deactivation has no Windmill
token to revoke on this path. Without a configured audience, take only
tokens typed as access tokens (at+jwt header or a Bearer typ claim), so
an ID token cannot stand in for one. Require https for the issuer except
on localhost.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix: refuse ID tokens with an audience set, parse the issuer host

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* feat: take an external MCP token's groups for the request instead of storing them

When sso_groups_claim is set, the IdP-managed instance groups of an
external MCP request come from the token's claim alone, mapped through
their external_id with nested paths counting for their ancestors. Nothing
is written, and an absent claim means no IdP groups, so removing a user
from every group revokes at the next token. Entra's overage pointer is
refused rather than read as no groups.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* feat: give external MCP clients the token access levels, one card per client

A client takes the same access as a Windmill token: read, read and run,
build and run (the session toolset, bound to the client's workspace), or
scripts and flows as tools. The settings editor reuses McpAccessPicker,
one collapsible card per client. The caller's JWT carries mcp_client so
runs the session toolset starts record the client too. With token groups
in use, admin rights a managed group grants follow the token, and
workspace groups are kept by source rather than by name.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix: keep a client's tool selection across reopening its card

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix: tidy the MCP external identity provider form

Show it under SSO only, shorten its description with details in a
tooltip, and give its fields form labels, hints and tooltips.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix: leave default claim names empty, shorten auth setting descriptions

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix: report an external MCP token's groups in whoami

Requests and jobs started through an external MCP token act with the
token's groups; whoami returned the stored memberships instead.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix: keep stored roles for external MCP requests

Only group memberships follow the token. Admin and superadmin roles stay
as stored, kept current by SCIM and SSO login: their source is not
recorded, so a group-derived demotion also stripped directly granted
admins and left operator restrictions unapplied.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix: record the MCP client on on-behalf-of runs and AI agent tool steps

On-behalf-of runs now hand push the MCP caller, which push uses only to
record the client while it fetches the run's own permissions. AI agent
tool jobs read the client from job_perms, so their steps see
WM_MCP_CLIENT.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix: keep the MCP client off v2_job

The client is needed only while a job is queued, which job_perms covers; a
finished run's client is in its audit entry. This leaves the job history
table unaltered.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* chore: update ee-repo-ref to e9e94030cebd5afb0c8156ee46af2025bbe8778a

This commit updates the EE repository reference after PR #934 was merged in windmill-ee-private.

Previous ee-repo-ref: 7bdd6e8067a72e847ed0372ddc79a84f288946cf

New ee-repo-ref: e9e94030cebd5afb0c8156ee46af2025bbe8778a

Automated by sync-ee-ref workflow.

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
Co-authored-by: windmill-internal-app[bot] <windmill-internal-app[bot]@users.noreply.github.com>
Co-authored-by: Ruben Fiszel <ruben@windmill.dev>
2026-10-30 20:09:09 +01:00
2024-02-08 16:09:11 +01:00
2026-10-30 20:02:34 +01:00
2026-10-30 20:02:34 +01:00
2023-08-26 09:17:07 +02:00
2026-08-19 14:18:37 +00:00
2025-04-21 16:53:23 +02:00
2026-04-16 06:26:25 -07:00
2025-12-08 10:34:16 +00:00
2022-05-05 04:25:58 +02:00
2024-02-08 16:09:11 +01:00

windmill.dev

Open-source, self-hostable code-first platform for workflows, apps and AI agents, running on the fastest self-hostable orchestrator. Engineers write code in 20+ languages and sync it with Git. Business teams build on the same platform with AI, while review, promotion between environments and isolated workers keep engineers in control of what ships. Self-hostable alternative to Lovable, Retool, n8n and a simplified Temporal.

Scripts are turned into sharable UIs, APIs and cron jobs automatically, and can be composed together into flows, data pipelines, AI agents or full-code React and Svelte apps. Supported languages: Python, TypeScript, Go, Bash, SQL, GraphQL, PowerShell, Rust, and more.

Package version Docker Image CI Package version

Commit activity Discord Shield

Try it - Website - Docs - Discord - Hub - Contributing

Windmill - Code-first platform for workflows, apps and AI agents

Windmill is fully open-sourced (AGPLv3) and Windmill Labs offers dedicated instances and commercial support and licenses.

Windmill Diagram

https://github.com/user-attachments/assets/d80de1d9-64de-4d89-aacd-6df23fa81fc4

Build with AI, ship with review

Business teams and engineers build on the same Windmill instance. What the AI builds is an ordinary script, flow or app, and goes through the same review as code written by engineers:

  • AI sessions build scripts, flows and apps with AI in a workspace fork, with a live preview and a diff to review before deploying.
  • Workspace roles decide what each team can author, and folders scope the resources, skills and MCP servers its AI can reach.
  • Protection rulesets block direct deployment, so changes reach production only after an engineer reviews and deploys them.
  • Dev workspaces keep their own credentials, and promote to prod through Compare & Deploy or a Git pull request.
  • Worker groups run AI-built code on its own workers, or on a separate instance.

See let business teams build with AI safely for the full setup. Engineers keep writing code locally with the CLI, the VS Code extension and their coding agent, synced with Git.

Main Concepts

  1. Define a minimal and generic script in Python, TypeScript, Go or Bash that solves a specific task. The code can be defined in the provided Web IDE or synchronized with your own GitHub repo (e.g. through VS Code extension): provided Web IDE or synchronized with your own GitHub repo (e.g. through VS Code extension):

Step 1

  1. Your scripts parameters are automatically parsed and generate a frontend.

Step 2

Step 3

  1. Make it flow! You can chain your scripts or scripts made by the community shared on WindmillHub.

Step 3

  1. Build complex UIs on top of your scripts and flows.

Step 4

Scripts and flows can be triggered by schedules, webhooks, HTTP routes, Kafka, WebSockets, emails, and more.

Build your entire infra on top of Windmill!

What the code looks like

A script is a plain function. Its typed arguments become a generated form, an HTTP endpoint and a CLI command:

import * as wmill from "windmill-client";
import dayjs from "dayjs"; // any npm package, resolved and pinned automatically

export async function main(
  customerId: string,
  plan: "starter" | "pro", // a union of strings becomes a dropdown
  trialDays = 14 // defaults infer the type
) {
  const trialEnd = dayjs().add(trialDays, "day").toISOString();

  // a data table: the workspace's Postgres, queried without a connection string
  const sql = wmill.datatable();
  await sql`INSERT INTO trials (customer_id, plan, trial_end) VALUES (${customerId}, ${plan}, ${trialEnd})`.fetch();

  // secrets are permissioned by path
  const slackToken = await wmill.getVariable("f/sales/slack_token");
  await fetch("https://slack.com/api/chat.postMessage", {
    method: "POST",
    headers: { Authorization: `Bearer ${slackToken}`, "Content-Type": "application/json" },
    body: JSON.stringify({ channel: "#sales", text: `New ${plan} trial: ${customerId}` }),
  });

  console.log(`Trial started for ${customerId}`); // logs stream live in the UI
  return { customerId, plan, trialEnd }; // returned as JSON
}

Workflows are code too. Each task runs as its own job with its own logs, and waiting for an approval releases the worker:

import { task, waitForApproval, workflow } from "windmill-client";

async function plan(env: string) {
  return { env, changes: 3 };
}

async function apply(plan: { env: string; changes: number }) {
  return `applied ${plan.changes} changes to ${plan.env}`;
}

export const main = workflow(async (env: string) => {
  const changes = await task(plan)(env);
  const approval = await waitForApproval({ timeout: 3600 });
  if (!approval.approved) {
    return `rejected by ${approval.approver}`;
  }
  return await task(apply)(changes);
});

Flows can also be built in the visual flow editor or as YAML, with scripts like the first one as steps. See workflows as code.

Data: data tables, DuckDB and DuckLake

  • Data tables give each workspace managed Postgres tables, queried with type-checked SQL from TypeScript, Python and DuckDB scripts without exposing a connection string.
  • DuckDB scripts query S3 and Azure Blob files (CSV, Parquet, JSON), data tables, Postgres, MySQL and BigQuery in SQL, on your workers.
  • DuckLake stores large datasets as lakehouse tables in your workspace object storage, queried in plain SQL.
  • Pipelines (alpha) wire scripts by the data they read and write instead of a hand-drawn DAG. This script runs whenever events is materialized, and materializes its own table:
-- pipeline
-- on ducklake://main/events
-- materialize ducklake://main/events_by_kind
ATTACH 'ducklake://main' AS dl;
SELECT kind, count(*) AS n
FROM dl.events
GROUP BY kind;

Existing dbt projects run unmodified as scripts. See the pipelines quickstart.

Develop locally or in the browser

Engineers work from their editor and coding agent, business teams build with AI in the browser, and both land in the same workspace:

Tool Description
CLI Sync a workspace with local files and Git, run scripts and flows from the command line. wmill init generates AGENTS.md and skill files for Claude Code, Cursor and other AI tools
VS Code extension Edit and test scripts and flows from VS Code or Cursor with full IDE support
Git sync Two-way sync between a workspace and your Git repository
MCP server Let coding agents and AI clients run scripts, manage resources and monitor jobs in a workspace
AI sessions The same agent loop in the browser, with nothing to install: plan mode, skills and MCP servers, a live preview, and a diff to review before deploying, in a fork of the workspace

https://github.com/user-attachments/assets/c541c326-e9ae-4602-a09a-1989aaded1e9

You can run scripts locally by passing the right environment variables for the wmill client library to fetch resources and variables from your instance. See local development docs.

Stack

  • Database: Postgres (compatible with Aurora, Cloud SQL, Neon, Azure PostgreSQL)
  • Backend: Rust - stateless API servers and workers pulling jobs from a Postgres queue
  • Frontend: Svelte 5
  • Sandboxing: nsjail and PID namespace isolation
  • Runtimes:
    • TypeScript/JavaScript: Bun (default); Deno only on the windmill-full images
    • Python: python3 with uv for dependency management
    • PHP: only on the windmill-full images
    • Go, Bash, PowerShell, Rust, C#, Java, Ansible

Fastest Self-Hostable Workflow Engine

We have compared Windmill to other self-hostable workflow engines (Airflow, Prefect & Temporal) and Windmill is the most performant solution for both benchmarks: one flow composed of 40 lightweight tasks & one flow composed of 10 long-running tasks.

All methodology & results on our Benchmarks page.

Fastest workflow engine

Security

  • Sandboxing: nsjail for filesystem/resource isolation, and PID namespace isolation (enabled by default) to prevent jobs from accessing worker process memory
  • Secrets: One encryption key per workspace for credentials stored in Windmill's K/V store. We recommend encrypting the Postgres database as well.

See Security documentation for details.

Performance

Once a job started, there is no overhead compared to running the same script on the node with its corresponding runner (Deno/Go/Python/Bash). The added latency from a job being pulled from the queue, started, and then having its result sent back to the database is ~50ms. A typical lightweight deno job will take around 100ms total.

Architecture

Stateless API servers and workers share a PostgreSQL database that holds the job queue and all workspace state (remote agent workers go through the API servers instead). Workers pull jobs by tag, so each worker group can run in its own network, for example dev workers that only reach dev systems and prod workers that only run reviewed code.

Windmill architecture: business teams and engineers build through stateless API servers into workspaces, where changes move from dev and forks to prod after review. PostgreSQL holds the job queue and state. Worker groups for dev and prod, native workers and remote agent workers pull jobs by tag and reach your databases, APIs and AI model providers.

How to self-host

For detailed setup options, see Self-Host documentation.

Docker compose

Deploy Windmill with 3 files (docker-compose.yml, Caddyfile, .env):

curl https://raw.githubusercontent.com/windmill-labs/windmill/main/docker-compose.yml -o docker-compose.yml
curl https://raw.githubusercontent.com/windmill-labs/windmill/main/Caddyfile -o Caddyfile
curl https://raw.githubusercontent.com/windmill-labs/windmill/main/.env -o .env

docker compose up -d

Go to http://localhost - default credentials: admin@windmill.dev / changeme

Using an external database: Set DATABASE_URL in .env to point to your managed Postgres (AWS RDS, GCP Cloud SQL, Azure, Neon, etc.) and set db replicas to 0.

Kubernetes (Helm charts)

helm repo add windmill https://windmill-labs.github.io/windmill-helm-charts/
helm install windmill-chart windmill/windmill --namespace=windmill --create-namespace

See windmill-helm-charts for configuration options.

Cloud providers

Windmill works on AWS (EKS/ECS), GCP, Azure, Ubicloud, Fly.io, Render.com, Hetzner, Digital Ocean, and others. Rule of thumb: 1 worker per 1vCPU and 1-2 GB RAM.

OAuth, SSO & SMTP

Configure OAuth and SSO (Google Workspace, Microsoft/Azure, Okta) directly from the superadmin UI. See documentation.

License

  • Using the Community Edition as is, internally or through its APIs, is free and needs no commercial license, within the limits and quotas set in the software.
  • Selling, reselling or serving the Community Edition as a managed service, modifying or wrapping it, or re-exposing it to your users as a feature of your product (iframed public apps excepted) requires a commercial license: contact sales@windmill.dev.
  • The binary built from this repository without the enterprise feature flag is open source under AGPLv3: the same uses are then allowed under the AGPLv3 terms, or with a commercial license. The API clients and the OpenAPI spec are Apache 2.0.

See LICENSE for the full terms and Pricing for plans.

Integrations

In Windmill, integrations are referred to as resources and resource types. Each Resource has a Resource Type that defines the schema that the resource needs to implement.

On self-hosted instances, you might want to import all the approved resource types from WindmillHub. A setup script will prompt you to have it being synced automatically everyday.

Environment Variables

The variables most deployments set:

Environment Variable name Default Description Api Server/Worker/All
DATABASE_URL The Postgres database url. All
MODE standalone The mode of the binary: standalone, server, worker, agent (EE), indexer (EE image, full-text search), mcp All
WORKER_GROUP default The worker group the worker belongs to and gets its configuration pulled from Worker
BASE_URL http://localhost:8000 The base url that is exposed publicly to access your instance. Is overriden by the instance settings if any. Server
LICENSE_KEY (EE only) None License key checked at startup for the Enterprise Edition of Windmill Worker

All other variables (database pool, queue, runtimes, private registries, certificates, zombie jobs and more) are documented in the environment variables reference.

Contributing

At this time, we are not seeking outside contribution. Bug reports and feature requests remain very welcome, and small, trivially-verified PRs that fix a problem are still accepted. See CONTRIBUTING.md for the full policy.

To run Windmill from source, see frontend/README_DEV.md.

© 2023-2026 Windmill Labs, Inc.

S
Description
Open-source developer platform to power your entire infra and turn scripts into webhooks, workflows and UIs. Fastest workflow engine (13x vs Airflow). Open-source alternative to Retool and Temporal.
Readme
940 MiB
Languages
Rust 36.1%
TypeScript 25.2%
Svelte 23.8%
HTML 11.2%
JavaScript 1.4%
Other 2.1%