# Workflow Engine NEO, Multi-Tenant .NET Workflow Engine

Source: https://workflowengine.io/products/workflow-engine-neo/
Site index for agents: https://workflowengine.io/llms.txt (products, licensing, documentation hosts, package names).

**Workflow Engine NEO, the multi-tenant .NET workflow engine for SaaS**

[992 GitHub stars](https://github.com/optimajet/WorkflowEngine.NET) · Workflow Engine by Optimajet · v22.1.0 stable · August 2026 · HTTP API on .NET 8 or newer · Page last updated 9 October 2026

Serve every customer from one deployment of your .NET app. Workflow Engine NEO adds a ready HTTP API with tenant isolation, and new customers arrive without a restart.

Separate product based on [Workflow Engine](https://workflowengine.io/products/dotnet-workflow-engine/) · 30-day trial key, no credit card · Commercial EULA

[HTTP API](https://workflowengine.io/products/workflow-engine-neo/#api)

Data, RPC and Search endpoints, published by one MapWorkflowApi() call

[Multitenancy](https://workflowengine.io/products/workflow-engine-neo/#tenancy)

logical, physical or hybrid isolation, with tenants added while the app runs

[Workflow Forms](https://workflowengine.io/products/workflow-engine-neo/#forms)

forms for approvals and human tasks, in every edition of Workflow Engine NEO

[Self-hosted](https://workflowengine.io/products/workflow-engine-neo/#neo)

NuGet packages in your app and your database; Optimajet runs no NEO cloud

[Switch with a key](https://workflowengine.io/products/workflow-engine-neo/#migration)

an app on Workflow Engine moves to NEO with its schemes and history

[Fawry Lending](https://workflowengine.io/blog/fawry-lending-loan-processing-workflows/)

cut workflow changes from two weeks to a few days on Workflow Engine NEO

## Inside the app you already run, Workflow Engine NEO serves every one of your customers

Workflow Engine NEO is a separate product in the Workflow Engine Family by Optimajet. It is based on Workflow Engine and adds a ready ASP.NET Core HTTP API, multitenancy and forms integration to the application you already run.

One app · every customer · Workflow Engine NEO

Every request carries its customer in the Workflow-Api-Tenant-ID header, and the HTTP API scopes each process call to that customer. To give a customer its own database, copy its data there and change its registration.

- ### No workflow server to run

  NEO is NuGet packages inside your app. Optimajet runs no NEO cloud.

- ### No controllers to write

  One MapWorkflowApi() call publishes the HTTP API.

- ### New customers without a restart

  A tenant is registered while the app runs, since v22.0.0.

- ### Your data stays yours

  Your database, your identity system, your servers.

## Start from the project you are building

Pick the card closest to your project. It says what fits it and opens the page that answers it, on this site or in the documentation.

### [If you are moving off another engine](https://workflowengine.io/blog/best-net-workflow-engines/)

Temporal, Camunda, Elsa, Workflow Core or Windows Workflow Foundation. Our comparison of nine .NET options shows what each one needs to run and where the engine lives.

Read the comparison

### [If you build a .NET application](https://docs.workflowengine.io/get-started/)

Start on Workflow Engine Free with no license key. When you need more, register a key in the same app, with no rewrite.

Open Get Started

### [If your approvals need four eyes](https://docs.workflowengine.io/get-started/concepts/rule/)

A rule reads the transition history, so whoever submitted a change is not offered Approve, and the restriction check refuses it. This already works in Workflow Engine Free.

Open the Rule docs

### [If you embed a workflow editor in your product](https://docs.workflowengine.io/get-started/integrate-the-designer/)

Workflow Designer is a browser component with React and Angular wrappers on npm, and Blazor hosts it through JavaScript interop. In NEO, each tenant's users edit their own schemes.

Open the designer guide

### [If you build a SaaS platform](https://workflowengine.io/products/workflow-engine-neo/#try)

One HTTP API serves every tenant, isolated logically or physically. A coding agent sets up a trial with two tenants on your machine in about 15 minutes.

Try it in 15 minutes

### [If your backend is not .NET](https://workflowengine.io/products/workflow-server/)

Workflow Server runs as a separate service in Docker. Your Node.js, Python or Java code calls its REST API, and its Callback API calls your code back.

See Workflow Server

## Your customers edit their own workflows in Workflow Designer

Workflow Designer is the browser editor where your team and your customers' staff draw schemes. In Workflow Engine NEO you embed it for each tenant, so every customer changes its own process inside your product.

[Open the designer integration guide](https://docs.workflowengine.io/get-started/integrate-the-designer/)

### In your front end

React and Angular wrappers ship on npm, Blazor hosts the same component through JavaScript interop, and any other front end loads the vanilla package.

### Per tenant

Embedded through the HTTP API, the designer works in the tenant of the request. A scheme it saves belongs to that tenant, and a shared scheme can still serve every tenant.

### Code Actions off for customers

Turn Code Actions off for your customers' users, because Code Actions compile C# with full server access. Keep sensitive behavior in server-side actions your team reviews.

The [React](https://workflowengine.io/features/react-workflow-designer/), [Angular](https://workflowengine.io/features/angular-workflow-designer/), [Blazor](https://workflowengine.io/features/blazor-workflow-designer/) and [JavaScript](https://workflowengine.io/features/javascript-workflow-designer/) pages show how it embeds in each stack, and the [Workflow Designer](https://workflowengine.io/features/workflow-designer/) page covers the whole feature.

## A scheme the whole team can read

Simple Process Notation has three building blocks where BPMN has more than 50 element types. Everything else is a setting the designer draws in color and shape, so your customers' users, your analysts and your developers read a scheme the same way.

Workflow Designer · scheme view · Purchase request

Transitions

- Direct transition · Moves the process forward.
- Reverse transition · Sends it back, as Reject does.
- Unspecified transition · No direction is set.
- Selected transition · The transition you are editing.
- IsFork transition · Starts or ends a subprocess that runs in parallel.

Transition pills

- Command, timer or Auto · Names the command or timer that fires the transition. Auto means it fires on its own after the activity has run its actions.
- Restricted to actors · Only users who pass the actor rule may run the command.
- Otherwise · Taken when no other condition passes.
- Condition · Taken only when its condition is true.
- Timer · Fires after an interval or at a set time.

Activities

- Initial activity · Every new process starts here.
- Final activity · The process ends here.
- Current activity · Where a running process is now.
- Intermediary activity · Any step between the start and the end.
- Selected activity · The activity you are editing.

Activity implementation

- PreExecution implementation · Actions for Pre-Execution, the preview of a process's path.
- Execution implementation · Actions that run when the process enters the activity.
- Inline activity · Embeds a reusable scheme into this one.

Business users

The orange activity shows where a request is now. The arrows leaving it show what can happen next, and the person icon on a pill shows who may do it.

Analysts

Branching rules sit on the arrows. A ? marks a condition, and the Otherwise mark shows the path taken when no condition passes. The diagram you review with the business is the specification the engine runs.

Developers

Every mark is a property you can also set in C# or in the scheme XML. Classifier colors the arrow, Trigger names the pill and IsFork dashes the line. The runtime executes what was drawn.

## One deployment, many customers

One Workflow Engine NEO deployment serves many customers, called tenants, from one .NET application. You choose how strong the isolation is for each tenant, and one HTTP API host can mix the models.

### Logical tenants

Tenants share one `WorkflowRuntime` and one database. Records are isolated by `TenantId`. Lowest cost per tenant. Good for many small customers on shared infrastructure.

### Physical tenants

Each tenant gets its own database and its own `WorkflowRuntime`. Full isolation at the persistence layer, with per-tenant backup and restore. Good for enterprise customers with data-residency rules.

### Hybrid, both at once

One HTTP API host maps some tenant IDs to dedicated runtimes and databases, and groups other IDs on shared ones. One Workflow Engine NEO deployment can even serve tenants on different databases at the same time, for example two tenants on SQL Server and two on PostgreSQL, each physical tenant with its own connection string.

The engine side of this is covered in depth on the [multitenancy feature page](https://workflowengine.io/features/multi-tenancy/).

### Shared and tenant data, side by side

Since v22.0.0 a workflow scheme can belong to one tenant, or serve every tenant when it is saved without one. So one standard approval scheme can serve most customers, while a customer who pays for custom routing gets its own in the same installation. Forms work the same way: a tenant's own form wins, and a shared form is the fallback. Process data always stays with its tenant. The built-in Data API and RPC API operations use the exact tenant of the request, so a process saved without a tenant is not shared with a named one.

### Isolation the HTTP API enforces

A request names its tenant in the `Workflow-Api-Tenant-ID` header. Data API queries filter by that tenant, RPC operations check the process tenant, and a process of another tenant comes back as not found. The isolation covers statuses, parameters, timers, transition history, inbox entries and approval history, and the `TenantId` goes on to subprocesses. The header itself grants nothing. Register `AddWorkflowApiSecurity()` and the caller's permissions claim must also allow that tenant, or the request gets 403. Endpoints you write yourself and direct database access stay your application's job.

### Add a tenant without a restart

Since v22.0.0 the tenant registry accepts changes at runtime. A new customer signs up, your provisioning code registers the tenant, and existing tenants keep working. No deployment, no restart window.

Runtime tenant registration (since v22.0.0) · csharp

```csharp
// A new customer signs up. Register them as a tenant, at runtime:
var tenantRegistry = services.GetRequiredService<IWorkflowTenantRegistry>();

var tenants = await tenantRegistry.RegisterTenantsAsync(new WorkflowTenantCreationOptions
{
    TenantIds = ["TenantA"],
    PersistenceProviderId = PersistenceProviderId.Mssql,
    ConnectionString = connectionString
});

// No restart. Existing tenants keep processing their workflows.
// Offboarding is the same call in reverse:
await tenantRegistry.UnregisterTenantsAsync(tenants.Single());
```

Registration does not create the tenant's database or store its secrets; your provisioning code does that. Registered from `WorkflowTenantCreationOptions` as above, a tenant on SQL Server, PostgreSQL, MySQL, Oracle or SQLite gets its schema migrations run by default. MongoDB is set up separately.

## The HTTP API, registered at startup

The HTTP API is a set of ASP.NET Core endpoints inside your own application. You register tenants, add the database providers you use, wire the security services, and set the license key. Without a NEO or trial key, only the Designer and health endpoints answer.

Program.cs · csharp

```csharp
builder.Services.AddWorkflowApiCore(options =>
{
    options.LicenseKey = "your NEO license key";
    options.DefaultTenantId = null; // multi-tenant: every request must name a tenant
});

builder.Services.AddWorkflowTenants(
    new WorkflowTenantCreationOptions
    {
        // Physical tenant: own database, own WorkflowRuntime
        TenantIds = ["acme-corp"],
        PersistenceProviderId = PersistenceProviderId.Mssql,
        ConnectionString = "Server=db-acme;Database=Workflow;..."
    },
    new WorkflowTenantCreationOptions
    {
        // Logical tenants: two IDs share one database
        TenantIds = ["globex", "stark"],
        PersistenceProviderId = PersistenceProviderId.Postgres,
        ConnectionString = "Host=db-shared;Database=workflow;..."
    });

builder.Services.AddWorkflowApiMssql();
builder.Services.AddWorkflowApiPostgres();
builder.Services.AddWorkflowApiSecurity();

var app = builder.Build();
app.MapWorkflowApi();
```

### WorkflowApiCoreOptions, the settings you actually touch

| Name | Type | Default | Description |
| --- | --- | --- | --- |
| BasePath | string | "workflow-api" | Root URL path for all endpoints. |
| LicenseKey | string | "" | Required for the Data API and the RPC API. Without it the API still serves the Workflow Designer and the readiness and liveness probes. |
| DefaultTenantId | string? | SingleTenantId | Used when a request names no tenant. In multi-tenant mode, set it to null so every request must declare a tenant. |

Setup and security are covered step by step in the [HTTP API documentation](https://workflowengine.io/documentation/web-api).

## Run a multi-tenant approval on your machine in 15 minutes

Workflow Engine NEO runs inside your ASP.NET Core app, with no cluster to set up. Its HTTP API and tenant isolation come ready. That is why a coding agent can build the whole trial while you watch.

### An approval over HTTP

Tenant acme moves its request from Draft to Approved with one call. You write no controller for it.`rpc/execute-command → 200, "wasExecuted": true`

### A 404 for the other tenant

Tenant globex asks for acme's process and is told it does not exist. The HTTP API scopes every process call to the tenant in the request header.`rpc/get-process-instance → 404, "code": "NotFound"`

### The scheme in Workflow Designer

The same approval opens in the visual editor. You can embed that editor in your app for each tenant's users.`npx @optimajet/workflow-designer … Approval`

The prompt

The agent writes the boilerplate for you: the project, the packages, Program.cs and each request. Everything stays in one folder on your machine, and the code is yours to keep as the start of a proof of concept.

1. Copy the prompt into Claude Code, Cursor or Copilot.

2. Give your business email and say yes. The agent requests a free 30-day trial key.

3. Watch it create the app, register two tenants and send the requests.

4. Read every request and response it shows you, then open the scheme.

Read the prompt before you paste it

```
Set up a local trial of Workflow Engine NEO by Optimajet for me: one ASP.NET Core app whose HTTP API serves two tenants, with one approval run for each. Follow the documentation pages named below and copy code from the rendered pages, not from llms-full.txt.

1. Check for the .NET 8 SDK or newer (dotnet --list-sdks). If it is missing, stop and tell me.

2. Get the license key before the first run: multitenancy, the Data API and the RPC API need a Workflow Engine NEO key or a trial key. If I give you a key, use it. If not, say that you will send my business email and company name to POST https://trial.workflowengine.io/api/trial/llm (see https://trial.workflowengine.io/llms.txt), ask me for both, wait for my yes, and send one request. The portal gives 3 keys per address, ever, and refuses personal email domains. Keep the key in dotnet user-secrets as Workflow:LicenseKey, never in source code or git.

3. Create the app as https://docs.workflowengine.io/get-started/install-workflow-engine/ shows, with OptimaJet.Workflow.Api and OptimaJet.Workflow.Api.Sqlite. The page targets net10.0; with an older SDK use its framework (net8.0 works). Replace AddWorkflowRuntime with AddWorkflowTenants and one WorkflowTenantCreationOptions: TenantIds ["acme", "globex"], PersistenceProviderId.Sqlite (namespace OptimaJet.Workflow.Core), one SQLite file, runtime.AsSingleServer(). In AddWorkflowApiCore, read LicenseKey from configuration and set DefaultTenantId = "acme" for this local trial only, because the standalone Workflow Designer sends no tenant header. Keep the allow-any-origin CORS policy for development only. Start it with dotnet run -- --urls http://localhost:5274.

4. Follow https://docs.workflowengine.io/get-started/create-your-first-workflow/ with two changes: rename the command Submit to Approve everywhere, and send the header Workflow-Api-Tenant-ID on every request, the Designer API calls included. Upload and save the scheme for acme and again for globex: a scheme saved through the Designer API belongs to the tenant of the request. For acme, create an instance, get the available commands, execute Approve and read the instance back (it must be at Approved). For globex, create an instance and leave it at Draft.

5. Show the tenant isolation: rpc/get-process-instance for the acme process with the globex header must answer 404.

6. Open the scheme in Workflow Designer: npx @optimajet/workflow-designer http://localhost:5274/workflow-api/designer Approval (it needs Node.js and opens a browser tab on macOS and Windows).

7. Show me each request with its response, then point me to https://workflowengine.io/products/workflow-engine-neo/ for tenancy and permissions, and to https://workflowengine.io/book-a-demo/ to discuss my own case.
```

When the trial runs, the next question is your own tenancy model. Bring it to a one-hour demo, or first read how [tenants](https://workflowengine.io/products/workflow-engine-neo/#tenancy) and [permissions](https://workflowengine.io/products/workflow-engine-neo/#permissions) work in Workflow Engine NEO.

You need the .NET 8 SDK and Node.js. Without an agent, follow [Install Workflow Engine](https://docs.workflowengine.io/get-started/install-workflow-engine/) in the documentation and request the key at [trial.workflowengine.io](https://trial.workflowengine.io/).

## Forms for every approval step, per tenant

Every approval and human task needs a screen. With the Forms Plugin, in every edition of Workflow Engine NEO, you attach a form to a step with the "Show Form" activity, and the runtime serves it when a process gets there. A tenant can have its own form, with a shared one as the fallback.

![The Form Engine Designer interface. A component palette on the left groups Inputs, Data display, Feedback, Layout, Surfaces, Navigation and Form elements; the centre canvas shows a Complex Master Form with name, email, address and country fields; the toolbar carries a UI-kit selector set to Material UI and a Copy form's JSON button; the right panel edits the selected element under Main, Style, Actions and Rules tabs.](https://workflowengine.io/images/formengine-form-builder.jpg)

A form built in Form Engine Designer, part of [Form Engine](https://formengine.io/), the Optimajet forms product family. The form's data travels as one object through the input, draft and output process parameters you name.

Registering the Forms Plugin · csharp

```csharp
var formsSettings = new FormsPluginSettings
{
    FormsManagerUrl = "https://forms.example.com"
};
runtime.WithPlugin(new FormsPlugin(formsSettings));
```

Build the form in Form Engine Designer, or write its JSON yourself. Changing a form needs no redeploy. The [workflow forms page](https://workflowengine.io/features/workflow-forms/) shows which steps need a form and what the binding saves you writing.

Your back end calls `FormsRuntimeApi`, and an endpoint of your own hands the result to the browser. `GetExecutableFormsAsync()` returns the current step's forms with their definition and data, `SaveFormAsync()` keeps a draft, and `ExecuteFormAsync()` submits the data and runs the workflow command in one call. `GetFormAsync()` and `GetProcessFormAsync()` load a single form.

### Drafts and versions built in

A user can fill half a form, save a draft and come back later. Form definitions are versioned. Pin a version in the step's settings, or leave it empty and each lookup takes the latest one.

### Works with every provider

All six database providers (SQL Server, PostgreSQL, MongoDB, MySQL, Oracle, SQLite) store form definitions. Submitted data lands in the process parameters you name, with no extra tables for it. Server-side rules run once you register your own `IFormValidator`, because the default one accepts any data. For React front ends, [`@optimajet/workflow-forms-manager`](https://www.npmjs.com/package/@optimajet/workflow-forms-manager) and [`@optimajet/workflow-forms-viewer`](https://www.npmjs.com/package/@optimajet/workflow-forms-viewer) ship on npm.

### Form Engine licensing is separate

Form Engine Core renders and validates forms under the MIT license. The Form Engine Enterprise license covers Form Engine Designer and the other features of that edition. It is priced separately for NEO Subscription, Business, and SaaS; NEO Enterprise includes it with OEM rights. Since v22.0.0 the Forms Plugin runs tenant-aware on Form Engine Core 10.0.1: a tenant-specific form wins, and a shared form is the fallback.

Elsa Workflows 3.7 leaves forms, the inbox and human-task permissions to your application. Our comparison of August 2026 builds [one approval process in both engines](https://workflowengine.io/blog/elsa-vs-workflow-engine/#approval-process).

## Permissions per operation and per tenant

Once you register `AddWorkflowApiSecurity()`, NEO authorizes each API call through a `WorkflowApiPermissions` claim attached to the caller. The claim is a compact string of allow and deny rules over a hierarchical operation namespace, plus tenant rules. More specific rules win.

Claim format · bash

```bash
<effect>:<target>[;<effect>:<target>]
# effect: a (allow) | d (deny)
# target: operation branch under workflow-api  OR  tenant rule under tenants
```

The string is small enough to travel in a JWT payload, and a typed builder API composes it. Authentication itself stays standard ASP.NET Core middleware (JWT bearer tokens, cookies, any registered scheme); the engine keeps no parallel user store of its own.

### Examples

| Value | Meaning |
| --- | --- |
| a:workflow-api | Allow all Workflow Engine API operations. |
| d:workflow-api | Deny all. |
| d:workflow-api;a:workflow-api.rpc | Deny everything except the RPC branch. |
| a:workflow-api;d:workflow-api.rpc.delete-instance | Allow everything except delete-instance. |
| a:tenants:TenantA,TenantB | Restrict the caller to TenantA and TenantB. |
| d:tenants:TenantA,TenantB | Allow all tenants except TenantA and TenantB. |

Builder API · csharp

```csharp
// Strict allow-list
var claim = permissions.BuildClaim(builder => builder
    .DenyAllOperations()
    .Allow(
        WorkflowApiOperationId.Liveness,
        WorkflowApiOperationId.DataSchemesGetCollection,
        WorkflowApiOperationId.DataSchemesGet)
    .DenyAllTenantsExcept("TenantA"));

// Branch allow + specific deny
var claim = permissions.BuildClaim(builder => builder
    .DenyAllOperations()
    .Allow("workflow-api.rpc")
    .Deny(WorkflowApiOperationId.RpcDeleteInstance)
    .AllowAllTenants());
```

## Switch now, add Workflow Engine NEO capabilities when you need them

On the same product version, moving from Workflow Engine to Workflow Engine NEO requires only registering the Workflow Engine NEO license key. Your runtime integration, schemes, processes and history carry over. Adopt the newly licensed features one at a time.

1. `WorkflowRuntime.RegisterLicense("NEO-...")`

   Register the Workflow Engine NEO license key. That is the product switch; it does not require a scheme or integration rewrite.

2. `Optional feature packages`

   Install packages only for the capabilities you choose. For the HTTP API, add [`OptimaJet.Workflow.Api`](https://www.nuget.org/packages/OptimaJet.Workflow.Api/) and its provider integration; forms use the Forms Plugin package.

3. `AddWorkflowRuntime(...) or AddWorkflowTenants(...)`

   If you expose the HTTP API, connect it to your existing runtime or configure logical, physical, or hybrid tenant placement.

4. `MapWorkflowApi() + AddWorkflowApiSecurity(...)`

   Map and secure any endpoints you expose so callers carry the `WorkflowApiPermissions` claim. Without a NEO or trial key, Designer and health endpoints remain available, while Data, Search, and RPC stay disabled.

Moving to v22.0.0 is a real upgrade on its own, for any product. It has breaking changes and mandatory database migrations, and the release notes pair each change with a migration scenario.

## Common questions

Direct answers to the questions teams ask while evaluating Workflow Engine NEO: the HTTP API, multitenancy, forms, editions, and licensing.

1. ### What is Workflow Engine NEO?

   Workflow Engine NEO is a separate SaaS-oriented product in the Workflow Engine Family by Optimajet, based on Workflow Engine since v19.0.0. It includes a ready-to-use HTTP API (Data, RPC, and Search endpoints), full hybrid multitenancy, multi-server clustering, and forms integration with Form Engine through the Forms Plugin.

2. ### Is Workflow Engine NEO the same as the Workflow Engine HTTP API in the documentation?

   No. Workflow Engine NEO is the product; Workflow Engine HTTP API is one of the capabilities it includes. The OptimaJet.Workflow\.Api package supplies the API, while the legacy documentation at workflowengine.io/documentation/web-api calls the same component the Workflow Engine Web API, its former name. Its Data API, RPC API, multitenancy, and security services describe the HTTP capability included with Workflow Engine NEO.

3. ### How is Workflow Engine NEO different from Workflow Engine?

   They are separate products. Workflow Engine NEO is based on Workflow Engine, and every edition of Workflow Engine NEO includes the HTTP API, full multitenancy, and the Forms Plugin. In Workflow Engine, multitenancy is a building block: the runtime stores the TenantId you supply when a process is created and passes it to subprocesses, and your application designs the isolation and controls access. If the HTTP API package is installed without a NEO key, it still serves the Designer API and the readiness and liveness probes, while the Data, Search, and RPC endpoints stay closed.

4. ### Do I need Workflow Engine NEO to add workflow to an ASP.NET web app?

   Not always. Workflow Engine and Workflow Engine Free are .NET libraries. You call them from C# inside your own process, so they power ASP.NET apps without Workflow Engine NEO. Choose Workflow Engine NEO when you drive workflow over HTTP: a JavaScript or mobile frontend, a Python or Java service, or several services that call one workflow API. The product includes that API ready-made, so you do not write controllers around the runtime.

5. ### Is NEO a hosted service run by Optimajet?

   No. Workflow Engine NEO is an embeddable product. You install NuGet packages, host the HTTP API in your own infrastructure, point it at your own database, and operate it. Optimajet does not run a NEO cloud. If you want a turnkey product, look at Workflow Server, a separate Optimajet product on workflowserver.io.

6. ### What is hybrid multitenancy?

   Hybrid multitenancy means tenants with their own database and tenants that share one live in one installation, behind one HTTP API host. Since v22.0.0 a workflow scheme can belong to one tenant or, saved without one, serve every tenant, and a tenant's own form wins over a shared one. Process data always stays with its tenant, because the built-in Data API and RPC API operations use the exact tenant of the request.

7. ### Can I add a new tenant without restarting the application?

   Yes, since v22.0.0. The tenant registry accepts changes at runtime: IWorkflowTenantRegistry.RegisterTenantsAsync adds tenants and UnregisterTenantsAsync removes them while the host keeps running. Existing tenants keep processing their workflows. Onboarding a customer becomes a database operation, not a deployment.

8. ### Can one tenant see another tenant's data?

   Not through the HTTP API. Data API queries filter by the selected tenant, and RPC API operations check the process tenant. A process from another tenant comes back as not found, so one tenant cannot even probe whether another tenant's data exists. The isolation covers statuses, parameters, timers, transition history, inbox entries and approval history. With AddWorkflowApiSecurity() registered, a caller also reaches only the tenants its permissions claim allows. Endpoints you write yourself and direct database access stay your application's responsibility.

9. ### How do permissions work in NEO?

   Through a WorkflowApiPermissions claim attached to the caller. The claim is a compact string of allow and deny rules. The format is effect:target pairs separated by semicolons, where the effect is a (allow) or d (deny) and the target is an operation branch under workflow-api or a tenant rule under tenants. Example: d:workflow-api;a:workflow-api.rpc;a:tenants:TenantA means deny everything, allow the RPC branch, and restrict the caller to TenantA. More specific rules win.

10. ### Does NEO include the Form Engine Enterprise license?

    Every edition of Workflow Engine NEO includes the Forms Plugin. Form Engine Core renders and validates forms under the MIT license. The Form Engine Enterprise license covers Form Engine Designer and the other features of that edition. It is priced separately for Workflow Engine NEO Subscription, Business, and SaaS; Workflow Engine NEO Enterprise includes it with OEM rights. All six database providers (SQL Server, PostgreSQL, MongoDB, MySQL, Oracle, SQLite) store form definitions.

11. ### Can I switch from Workflow Engine to Workflow Engine NEO without rewriting code?

    Yes. For an existing application on the same product version, moving from Workflow Engine to Workflow Engine NEO requires only registering the Workflow Engine NEO license key. Your existing schemes, processes, data, and Workflow Runtime integration continue unchanged. You can adopt Workflow Engine NEO capabilities gradually; install and configure the Workflow Engine HTTP API only if you choose to expose it.

12. ### What .NET version does NEO need?

    The HTTP API package (OptimaJet.Workflow\.Api) needs .NET 8 or newer; the 21.0.0 release dropped .NET 6 from the HTTP API and added .NET 10 support. The underlying WorkflowEngine.NETCore-Core library targets netstandard2.0, so the engine itself runs on the same range of .NET versions as base Workflow Engine.

13. ### Which editions does Workflow Engine NEO have?

    Workflow Engine NEO has four editions: Subscription, Business, SaaS, and Enterprise. Subscription is annual for public SaaS platforms. Business is a perpetual license for internal applications. SaaS is a perpetual license for public platforms. Enterprise adds Workflow Engine redistribution rights, a white-label Workflow Designer, the Form Engine Enterprise license with OEM rights, and source code access. All four editions include the APIs, clustering, and full hybrid multitenancy. The full matrix is on the pricing page.

14. ### How do I try NEO?

    Request a free 30-day trial key at trial.workflowengine.io. No credit card is required. The trial covers the HTTP API, full multitenancy, and the Forms Plugin; install and configure the capabilities you want to evaluate. The portal also publishes llms.txt instructions, so an AI coding agent can walk through the trial key generation for you.

15. ### How fast is Workflow Engine NEO?

    Our published benchmark measured Workflow Engine at 250 operations per second on a high-performance server. Workflow Engine NEO runs the same engine and adds its HTTP API layer. If you need many thousands of operations per second, you are likely outside the business-process category and should look at stream processors.

16. ### How mature is Workflow Engine NEO?

    The underlying Workflow Engine has been in production since 2014 and is used by Dell, KPMG, Bosch, Philips, GE Honda Aero Engines, ProcessMAP, and Nelnet. The HTTP API capability first shipped in v14.0.0 (August 2024). The RPC API and full multitenancy shipped in v19.0.0 (September 2025). Dynamic tenant registration and hybrid multitenancy shipped in v22.0.0 (July 2026).

## HTTP API overview, trial key, and a demo when you are ready

See what the HTTP API gives you, try it with a free 30-day trial key, and bring your tenancy and licensing questions to a demo.

1. 01Documentation

   ### Read the HTTP API overview

   What the ready-to-use API covers: Data, RPC, and Search endpoints, hybrid multitenancy, security services. About an hour from install to a running HTTP API.

   [Read the HTTP API overview](https://docs.workflowengine.io/evaluate/workflow-engine-features/http-api/)

2. 02Trial

   ### Get a NEO trial key

   A free 30-day key, no credit card. The trial covers the HTTP API, full multitenancy, and the Forms Plugin; connect the capabilities you want to evaluate.

   [Get a trial key](https://trial.workflowengine.io/)

3. 03Book a demo

   ### See NEO on your scenario

   An hour with the team: tenancy topology for your SaaS, forms integration for approvals and human tasks, editions, migration questions.

   [Book a demo](https://workflowengine.io/book-a-demo/)

## Sitemap

[Sitemap of workflowengine.io](https://workflowengine.io/sitemap.md): every page of the site, with the description each page carries.