CamundaClient

Technical Preview

The C# SDK is a technical preview available from Camunda 8.9. It will become fully supported in Camunda 8.10. Its API surface may change in future releases without following semver.

Creating a Client

Factory method for creating CamundaClient instances.

public static CamundaClient CreateClient(CamundaOptions? options = null)

Create a new CamundaClient.

Parameter	Type	Description
options	CamundaOptions

Dependency Injection

Extension methods for registering CamundaClient in an DependencyInjection.IServiceCollection.

AddCamundaClient(IServiceCollection)

public static IServiceCollection AddCamundaClient(this IServiceCollection services)

Registers a singleton CamundaClient using zero-config (environment variables only).

Parameter	Type	Description
services	IServiceCollection

AddCamundaClient(IServiceCollection, IConfiguration)

public static IServiceCollection AddCamundaClient(this IServiceCollection services, IConfiguration configurationSection)

Registers a singleton CamundaClient using an Configuration.IConfiguration section.

Typically called as services.AddCamundaClient(configuration.GetSection("Camunda")). PascalCase keys in the section are mapped to canonical CAMUNDA_* env-var names internally. Environment variables still apply as a base layer; section values override them.

Parameter	Type	Description
services	IServiceCollection
configurationSection	IConfiguration

AddCamundaClient(IServiceCollection, Action<CamundaOptions>)

public static IServiceCollection AddCamundaClient(this IServiceCollection services, Action<CamundaOptions> configure)

Registers a singleton CamundaClient with an options callback for full control.

Parameter	Type	Description
services	IServiceCollection
configure	Action<CamundaOptions>

Overview

Primary Camunda client. Provides typed methods for all Camunda 8 REST API operations.

Auto-generated operation methods are added in the Generated/ partial class files. This class provides the infrastructure: configuration, auth, retry, backpressure.

public class CamundaClient : IDisposable, IAsyncDisposable

Constructor

public CamundaClient(CamundaOptions? options = null)

Create a new CamundaClient with the given options.

Parameter	Type	Description
options	CamundaOptions

Properties

Property	Type	Description
Config	CamundaConfig	The current hydrated configuration (read-only).

Methods

Other

Create(CamundaOptions?)

public static CamundaClient Create(CamundaOptions? options = null)

Create a new CamundaClient.

Parameter	Type	Description
options	CamundaOptions

Returns: CamundaClient

Dispose()

public void Dispose()

Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.

DisposeAsync()

public ValueTask DisposeAsync()

Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources asynchronously.

Returns: ValueTask — A task that represents the asynchronous dispose operation.

ChangeClusterModeAsync(string, bool?, CancellationToken)

public Task<ClusterModeChangeResponse> ChangeClusterModeAsync(string mode, bool? dryRun = null, CancellationToken ct = default)

Change cluster mode

Transitions the cluster between processing and recovery mode. This is a non-blocking operation: the request is acknowledged once the change has been accepted, before the transition itself has completed. Entering recovery mode deactivates all partitions so that only a restricted set of read-only operations remains available; exiting recovery mode returns the cluster to normal processing. Returns the planned cluster change so its progress can be monitored via the topology.

Parameter	Type	Description
mode	String
dryRun	Nullable<Boolean>
ct	CancellationToken

Returns: Task<ClusterModeChangeResponse>

Example

public static async Task ChangeClusterModeExample()
{
    using var client = CamundaClient.Create();

    // Pass dryRun: true to validate the request and inspect the resulting plan
    // without applying it. Omit it (or set it to false) to trigger the transition.
    var change = await client.ChangeClusterModeAsync("RECOVERING", dryRun: true);

    Console.WriteLine($"Cluster change {change.ChangeId}:");
    foreach (var operation in change.PlannedChanges)
    {
        var suffix = operation.Mode is null ? "" : $" -> {operation.Mode}";
        Console.WriteLine($"  {operation.Operation}{suffix}");
    }
}

CreateAdminUserAsync(UserRequest, CancellationToken)

public Task<UserCreateResult> CreateAdminUserAsync(UserRequest body, CancellationToken ct = default)

Create admin user

Creates a new user and assigns the admin role to it. This endpoint is only usable when users are managed in the Orchestration Cluster and while no user is assigned to the admin role.

Parameter	Type	Description
body	UserRequest
ct	CancellationToken

Returns: Task<UserCreateResult>

Example

public static async Task CreateAdminUserExample(Username username)
{
    using var client = CamundaClient.Create();

    var result = await client.CreateAdminUserAsync(new UserRequest
    {
        Username = username,
        Name = "Admin User",
        Email = "admin@example.com",
        Password = "admin-password",
    });

    Console.WriteLine($"Admin user key: {result.Username}");
}

CreateAgentInstanceAsync(AgentInstanceCreationRequest, CancellationToken)

public Task<AgentInstanceCreationResult> CreateAgentInstanceAsync(AgentInstanceCreationRequest body, CancellationToken ct = default)

Create agent instance

Creates a new agent instance. The returned key identifies the instance and must be used in subsequent update and query calls.

Parameter	Type	Description
body	AgentInstanceCreationRequest
ct	CancellationToken

Returns: Task<AgentInstanceCreationResult>

Example

public static async Task CreateAgentInstanceExample(ElementInstanceKey elementInstanceKey)
{
    using var client = CamundaClient.Create();

    var result = await client.CreateAgentInstanceAsync(new AgentInstanceCreationRequest
    {
        ElementInstanceKey = elementInstanceKey,
        Definition = new AgentInstanceDefinition
        {
            Model = "gpt-4o",
            Provider = "openai",
            SystemPrompt = "You are a helpful assistant.",
        },
    });

    Console.WriteLine($"Created agent instance: {result.AgentInstanceKey}");
}

CreateAgentInstanceHistoryItemAsync(AgentInstanceKey, AgentInstanceHistoryItemRequest, CancellationToken)

public Task<AgentInstanceHistoryItemCreationResult> CreateAgentInstanceHistoryItemAsync(AgentInstanceKey agentInstanceKey, AgentInstanceHistoryItemRequest body, CancellationToken ct = default)

Create agent instance history item

Appends a single history item to an agent instance's conversation history. The created item has commitStatus PENDING until the job identified by jobLease completes successfully, at which point it transitions to COMMITTED. If the job fails or is superseded by a retry, the item is marked DISCARDED.

Parameter	Type	Description
agentInstanceKey	AgentInstanceKey
body	AgentInstanceHistoryItemRequest
ct	CancellationToken

Returns: Task<AgentInstanceHistoryItemCreationResult>

Example

public static async Task CreateAgentInstanceHistoryItemExample(
    AgentInstanceKey agentInstanceKey,
    ElementInstanceKey elementInstanceKey,
    JobKey jobKey,
    string jobLease)
{
    using var client = CamundaClient.Create();

    var result = await client.CreateAgentInstanceHistoryItemAsync(
        agentInstanceKey,
        new AgentInstanceHistoryItemRequest
        {
            ElementInstanceKey = elementInstanceKey,
            JobKey = jobKey,
            JobLease = jobLease,
            Role = AgentInstanceHistoryRoleEnum.ASSISTANT,
            Content = new List<AgentInstanceMessageContent>
            {
                new AgentInstanceTextContent { Text = "How can I help you today?" },
            },
            ProducedAt = DateTimeOffset.UtcNow,
        });

    Console.WriteLine($"Created history item: {result.HistoryItemKey}");
}

CreateGlobalTaskListenerAsync(CreateGlobalTaskListenerRequest, CancellationToken)

public Task<GlobalTaskListenerResult> CreateGlobalTaskListenerAsync(CreateGlobalTaskListenerRequest body, CancellationToken ct = default)

Create global user task listener

Create a new global user task listener.

Parameter	Type	Description
body	CreateGlobalTaskListenerRequest
ct	CancellationToken

Returns: Task<GlobalTaskListenerResult>

Example

public static async Task CreateGlobalTaskListenerExample(GlobalListenerId id)
{
    using var client = CamundaClient.Create();

    var result = await client.CreateGlobalTaskListenerAsync(
        new CreateGlobalTaskListenerRequest
        {
            EventTypes = new List<GlobalTaskListenerEventTypeEnum> { GlobalTaskListenerEventTypeEnum.Completing },
            Id = id,
        });

    Console.WriteLine($"Task listener: {result.Id}");
}

CreateUserAsync(UserRequest, CancellationToken)

public Task<UserCreateResult> CreateUserAsync(UserRequest body, CancellationToken ct = default)

Create user

Create a new user.

Parameter	Type	Description
body	UserRequest
ct	CancellationToken

Returns: Task<UserCreateResult>

Example

public static async Task CreateUserExample(Username username)
{
    using var client = CamundaClient.Create();

    var result = await client.CreateUserAsync(new UserRequest
    {
        Username = username,
        Name = "Jane Doe",
        Email = "jdoe@example.com",
        Password = "secure-password",
    });

    Console.WriteLine($"User key: {result.Username}");
}

DeleteGlobalTaskListenerAsync(GlobalListenerId, CancellationToken)

public Task DeleteGlobalTaskListenerAsync(GlobalListenerId id, CancellationToken ct = default)

Delete global user task listener

Deletes a global user task listener.

Parameter	Type	Description
id	GlobalListenerId
ct	CancellationToken

Returns: Task

Example

public static async Task DeleteGlobalTaskListenerExample(GlobalListenerId globalListenerId)
{
    using var client = CamundaClient.Create();

    await client.DeleteGlobalTaskListenerAsync(
        globalListenerId);
}

DeleteUserAsync(Username, CancellationToken)

public Task DeleteUserAsync(Username username, CancellationToken ct = default)

Delete user

Deletes a user.

Parameter	Type	Description
username	Username
ct	CancellationToken

Returns: Task

Example

public static async Task DeleteUserExample(Username username)
{
    using var client = CamundaClient.Create();

    await client.DeleteUserAsync(username);
}

EvaluateConditionalsAsync(ConditionalEvaluationInstruction, CancellationToken)

public Task<EvaluateConditionalResult> EvaluateConditionalsAsync(ConditionalEvaluationInstruction body, CancellationToken ct = default)

Evaluate root level conditional start events

Evaluates root-level conditional start events for process definitions. If the evaluation is successful, it will return the keys of all created process instances, along with their associated process definition key. Multiple root-level conditional start events of the same process definition can trigger if their conditions evaluate to true.

Parameter	Type	Description
body	ConditionalEvaluationInstruction
ct	CancellationToken

Returns: Task<EvaluateConditionalResult>

Example

public static async Task EvaluateConditionalsExample()
{
    using var client = CamundaClient.Create();

    var result = await client.EvaluateConditionalsAsync(
        new ConditionalEvaluationInstruction());

    Console.WriteLine($"Result: {result}");
}

EvaluateExpressionAsync(ExpressionEvaluationRequest, CancellationToken)

public Task<ExpressionEvaluationResult> EvaluateExpressionAsync(ExpressionEvaluationRequest body, CancellationToken ct = default)

Evaluate an expression

Evaluates a FEEL expression and returns the result. Supports references to tenant scoped cluster variables when a tenant ID is provided. Optionally, provide a scopeKey to make the variables of a specific process instance or element instance visible while evaluating the expression.

Parameter	Type	Description
body	ExpressionEvaluationRequest
ct	CancellationToken

Returns: Task<ExpressionEvaluationResult>

Example

public static async Task EvaluateExpressionExample()
{
    using var client = CamundaClient.Create();

    var result = await client.EvaluateExpressionAsync(
        new ExpressionEvaluationRequest
        {
            Expression = "= 1 + 2",
        });

    Console.WriteLine($"Result: {result.Result}");
}

GetAgentInstanceAsync(AgentInstanceKey, ConsistencyOptions<AgentInstanceResult>?, CancellationToken)

public Task<AgentInstanceResult> GetAgentInstanceAsync(AgentInstanceKey agentInstanceKey, ConsistencyOptions<AgentInstanceResult>? consistency = null, CancellationToken ct = default)

Get agent instance

Returns agent instance as JSON.

Parameter	Type	Description
agentInstanceKey	AgentInstanceKey
consistency	ConsistencyOptions<AgentInstanceResult>
ct	CancellationToken

Returns: Task<AgentInstanceResult>

Example

public static async Task GetAgentInstanceExample(AgentInstanceKey agentInstanceKey)
{
    using var client = CamundaClient.Create();

    var result = await client.GetAgentInstanceAsync(agentInstanceKey);
    Console.WriteLine($"Agent instance: {result.AgentInstanceKey}, status: {result.Status}");
}

GetFormByKeyAsync(FormKey, ConsistencyOptions<FormResult>?, CancellationToken)

public Task<FormResult> GetFormByKeyAsync(FormKey formKey, ConsistencyOptions<FormResult>? consistency = null, CancellationToken ct = default)

Get form by key

Get a form by its unique form key.

Parameter	Type	Description
formKey	FormKey
consistency	ConsistencyOptions<FormResult>
ct	CancellationToken

Returns: Task<FormResult>

Example

public static async Task GetFormByKeyExample(FormKey formKey)
{
    using var client = CamundaClient.Create();

    var result = await client.GetFormByKeyAsync(formKey);
    Console.WriteLine($"Form: {result.FormId}, version: {result.Version}");
}

GetGlobalTaskListenerAsync(GlobalListenerId, ConsistencyOptions<GlobalTaskListenerResult>?, CancellationToken)

public Task<GlobalTaskListenerResult> GetGlobalTaskListenerAsync(GlobalListenerId id, ConsistencyOptions<GlobalTaskListenerResult>? consistency = null, CancellationToken ct = default)

Get global user task listener

Get a global user task listener by its id.

Parameter	Type	Description
id	GlobalListenerId
consistency	ConsistencyOptions<GlobalTaskListenerResult>
ct	CancellationToken

Returns: Task<GlobalTaskListenerResult>

Example

public static async Task GetGlobalTaskListenerExample(GlobalListenerId globalListenerId)
{
    using var client = CamundaClient.Create();

    var result = await client.GetGlobalTaskListenerAsync(
        globalListenerId);

    Console.WriteLine($"Task listener: {result.EventTypes}");
}

GetStatusAsync(CancellationToken)

public Task GetStatusAsync(CancellationToken ct = default)

Get cluster status

Checks the health status of the cluster by verifying if there's at least one partition with a healthy leader.

Parameter	Type	Description
ct	CancellationToken

Returns: Task

Example

public static async Task GetStatusExample()
{
    using var client = CamundaClient.Create();

    await client.GetStatusAsync();
    Console.WriteLine("Cluster is healthy");
}

GetSystemConfigurationAsync(CancellationToken)

public Task<SystemConfigurationResponse> GetSystemConfigurationAsync(CancellationToken ct = default)

System configuration (alpha)

Returns the current system configuration. The response is an envelope that groups settings by feature area.

This endpoint is an alpha feature and may be subject to change in future releases.

Parameter	Type	Description
ct	CancellationToken

Returns: Task<SystemConfigurationResponse>

Example

public static async Task GetSystemConfigurationExample()
{
    using var client = CamundaClient.Create();

    var result = await client.GetSystemConfigurationAsync();
    Console.WriteLine($"System config: {result}");
}

GetUserAsync(Username, ConsistencyOptions<UserResult>?, CancellationToken)

public Task<UserResult> GetUserAsync(Username username, ConsistencyOptions<UserResult>? consistency = null, CancellationToken ct = default)

Get user

Get a user by its username.

Parameter	Type	Description
username	Username
consistency	ConsistencyOptions<UserResult>
ct	CancellationToken

Returns: Task<UserResult>

ResolveSecretsAsync(SecretResolveRequest, CancellationToken)

public Task<SecretResolveResult> ResolveSecretsAsync(SecretResolveRequest body, CancellationToken ct = default)

Resolve secrets (alpha)

Resolve a deduplicated batch of camunda.secrets.* references for the caller's physical tenant in a single round-trip.

Each reference is authorized and resolved independently. For valid requests, the endpoint always responds with HTTP 200: successfully resolved references are returned in resolved, while references that could not be resolved (for example not found, malformed or over-long, or the caller lacks SECRET:REVEAL on that reference) are returned in errors. A failure of one reference never fails the others. Only structurally invalid requests are rejected with HTTP 400: a missing or non-array references field, more than 20 references, or a null entry.

This endpoint is an alpha feature and may be subject to change in future releases.

Phase 1: the secret backend is mocked. Only a fixed allow-list of references resolves; every other authorized, valid reference returns NOT_FOUND.

Parameter	Type	Description
body	SecretResolveRequest
ct	CancellationToken

Returns: Task<SecretResolveResult>

Example

public static async Task ResolveSecretsExample()
{
    using var client = CamundaClient.Create();

    var result = await client.ResolveSecretsAsync(new SecretResolveRequest
    {
        References = new List<string>
        {
            "camunda.secrets.myApiToken",
            "camunda.secrets.dbPassword",
        },
    });

    // Successfully resolved references are returned in Resolved; references that
    // could not be resolved are returned in Errors, each with a typed error code.
    // Never log resolved.Value — it holds secret material. Pass it directly to the
    // consumer that needs it (HTTP client, DB driver, ...) instead.
    foreach (var resolved in result.Resolved)
    {
        Console.WriteLine($"Resolved {resolved.Reference} (value redacted)");
        UseSecret(resolved.Value);
    }

    foreach (var error in result.Errors)
    {
        Console.WriteLine($"Failed to resolve {error.Reference}: {error.Code} - {error.Message}");
    }
}

// Hands the resolved secret to whatever needs it, without logging it.
private static void UseSecret(string value) { }

RestoreAsync(RestoreRequest, CancellationToken)

public Task<ClusterModeChangeResponse> RestoreAsync(RestoreRequest body, CancellationToken ct = default)

Restore from a backup

Restores the cluster from a backup. The restore is described either by a single backup ID or by a time range (from/to) that selects the backups to restore. This endpoint is only accessible while the cluster is in recovery mode; requests are rejected otherwise. The request is validated and acknowledged, but the restore itself is performed asynchronously.

Parameter	Type	Description
body	RestoreRequest
ct	CancellationToken

Returns: Task<ClusterModeChangeResponse>

Example

public static async Task RestoreExample()
{
    using var client = CamundaClient.Create();

    // The cluster must be in recovery mode before a restore is accepted.
    // Provide either a list of backup IDs (one per partition) or a time
    // range (From/To) that selects the backups to restore, but not both.
    var change = await client.RestoreAsync(new RestoreRequest
    {
        BackupIds = new List<long> { 100, 101 },
    });

    Console.WriteLine($"Cluster change {change.ChangeId}:");
    foreach (var operation in change.PlannedChanges)
    {
        var suffix = operation.Mode is null ? "" : $" -> {operation.Mode}";
        Console.WriteLine($"  {operation.Operation}{suffix}");
    }
}

SearchAgentInstanceHistoryAsync(AgentInstanceKey, AgentInstanceHistorySearchQuery, ConsistencyOptions<AgentInstanceHistorySearchQueryResult>?, CancellationToken)

public Task<AgentInstanceHistorySearchQueryResult> SearchAgentInstanceHistoryAsync(AgentInstanceKey agentInstanceKey, AgentInstanceHistorySearchQuery body, ConsistencyOptions<AgentInstanceHistorySearchQueryResult>? consistency = null, CancellationToken ct = default)

Search agent instance history

Searches the conversation history of an agent instance. Committed items are returned by default.

Parameter	Type	Description
agentInstanceKey	AgentInstanceKey
body	AgentInstanceHistorySearchQuery
consistency	ConsistencyOptions<AgentInstanceHistorySearchQueryResult>
ct	CancellationToken

Returns: Task<AgentInstanceHistorySearchQueryResult>

Example

public static async Task SearchAgentInstanceHistoryExample(AgentInstanceKey agentInstanceKey)
{
    using var client = CamundaClient.Create();

    var result = await client.SearchAgentInstanceHistoryAsync(
        agentInstanceKey,
        new AgentInstanceHistorySearchQuery
        {
            Sort = new List<AgentInstanceHistorySearchQuerySortRequest>
            {
                new AgentInstanceHistorySearchQuerySortRequest
                {
                    Field = AgentInstanceHistorySearchQuerySortRequestField.ProducedAt,
                    Order = SortOrderEnum.ASC,
                },
            },
            Page = new LimitPagination { Limit = 20 },
        });

    foreach (var item in result.Items)
    {
        Console.WriteLine($"{item.HistoryItemKey} ({item.Role})");
    }
}

SearchAgentInstancesAsync(AgentInstanceSearchQuery, ConsistencyOptions<AgentInstanceSearchQueryResult>?, CancellationToken)

public Task<AgentInstanceSearchQueryResult> SearchAgentInstancesAsync(AgentInstanceSearchQuery body, ConsistencyOptions<AgentInstanceSearchQueryResult>? consistency = null, CancellationToken ct = default)

Search agent instances

Search for agent instances based on given criteria.

Parameter	Type	Description
body	AgentInstanceSearchQuery
consistency	ConsistencyOptions<AgentInstanceSearchQueryResult>
ct	CancellationToken

Returns: Task<AgentInstanceSearchQueryResult>

Example

public static async Task SearchAgentInstancesExample()
{
    using var client = CamundaClient.Create();

    var result = await client.SearchAgentInstancesAsync(new AgentInstanceSearchQuery());

    foreach (var instance in result.Items)
    {
        Console.WriteLine($"Agent instance: {instance.AgentInstanceKey}, status: {instance.Status}");
    }
}

SearchGlobalTaskListenersAsync(GlobalTaskListenerSearchQueryRequest, ConsistencyOptions<GlobalTaskListenerSearchQueryResult>?, CancellationToken)

public Task<GlobalTaskListenerSearchQueryResult> SearchGlobalTaskListenersAsync(GlobalTaskListenerSearchQueryRequest body, ConsistencyOptions<GlobalTaskListenerSearchQueryResult>? consistency = null, CancellationToken ct = default)

Search global user task listeners

Search for global user task listeners based on given criteria.

Parameter	Type	Description
body	GlobalTaskListenerSearchQueryRequest
consistency	ConsistencyOptions<GlobalTaskListenerSearchQueryResult>
ct	CancellationToken

Returns: Task<GlobalTaskListenerSearchQueryResult>

Example

public static async Task SearchGlobalTaskListenersExample()
{
    using var client = CamundaClient.Create();

    var result = await client.SearchGlobalTaskListenersAsync(
        new GlobalTaskListenerSearchQueryRequest());

    foreach (var listener in result.Items)
    {
        Console.WriteLine($"Listener: {listener.Id}");
    }
}

SearchUsersAsync(UserSearchQueryRequest, ConsistencyOptions<UserSearchResult>?, CancellationToken)

public Task<UserSearchResult> SearchUsersAsync(UserSearchQueryRequest body, ConsistencyOptions<UserSearchResult>? consistency = null, CancellationToken ct = default)

Search users

Search for users based on given criteria.

Parameter	Type	Description
body	UserSearchQueryRequest
consistency	ConsistencyOptions<UserSearchResult>
ct	CancellationToken

Returns: Task<UserSearchResult>

UpdateAgentInstanceAsync(AgentInstanceKey, AgentInstanceUpdateRequest, CancellationToken)

public Task UpdateAgentInstanceAsync(AgentInstanceKey agentInstanceKey, AgentInstanceUpdateRequest body, CancellationToken ct = default)

Update agent instance

Updates the mutable fields of an agent instance: status, metric counters, and tools. Metric values are treated as deltas and applied immediately to the aggregate counters. Tool updates replace the existing tool list.

Parameter	Type	Description
agentInstanceKey	AgentInstanceKey
body	AgentInstanceUpdateRequest
ct	CancellationToken

Returns: Task

Example

public static async Task UpdateAgentInstanceExample(AgentInstanceKey agentInstanceKey, ElementInstanceKey elementInstanceKey)
{
    using var client = CamundaClient.Create();

    await client.UpdateAgentInstanceAsync(
        agentInstanceKey,
        new AgentInstanceUpdateRequest
        {
            ElementInstanceKey = elementInstanceKey,
            Status = AgentInstanceUpdateStatusEnum.THINKING,
            Metrics = new AgentInstanceMetricsDelta
            {
                InputTokens = 150,
                OutputTokens = 50,
                ModelCalls = 1,
            },
        });

    Console.WriteLine($"Updated agent instance: {agentInstanceKey}");
}

UpdateGlobalTaskListenerAsync(GlobalListenerId, UpdateGlobalTaskListenerRequest, CancellationToken)

public Task<GlobalTaskListenerResult> UpdateGlobalTaskListenerAsync(GlobalListenerId id, UpdateGlobalTaskListenerRequest body, CancellationToken ct = default)

Update global user task listener

Updates a global user task listener.

Parameter	Type	Description
id	GlobalListenerId
body	UpdateGlobalTaskListenerRequest
ct	CancellationToken

Returns: Task<GlobalTaskListenerResult>

Example

public static async Task UpdateGlobalTaskListenerExample(GlobalListenerId globalListenerId)
{
    using var client = CamundaClient.Create();

    var result = await client.UpdateGlobalTaskListenerAsync(
        globalListenerId,
        new UpdateGlobalTaskListenerRequest
        {
            EventTypes = new List<GlobalTaskListenerEventTypeEnum> { GlobalTaskListenerEventTypeEnum.Completing },
            Type = "updated-task-listener",
        });

    Console.WriteLine($"Updated listener: {result.Id}");
}

UpdateUserAsync(Username, UserUpdateRequest, CancellationToken)

public Task<UserUpdateResult> UpdateUserAsync(Username username, UserUpdateRequest body, CancellationToken ct = default)

Update user

Updates a user.

Parameter	Type	Description
username	Username
body	UserUpdateRequest
ct	CancellationToken

Returns: Task<UserUpdateResult>

Example

public static async Task UpdateUserExample(Username username)
{
    using var client = CamundaClient.Create();

    await client.UpdateUserAsync(
        username,
        new UserUpdateRequest
        {
            Name = "Jane Smith",
            Email = "jsmith@example.com",
        });
}

Cluster

GetBackpressureState()

public BackpressureState GetBackpressureState()

Current backpressure state snapshot.

Returns: BackpressureState

Example

public static void GetBackpressureStateExample()
{
    using var client = CamundaClient.Create();

    var state = client.GetBackpressureState();
    Console.WriteLine($"Severity: {state.Severity}, Permits: {state.PermitsMax}");
}

GetAuthenticationAsync(CancellationToken)

public Task<CamundaUserResult> GetAuthenticationAsync(CancellationToken ct = default)

Get current user

Retrieves the current authenticated user.

Parameter	Type	Description
ct	CancellationToken

Returns: Task<CamundaUserResult>

Example

public static async Task GetAuthenticationExample()
{
    using var client = CamundaClient.Create();

    var result = await client.GetAuthenticationAsync();
    Console.WriteLine($"Authenticated user: {result.Username}");
}

GetLicenseAsync(CancellationToken)

public Task<LicenseResponse> GetLicenseAsync(CancellationToken ct = default)

Get license status

Obtains the status of the current Camunda license.

Parameter	Type	Description
ct	CancellationToken

Returns: Task<LicenseResponse>

Example

public static async Task GetLicenseExample()
{
    using var client = CamundaClient.Create();

    var result = await client.GetLicenseAsync();
    Console.WriteLine($"License type: {result.LicenseType}");
}

GetTopologyAsync(CancellationToken)

public Task<TopologyResponse> GetTopologyAsync(CancellationToken ct = default)

Get cluster topology

Obtains the current topology of the cluster the gateway is part of.

Parameter	Type	Description
ct	CancellationToken

Returns: Task<TopologyResponse>

Example

public static async Task GetTopologyExample()
{
    using var client = CamundaClient.Create();

    var topology = await client.GetTopologyAsync();
    Console.WriteLine($"Cluster size: {topology.ClusterSize}");
}

PinClockAsync(ClockPinRequest, CancellationToken)

public Task PinClockAsync(ClockPinRequest body, CancellationToken ct = default)

Pin internal clock (alpha)

Set a precise, static time for the Zeebe engine's internal clock. When the clock is pinned, it remains at the specified time and does not advance. To change the time, the clock must be pinned again with a new timestamp.

This endpoint is an alpha feature and may be subject to change in future releases.

Parameter	Type	Description
body	ClockPinRequest
ct	CancellationToken

Returns: Task

Example

public static async Task PinClockExample()
{
    using var client = CamundaClient.Create();

    await client.PinClockAsync(new ClockPinRequest
    {
        Timestamp = 1700000000000,
    });
}

ResetClockAsync(CancellationToken)

public Task ResetClockAsync(CancellationToken ct = default)

Reset internal clock (alpha)

Resets the Zeebe engine's internal clock to the current system time, enabling it to tick in real-time. This operation is useful for returning the clock to normal behavior after it has been pinned to a specific time.

This endpoint is an alpha feature and may be subject to change in future releases.

Parameter	Type	Description
ct	CancellationToken

Returns: Task

Example

public static async Task ResetClockExample()
{
    using var client = CamundaClient.Create();

    await client.ResetClockAsync();
}

Resources

DeployResourcesFromFilesAsync(string[], string?, CancellationToken)

public Task<ExtendedDeploymentResponse> DeployResourcesFromFilesAsync(string[] resourceFilePaths, string? tenantId = null, CancellationToken ct = default)

Deploy resources from local filesystem paths.

Reads the specified files, infers MIME types from their extensions, and calls CamundaClient.CreateDeploymentAsync with the loaded content.

Parameter	Type	Description
resourceFilePaths	String[]	Absolute or relative file paths to BPMN, DMN, form, or resource files.
tenantId	String	Optional tenant ID for multi-tenant deployments.
ct	CancellationToken	Cancellation token.

Returns: Task<ExtendedDeploymentResponse> — An ExtendedDeploymentResponse with typed access to deployed artifacts.

Example

public static async Task DeployResourcesFromFilesExample()
{
    using var client = CamundaClient.Create();

    var result = await client.DeployResourcesFromFilesAsync(
        ["process.bpmn", "decision.dmn"]);
    Console.WriteLine($"Deployment key: {result.DeploymentKey}");
}

DeleteResourceAsync(ResourceKey, DeleteResourceRequest, CancellationToken)

public Task<DeleteResourceResponse> DeleteResourceAsync(ResourceKey resourceKey, DeleteResourceRequest body, CancellationToken ct = default)

Delete resource

Deletes a deployed resource. This can be a process definition, decision requirements definition, or form definition deployed using the deploy resources endpoint. Specify the resource you want to delete in the resourceKey parameter.

Once a resource has been deleted it cannot be recovered. If the resource needs to be available again, a new deployment of the resource is required.

By default, only the resource itself is deleted from the runtime state. To also delete the historic data associated with a resource, set the deleteHistory flag in the request body to true. The historic data is deleted asynchronously via a batch operation. The details of the created batch operation are included in the response. Note that history deletion is only supported for process resources; for other resource types this flag is ignored and no history will be deleted.

Parameter	Type	Description
resourceKey	ResourceKey
body	DeleteResourceRequest
ct	CancellationToken

Returns: Task<DeleteResourceResponse>

Example

public static async Task DeleteResourceExample(ResourceKey resourceKey)
{
    using var client = CamundaClient.Create();

    await client.DeleteResourceAsync(
        resourceKey,
        new DeleteResourceRequest());
}

GetResourceAsync(ResourceKey, ConsistencyOptions<ResourceResult>?, CancellationToken)

public Task<ResourceResult> GetResourceAsync(ResourceKey resourceKey, ConsistencyOptions<ResourceResult>? consistency = null, CancellationToken ct = default)

Get resource

Returns a deployed resource.

info

This endpoint does not return BPMN process definitions, DMN decision definitions, or form resources. To query BPMN process definitions or DMN decision definitions, use their respective APIs.

Parameter	Type	Description
resourceKey	ResourceKey
consistency	ConsistencyOptions<ResourceResult>
ct	CancellationToken

Returns: Task<ResourceResult>

GetResourceContentAsync(ResourceKey, ConsistencyOptions<object>?, CancellationToken)

public Task<object> GetResourceContentAsync(ResourceKey resourceKey, ConsistencyOptions<object>? consistency = null, CancellationToken ct = default)

Get RPA resource content (deprecated)

Deprecated — use /resources/{resourceKey}/content/binary instead, which supports all resource types and returns content as binary (octet-stream).

Returns the content of a deployed RPA resource as JSON.

info

This endpoint only supports RPA resources. For generic resource content in binary format, use the /resources/{resourceKey}/content/binary endpoint.

Parameter	Type	Description
resourceKey	ResourceKey
consistency	ConsistencyOptions<Object>
ct	CancellationToken

Returns: Task<Object>

GetResourceContentBinaryAsync(ResourceKey, ConsistencyOptions<byte[]>?, CancellationToken)

public Task<byte[]> GetResourceContentBinaryAsync(ResourceKey resourceKey, ConsistencyOptions<byte[]>? consistency = null, CancellationToken ct = default)

Get resource content as binary

Returns the content of a deployed resource in binary format (octet-stream).

info

This endpoint does not return BPMN process definitions, DMN decision definitions, or form resources. To query BPMN process definitions or DMN decision definitions, use their respective APIs.

Parameter	Type	Description
resourceKey	ResourceKey
consistency	ConsistencyOptions<Byte[]>
ct	CancellationToken

Returns: Task<Byte[]>

Example

public static async Task GetResourceContentBinaryExample(ResourceKey resourceKey)
{
    using var client = CamundaClient.Create();

    byte[] content = await client.GetResourceContentBinaryAsync(resourceKey);
    Console.WriteLine($"Binary content length: {content.Length} bytes");
}

SearchResourcesAsync(ResourceSearchQuery, ConsistencyOptions<ResourceSearchQueryResult>?, CancellationToken)

public Task<ResourceSearchQueryResult> SearchResourcesAsync(ResourceSearchQuery body, ConsistencyOptions<ResourceSearchQueryResult>? consistency = null, CancellationToken ct = default)

Search resources

Search for deployed resources based on given criteria.

info

This endpoint does not return BPMN process definitions, DMN decision definitions, or form resources. To query BPMN process definitions or DMN decision definitions, use their respective search APIs.

Parameter	Type	Description
body	ResourceSearchQuery
consistency	ConsistencyOptions<ResourceSearchQueryResult>
ct	CancellationToken

Returns: Task<ResourceSearchQueryResult>

Example

public static async Task SearchResourcesExample()
{
    using var client = CamundaClient.Create();

    var result = await client.SearchResourcesAsync(new ResourceSearchQuery());
    foreach (var resource in result.Items!)
    {
        Console.WriteLine($"Resource: {resource.ResourceName}");
    }
}

Process Instances

SearchVariablesAsDtoAsync<T>(ProcessInstanceKey, ScopeKey?, TenantId?, int, CancellationToken)

public Task<VariableMap<T>> SearchVariablesAsDtoAsync<T>(ProcessInstanceKey processInstanceKey, ScopeKey? scopeKey = null, TenantId? tenantId = null, int pageSize = 100, CancellationToken ct = default) where T : class

Fetch the variables declared by a DTO type for a process instance, mapping them onto a strongly-typed result.

The query is derived from the DTO's members (honouring [JsonPropertyName]): only the declared variable names are fetched via a name $in [...] filter, so memory is bounded by the DTO shape rather than the total number of variables on the process instance. Results are paged to exhaustion over the filtered set, collapsed by name, and parsed into a VariableMap.

Access modes on the returned map:

• Lenient — VariableMap.Get / VariableMap.Get tolerate absent variables.
• Strict — VariableMap.Validate constructs the DTO and throws if a required member is absent.

public record OrderVars(string OrderId, decimal? Amount);

var vars = await client.SearchVariablesAsDtoAsync<OrderVars>(processInstanceKey);
var amount = vars.Get<decimal>("amount");   // lenient
var typed = vars.Validate();                    // strict: throws if OrderId missing

Parameter	Type	Description
processInstanceKey	ProcessInstanceKey	The process instance whose variables to search.
scopeKey	Nullable<ScopeKey>	Optional scope key to disambiguate variables that exist at multiple scopes. When omitted and a declared variable resolves to more than one scope, a VariableScopeCollisionException is thrown.
tenantId	Nullable<TenantId>	Optional tenant ID filter.
pageSize	Int32	The page size used while paging the filtered result set.
ct	CancellationToken	Cancellation token.

Returns: Task<VariableMap<T>> — A VariableMap over the declared variables.

Example

public record OrderVariables(string OrderId, decimal Amount, string? Notes);

public static async Task SearchVariablesAsDtoExample(ProcessInstanceKey processInstanceKey)
{
    using var client = CamundaClient.Create();

    // Search a process instance for exactly the variables declared on the DTO,
    // pages and all, and collapse them into a single typed object.
    var map = await client.SearchVariablesAsDtoAsync<OrderVariables>(processInstanceKey);

    // Read individual values lazily without materializing the whole DTO.
    if (map.Contains("amount"))
    {
        var amount = map.Get<decimal>("amount");
        Console.WriteLine($"Amount: {amount}");
    }

    // Validate() enforces that every non-nullable member is present,
    // throwing VariableValidationException if a required variable is missing.
    OrderVariables order = map.Validate();
    Console.WriteLine($"Order {order.OrderId}: {order.Amount}");
}

AssignProcessInstanceBusinessIdAsync(ProcessInstanceKey, ProcessInstanceBusinessIdAssignmentInstruction, CancellationToken)

public Task AssignProcessInstanceBusinessIdAsync(ProcessInstanceKey processInstanceKey, ProcessInstanceBusinessIdAssignmentInstruction body, CancellationToken ct = default)

Assign business id to process instance

Assigns a business id to an already-running process instance that currently has none.

The assignment is single and irreversible: only artifacts created after the assignment (for example future jobs, user tasks, decision instances, and message subscriptions) carry the business id, while existing artifacts are not retroactively enriched. Re-sending the same business id succeeds as a no-op. This endpoint is only useful while business id uniqueness enforcement is disabled; when it is enabled, the request is rejected with a 409 response.

Parameter	Type	Description
processInstanceKey	ProcessInstanceKey
body	ProcessInstanceBusinessIdAssignmentInstruction
ct	CancellationToken

Returns: Task

Example

public static async Task AssignProcessInstanceBusinessIdExample(ProcessInstanceKey processInstanceKey, BusinessId businessId)
{
    using var client = CamundaClient.Create();

    await client.AssignProcessInstanceBusinessIdAsync(
        processInstanceKey,
        new ProcessInstanceBusinessIdAssignmentInstruction
        {
            BusinessId = businessId,
        });
}

CancelProcessInstanceAsync(ProcessInstanceKey, CancelProcessInstanceRequest, CancellationToken)

public Task CancelProcessInstanceAsync(ProcessInstanceKey processInstanceKey, CancelProcessInstanceRequest body, CancellationToken ct = default)

Cancel process instance

Cancels a running process instance. As a cancellation includes more than just the removal of the process instance resource, the cancellation resource must be posted. Cancellation can wait on listener-related processing; when that processing does not complete in time, this endpoint can return 504. Other gateway timeout causes are also possible. Retry with backoff and inspect listener worker availability and logs when this repeats.

Parameter	Type	Description
processInstanceKey	ProcessInstanceKey
body	CancelProcessInstanceRequest
ct	CancellationToken

Returns: Task

Example

public static async Task CancelProcessInstanceExample(ProcessInstanceKey processInstanceKey)
{
    using var client = CamundaClient.Create();

    await client.CancelProcessInstanceAsync(
        processInstanceKey,
        new CancelProcessInstanceRequest());
}

CancelProcessInstancesBatchOperationAsync(ProcessInstanceCancellationBatchOperationRequest, CancellationToken)

public Task<BatchOperationCreatedResult> CancelProcessInstancesBatchOperationAsync(ProcessInstanceCancellationBatchOperationRequest body, CancellationToken ct = default)

Cancel process instances (batch)

Cancels multiple running process instances. Since only ACTIVE root instances can be cancelled, any given filters for state and parentProcessInstanceKey are ignored and overridden during this batch operation. This is done asynchronously, the progress can be tracked using the batchOperationKey from the response and the batch operation status endpoint (/batch-operations/{batchOperationKey}).

Parameter	Type	Description
body	ProcessInstanceCancellationBatchOperationRequest
ct	CancellationToken

Returns: Task<BatchOperationCreatedResult>

Example

public static async Task CancelProcessInstancesBatchOperationExample()
{
    using var client = CamundaClient.Create();

    var result = await client.CancelProcessInstancesBatchOperationAsync(
        new ProcessInstanceCancellationBatchOperationRequest());

    Console.WriteLine($"Batch operation key: {result.BatchOperationKey}");
}

CreateProcessInstanceAsync(ProcessInstanceCreationInstruction, CancellationToken)

public Task<CreateProcessInstanceResult> CreateProcessInstanceAsync(ProcessInstanceCreationInstruction body, CancellationToken ct = default)

Create process instance

Creates and starts an instance of the specified process. The process definition to use to create the instance can be specified either using its unique key (as returned by Deploy resources), or using the BPMN process id and a version.

Waits for the completion of the process instance before returning a result when awaitCompletion is enabled.

Parameter	Type	Description
body	ProcessInstanceCreationInstruction
ct	CancellationToken

Returns: Task<CreateProcessInstanceResult>

Example

public static async Task CreateProcessInstanceByIdExample(ProcessDefinitionId processDefinitionId)
{
    using var client = CamundaClient.Create();

    var result = await client.CreateProcessInstanceAsync(new ProcessInstanceCreationInstructionById
    {
        ProcessDefinitionId = processDefinitionId,
    });

    Console.WriteLine($"Process instance key: {result.ProcessInstanceKey}");
}

public static async Task CreateProcessInstanceByKeyExample(ProcessDefinitionKey processDefinitionKey)
{
    using var client = CamundaClient.Create();

    var result = await client.CreateProcessInstanceAsync(new ProcessInstanceCreationInstructionByKey
    {
        ProcessDefinitionKey = processDefinitionKey,
    });

    Console.WriteLine($"Process instance key: {result.ProcessInstanceKey}");
}

DeleteProcessInstanceAsync(ProcessInstanceKey, DeleteProcessInstanceRequest, CancellationToken)

public Task DeleteProcessInstanceAsync(ProcessInstanceKey processInstanceKey, DeleteProcessInstanceRequest body, CancellationToken ct = default)

Delete process instance

Deletes a process instance. Only instances that are completed or terminated can be deleted.

Parameter	Type	Description
processInstanceKey	ProcessInstanceKey
body	DeleteProcessInstanceRequest
ct	CancellationToken

Returns: Task

Example

public static async Task DeleteProcessInstanceExample(ProcessInstanceKey processInstanceKey)
{
    using var client = CamundaClient.Create();

    await client.DeleteProcessInstanceAsync(
        processInstanceKey,
        new DeleteProcessInstanceRequest());
}

DeleteProcessInstancesBatchOperationAsync(ProcessInstanceDeletionBatchOperationRequest, CancellationToken)

public Task<BatchOperationCreatedResult> DeleteProcessInstancesBatchOperationAsync(ProcessInstanceDeletionBatchOperationRequest body, CancellationToken ct = default)

Delete process instances (batch)

Delete multiple process instances. This will delete the historic data from secondary storage. Only process instances in a final state (COMPLETED or TERMINATED) can be deleted. This is done asynchronously, the progress can be tracked using the batchOperationKey from the response and the batch operation status endpoint (/batch-operations/{batchOperationKey}).

Parameter	Type	Description
body	ProcessInstanceDeletionBatchOperationRequest
ct	CancellationToken

Returns: Task<BatchOperationCreatedResult>

Example

public static async Task DeleteProcessInstancesBatchOperationExample()
{
    using var client = CamundaClient.Create();

    var result = await client.DeleteProcessInstancesBatchOperationAsync(
        new ProcessInstanceDeletionBatchOperationRequest());

    Console.WriteLine($"Batch operation key: {result.BatchOperationKey}");
}

GetProcessInstanceAsync(ProcessInstanceKey, ConsistencyOptions<ProcessInstanceResult>?, CancellationToken)

public Task<ProcessInstanceResult> GetProcessInstanceAsync(ProcessInstanceKey processInstanceKey, ConsistencyOptions<ProcessInstanceResult>? consistency = null, CancellationToken ct = default)

Get process instance

Get the process instance by the process instance key.

Parameter	Type	Description
processInstanceKey	ProcessInstanceKey
consistency	ConsistencyOptions<ProcessInstanceResult>
ct	CancellationToken

Returns: Task<ProcessInstanceResult>

Example

public static async Task GetProcessInstanceExample(ProcessInstanceKey processInstanceKey)
{
    using var client = CamundaClient.Create();

    var result = await client.GetProcessInstanceAsync(processInstanceKey);
    Console.WriteLine($"Process instance: {result.ProcessDefinitionId}");
}

GetProcessInstanceCallHierarchyAsync(ProcessInstanceKey, ConsistencyOptions<object>?, CancellationToken)

public Task<object> GetProcessInstanceCallHierarchyAsync(ProcessInstanceKey processInstanceKey, ConsistencyOptions<object>? consistency = null, CancellationToken ct = default)

Get call hierarchy

Returns the call hierarchy for a given process instance, showing its ancestry up to the root instance.

Parameter	Type	Description
processInstanceKey	ProcessInstanceKey
consistency	ConsistencyOptions<Object>
ct	CancellationToken

Returns: Task<Object>

Example

public static async Task GetProcessInstanceCallHierarchyExample(ProcessInstanceKey processInstanceKey)
{
    using var client = CamundaClient.Create();

    var result = await client.GetProcessInstanceCallHierarchyAsync(
        processInstanceKey);

    Console.WriteLine($"Call hierarchy: {result}");
}

GetProcessInstanceSequenceFlowsAsync(ProcessInstanceKey, ConsistencyOptions<ProcessInstanceSequenceFlowsQueryResult>?, CancellationToken)

public Task<ProcessInstanceSequenceFlowsQueryResult> GetProcessInstanceSequenceFlowsAsync(ProcessInstanceKey processInstanceKey, ConsistencyOptions<ProcessInstanceSequenceFlowsQueryResult>? consistency = null, CancellationToken ct = default)

Get sequence flows

Get sequence flows taken by the process instance.

Parameter	Type	Description
processInstanceKey	ProcessInstanceKey
consistency	ConsistencyOptions<ProcessInstanceSequenceFlowsQueryResult>
ct	CancellationToken

Returns: Task<ProcessInstanceSequenceFlowsQueryResult>

Example

public static async Task GetProcessInstanceSequenceFlowsExample(ProcessInstanceKey processInstanceKey)
{
    using var client = CamundaClient.Create();

    var result = await client.GetProcessInstanceSequenceFlowsAsync(
        processInstanceKey);

    foreach (var flow in result.Items)
    {
        Console.WriteLine($"Sequence flow: {flow}");
    }
}

GetProcessInstanceStatisticsAsync(ProcessInstanceKey, ConsistencyOptions<ProcessInstanceElementStatisticsQueryResult>?, CancellationToken)

public Task<ProcessInstanceElementStatisticsQueryResult> GetProcessInstanceStatisticsAsync(ProcessInstanceKey processInstanceKey, ConsistencyOptions<ProcessInstanceElementStatisticsQueryResult>? consistency = null, CancellationToken ct = default)

Get element instance statistics

Get statistics about elements by the process instance key.

Parameter	Type	Description
processInstanceKey	ProcessInstanceKey
consistency	ConsistencyOptions<ProcessInstanceElementStatisticsQueryResult>
ct	CancellationToken

Returns: Task<ProcessInstanceElementStatisticsQueryResult>

Example

public static async Task GetProcessInstanceStatisticsExample(ProcessInstanceKey processInstanceKey)
{
    using var client = CamundaClient.Create();

    var result = await client.GetProcessInstanceStatisticsAsync(
        processInstanceKey);

    foreach (var stat in result.Items)
    {
        Console.WriteLine($"Element: {stat.ElementId}");
    }
}

GetProcessInstanceStatisticsByDefinitionAsync(IncidentProcessInstanceStatisticsByDefinitionQuery, ConsistencyOptions<IncidentProcessInstanceStatisticsByDefinitionQueryResult>?, CancellationToken)

public Task<IncidentProcessInstanceStatisticsByDefinitionQueryResult> GetProcessInstanceStatisticsByDefinitionAsync(IncidentProcessInstanceStatisticsByDefinitionQuery body, ConsistencyOptions<IncidentProcessInstanceStatisticsByDefinitionQueryResult>? consistency = null, CancellationToken ct = default)

Get process instance statistics by definition

Returns statistics for active process instances with incidents, grouped by process definition. The result set is scoped to a specific incident error hash code, which must be provided as a filter in the request body.

Parameter	Type	Description
body	IncidentProcessInstanceStatisticsByDefinitionQuery
consistency	ConsistencyOptions<IncidentProcessInstanceStatisticsByDefinitionQueryResult>
ct	CancellationToken

Returns: Task<IncidentProcessInstanceStatisticsByDefinitionQueryResult>

Example

public static async Task GetProcessInstanceStatisticsByDefinitionExample()
{
    using var client = CamundaClient.Create();

    var result = await client.GetProcessInstanceStatisticsByDefinitionAsync(
        new IncidentProcessInstanceStatisticsByDefinitionQuery());

    foreach (var stat in result.Items)
    {
        Console.WriteLine($"Definition: {stat.ProcessDefinitionKey}");
    }
}

GetProcessInstanceStatisticsByErrorAsync(IncidentProcessInstanceStatisticsByErrorQuery, ConsistencyOptions<IncidentProcessInstanceStatisticsByErrorQueryResult>?, CancellationToken)

public Task<IncidentProcessInstanceStatisticsByErrorQueryResult> GetProcessInstanceStatisticsByErrorAsync(IncidentProcessInstanceStatisticsByErrorQuery body, ConsistencyOptions<IncidentProcessInstanceStatisticsByErrorQueryResult>? consistency = null, CancellationToken ct = default)

Get process instance statistics by error

Returns statistics for active process instances that currently have active incidents, grouped by incident error hash code.

Parameter	Type	Description
body	IncidentProcessInstanceStatisticsByErrorQuery
consistency	ConsistencyOptions<IncidentProcessInstanceStatisticsByErrorQueryResult>
ct	CancellationToken

Returns: Task<IncidentProcessInstanceStatisticsByErrorQueryResult>

Example

public static async Task GetProcessInstanceStatisticsByErrorExample()
{
    using var client = CamundaClient.Create();

    var result = await client.GetProcessInstanceStatisticsByErrorAsync(
        new IncidentProcessInstanceStatisticsByErrorQuery());

    foreach (var stat in result.Items)
    {
        Console.WriteLine($"Error: {stat.ErrorMessage}");
    }
}

GetProcessInstanceWaitStateStatisticsAsync(ProcessInstanceKey, ConsistencyOptions<ProcessInstanceWaitStateStatisticsQueryResult>?, CancellationToken)

public Task<ProcessInstanceWaitStateStatisticsQueryResult> GetProcessInstanceWaitStateStatisticsAsync(ProcessInstanceKey processInstanceKey, ConsistencyOptions<ProcessInstanceWaitStateStatisticsQueryResult>? consistency = null, CancellationToken ct = default)

Get wait state statistics

Get statistics about waiting element instances by the process instance key, grouped by element id.

Parameter	Type	Description
processInstanceKey	ProcessInstanceKey
consistency	ConsistencyOptions<ProcessInstanceWaitStateStatisticsQueryResult>
ct	CancellationToken

Returns: Task<ProcessInstanceWaitStateStatisticsQueryResult>

Example

public static async Task GetProcessInstanceWaitStateStatisticsExample(ProcessInstanceKey processInstanceKey)
{
    using var client = CamundaClient.Create();

    var result = await client.GetProcessInstanceWaitStateStatisticsAsync(
        processInstanceKey);

    foreach (var stat in result.Items)
    {
        Console.WriteLine($"Element: {stat.ElementId}, waiting: {stat.WaitingCount}");
    }
}

MigrateProcessInstanceAsync(ProcessInstanceKey, ProcessInstanceMigrationInstruction, CancellationToken)

public Task MigrateProcessInstanceAsync(ProcessInstanceKey processInstanceKey, ProcessInstanceMigrationInstruction body, CancellationToken ct = default)

Migrate process instance

Migrates a process instance to a new process definition. This request can contain multiple mapping instructions to define mapping between the active process instance's elements and target process definition elements.

Use this to upgrade a process instance to a new version of a process or to a different process definition, e.g. to keep your running instances up-to-date with the latest process improvements.

Parameter	Type	Description
processInstanceKey	ProcessInstanceKey
body	ProcessInstanceMigrationInstruction
ct	CancellationToken

Returns: Task

Example

public static async Task MigrateProcessInstanceExample(ProcessInstanceKey processInstanceKey, ProcessDefinitionKey targetProcessDefinitionKey)
{
    using var client = CamundaClient.Create();

    await client.MigrateProcessInstanceAsync(
        processInstanceKey,
        new ProcessInstanceMigrationInstruction
        {
            TargetProcessDefinitionKey = targetProcessDefinitionKey,
        });
}

MigrateProcessInstancesBatchOperationAsync(ProcessInstanceMigrationBatchOperationRequest, CancellationToken)

public Task<BatchOperationCreatedResult> MigrateProcessInstancesBatchOperationAsync(ProcessInstanceMigrationBatchOperationRequest body, CancellationToken ct = default)

Migrate process instances (batch)

Migrate multiple process instances. Since only process instances with ACTIVE state can be migrated, any given filters for state are ignored and overridden during this batch operation. This is done asynchronously, the progress can be tracked using the batchOperationKey from the response and the batch operation status endpoint (/batch-operations/{batchOperationKey}).

Parameter	Type	Description
body	ProcessInstanceMigrationBatchOperationRequest
ct	CancellationToken

Returns: Task<BatchOperationCreatedResult>

Example

public static async Task MigrateProcessInstancesBatchOperationExample(ProcessDefinitionKey targetProcessDefinitionKey)
{
    using var client = CamundaClient.Create();

    var result = await client.MigrateProcessInstancesBatchOperationAsync(
        new ProcessInstanceMigrationBatchOperationRequest
        {
            Filter = new ProcessInstanceFilter(),
            MigrationPlan = new ProcessInstanceMigrationBatchOperationPlan
            {
                TargetProcessDefinitionKey = targetProcessDefinitionKey,
            },
        });

    Console.WriteLine($"Batch operation key: {result.BatchOperationKey}");
}

ModifyProcessInstanceAsync(ProcessInstanceKey, ProcessInstanceModificationInstruction, CancellationToken)

public Task ModifyProcessInstanceAsync(ProcessInstanceKey processInstanceKey, ProcessInstanceModificationInstruction body, CancellationToken ct = default)

Modify process instance

Modifies a running process instance. This request can contain multiple instructions to activate an element of the process or to terminate an active instance of an element.

Use this to repair a process instance that is stuck on an element or took an unintended path. For example, because an external system is not available or doesn't respond as expected.

Parameter	Type	Description
processInstanceKey	ProcessInstanceKey
body	ProcessInstanceModificationInstruction
ct	CancellationToken

Returns: Task

Example

public static async Task ModifyProcessInstanceExample(ProcessInstanceKey processInstanceKey)
{
    using var client = CamundaClient.Create();

    await client.ModifyProcessInstanceAsync(
        processInstanceKey,
        new ProcessInstanceModificationInstruction());
}

ModifyProcessInstancesBatchOperationAsync(ProcessInstanceModificationBatchOperationRequest, CancellationToken)

public Task<BatchOperationCreatedResult> ModifyProcessInstancesBatchOperationAsync(ProcessInstanceModificationBatchOperationRequest body, CancellationToken ct = default)

Modify process instances (batch)

Modify multiple process instances. Since only process instances with ACTIVE state can be modified, any given filters for state are ignored and overridden during this batch operation. In contrast to single modification operation, it is not possible to add variable instructions or modify by element key. It is only possible to use the element id of the source and target. This is done asynchronously, the progress can be tracked using the batchOperationKey from the response and the batch operation status endpoint (/batch-operations/{batchOperationKey}).

Parameter	Type	Description
body	ProcessInstanceModificationBatchOperationRequest
ct	CancellationToken

Returns: Task<BatchOperationCreatedResult>

Example

public static async Task ModifyProcessInstancesBatchOperationExample()
{
    using var client = CamundaClient.Create();

    var result = await client.ModifyProcessInstancesBatchOperationAsync(
        new ProcessInstanceModificationBatchOperationRequest());

    Console.WriteLine($"Batch operation key: {result.BatchOperationKey}");
}

ResolveIncidentsBatchOperationAsync(ProcessInstanceIncidentResolutionBatchOperationRequest, CancellationToken)

public Task<BatchOperationCreatedResult> ResolveIncidentsBatchOperationAsync(ProcessInstanceIncidentResolutionBatchOperationRequest body, CancellationToken ct = default)

Resolve related incidents (batch)

Resolves multiple instances of process instances. Since only process instances with ACTIVE state can have unresolved incidents, any given filters for state are ignored and overridden during this batch operation. This is done asynchronously, the progress can be tracked using the batchOperationKey from the response and the batch operation status endpoint (/batch-operations/{batchOperationKey}).

Parameter	Type	Description
body	ProcessInstanceIncidentResolutionBatchOperationRequest
ct	CancellationToken

Returns: Task<BatchOperationCreatedResult>

Example

public static async Task ResolveIncidentsBatchOperationExample()
{
    using var client = CamundaClient.Create();

    var result = await client.ResolveIncidentsBatchOperationAsync(
        new ProcessInstanceIncidentResolutionBatchOperationRequest());

    Console.WriteLine($"Batch operation key: {result.BatchOperationKey}");
}

ResolveProcessInstanceIncidentsAsync(ProcessInstanceKey, CancellationToken)

public Task<BatchOperationCreatedResult> ResolveProcessInstanceIncidentsAsync(ProcessInstanceKey processInstanceKey, CancellationToken ct = default)

Resolve related incidents

Creates a batch operation to resolve multiple incidents of a process instance.

Parameter	Type	Description
processInstanceKey	ProcessInstanceKey
ct	CancellationToken

Returns: Task<BatchOperationCreatedResult>

Example

public static async Task ResolveProcessInstanceIncidentsExample(ProcessInstanceKey processInstanceKey)
{
    using var client = CamundaClient.Create();

    var result = await client.ResolveProcessInstanceIncidentsAsync(
        processInstanceKey);

    Console.WriteLine($"Batch operation key: {result.BatchOperationKey}");
}

ResumeProcessInstanceAsync(ProcessInstanceKey, ResumeProcessInstanceRequest, CancellationToken)

public Task ResumeProcessInstanceAsync(ProcessInstanceKey processInstanceKey, ResumeProcessInstanceRequest body, CancellationToken ct = default)

Resume process instance

Resumes a suspended process instance, returning it to the ACTIVE state and continuing processing. Only process instances in the SUSPENDED state can be resumed.

Parameter	Type	Description
processInstanceKey	ProcessInstanceKey
body	ResumeProcessInstanceRequest
ct	CancellationToken

Returns: Task

Example

public static async Task ResumeProcessInstanceExample(ProcessInstanceKey processInstanceKey)
{
    using var client = CamundaClient.Create();

    await client.ResumeProcessInstanceAsync(
        processInstanceKey,
        new ResumeProcessInstanceRequest());
}

ResumeProcessInstancesBatchOperationAsync(ProcessInstanceResumptionBatchOperationRequest, CancellationToken)

public Task<BatchOperationCreatedResult> ResumeProcessInstancesBatchOperationAsync(ProcessInstanceResumptionBatchOperationRequest body, CancellationToken ct = default)

Resume process instances (batch)

Resumes multiple suspended process instances. Since only SUSPENDED root instances can be resumed, any given filters for state and parentProcessInstanceKey are ignored and overridden during this batch operation. This is done asynchronously, the progress can be tracked using the batchOperationKey from the response and the batch operation status endpoint (/batch-operations/{batchOperationKey}).

Parameter	Type	Description
body	ProcessInstanceResumptionBatchOperationRequest
ct	CancellationToken

Returns: Task<BatchOperationCreatedResult>

Example

public static async Task ResumeProcessInstancesBatchOperationExample()
{
    using var client = CamundaClient.Create();

    var result = await client.ResumeProcessInstancesBatchOperationAsync(
        new ProcessInstanceResumptionBatchOperationRequest
        {
            Filter = new ProcessInstanceFilter(),
        });

    Console.WriteLine($"Batch operation key: {result.BatchOperationKey}");
}

SearchProcessInstanceIncidentsAsync(ProcessInstanceKey, IncidentSearchQuery, ConsistencyOptions<IncidentSearchQueryResult>?, CancellationToken)

public Task<IncidentSearchQueryResult> SearchProcessInstanceIncidentsAsync(ProcessInstanceKey processInstanceKey, IncidentSearchQuery body, ConsistencyOptions<IncidentSearchQueryResult>? consistency = null, CancellationToken ct = default)

Search related incidents

Search for incidents caused by the process instance or any of its called process or decision instances.

Although the processInstanceKey is provided as a path parameter to indicate the root process instance, you may also include a processInstanceKey within the filter object to narrow results to specific child process instances. This is useful, for example, if you want to isolate incidents associated with subprocesses or called processes under the root instance while excluding incidents directly tied to the root.

Parameter	Type	Description
processInstanceKey	ProcessInstanceKey
body	IncidentSearchQuery
consistency	ConsistencyOptions<IncidentSearchQueryResult>
ct	CancellationToken

Returns: Task<IncidentSearchQueryResult>

Example

public static async Task SearchProcessInstanceIncidentsExample(ProcessInstanceKey processInstanceKey)
{
    using var client = CamundaClient.Create();

    var result = await client.SearchProcessInstanceIncidentsAsync(
        processInstanceKey,
        new IncidentSearchQuery());

    foreach (var incident in result.Items)
    {
        Console.WriteLine($"Incident: {incident.IncidentKey}");
    }
}

SearchProcessInstancesAsync(ProcessInstanceSearchQuery, ConsistencyOptions<ProcessInstanceSearchQueryResult>?, CancellationToken)

public Task<ProcessInstanceSearchQueryResult> SearchProcessInstancesAsync(ProcessInstanceSearchQuery body, ConsistencyOptions<ProcessInstanceSearchQueryResult>? consistency = null, CancellationToken ct = default)

Search process instances

Search for process instances based on given criteria.

Parameter	Type	Description
body	ProcessInstanceSearchQuery
consistency	ConsistencyOptions<ProcessInstanceSearchQueryResult>
ct	CancellationToken

Returns: Task<ProcessInstanceSearchQueryResult>

Example

public static async Task SearchProcessInstancesExample()
{
    using var client = CamundaClient.Create();

    var result = await client.SearchProcessInstancesAsync(new ProcessInstanceSearchQuery());

    foreach (var instance in result.Items)
    {
        Console.WriteLine($"Process instance: {instance.ProcessInstanceKey}");
    }
}

SuspendProcessInstanceAsync(ProcessInstanceKey, SuspendProcessInstanceRequest, CancellationToken)

public Task SuspendProcessInstanceAsync(ProcessInstanceKey processInstanceKey, SuspendProcessInstanceRequest body, CancellationToken ct = default)

Suspend process instance

Suspends a running process instance, pausing further processing until it is resumed. Only process instances in the ACTIVE state can be suspended.

Parameter	Type	Description
processInstanceKey	ProcessInstanceKey
body	SuspendProcessInstanceRequest
ct	CancellationToken

Returns: Task

Example

public static async Task SuspendProcessInstanceExample(ProcessInstanceKey processInstanceKey)
{
    using var client = CamundaClient.Create();

    await client.SuspendProcessInstanceAsync(
        processInstanceKey,
        new SuspendProcessInstanceRequest());
}

SuspendProcessInstancesBatchOperationAsync(ProcessInstanceSuspensionBatchOperationRequest, CancellationToken)

public Task<BatchOperationCreatedResult> SuspendProcessInstancesBatchOperationAsync(ProcessInstanceSuspensionBatchOperationRequest body, CancellationToken ct = default)

Suspend process instances (batch)

Suspends multiple running process instances. Since only ACTIVE root instances can be suspended, any given filters for state and parentProcessInstanceKey are ignored and overridden during this batch operation. This is done asynchronously, the progress can be tracked using the batchOperationKey from the response and the batch operation status endpoint (/batch-operations/{batchOperationKey}).

Parameter	Type	Description
body	ProcessInstanceSuspensionBatchOperationRequest
ct	CancellationToken

Returns: Task<BatchOperationCreatedResult>

Example

public static async Task SuspendProcessInstancesBatchOperationExample()
{
    using var client = CamundaClient.Create();

    var result = await client.SuspendProcessInstancesBatchOperationAsync(
        new ProcessInstanceSuspensionBatchOperationRequest
        {
            Filter = new ProcessInstanceFilter(),
        });

    Console.WriteLine($"Batch operation key: {result.BatchOperationKey}");
}

Jobs

CreateJobWorker(JobWorkerConfig, JobHandler)

public JobWorker CreateJobWorker(JobWorkerConfig config, JobHandler handler)

Create a job worker that polls for and processes jobs of the specified type.

The handler receives an ActivatedJob and returns variables to auto-complete. Throw BpmnErrorException for BPMN errors, JobFailureException for explicit failures, or any other exception to auto-fail with retries - 1.

Parameter	Type	Description
config	JobWorkerConfig	Worker configuration (job type, timeout, concurrency).
handler	JobHandler	Async handler that processes each job. Return output variables (or null) to complete.

Returns: JobWorker — The running JobWorker instance.

Example

public static void CreateJobWorkerExample()
{
    using var client = CamundaClient.Create();

    var worker = client.CreateJobWorker(
        new JobWorkerConfig { JobType = "payment-service" },
        async (job, ct) =>
        {
            Console.WriteLine($"Processing job {job.JobKey}");
            return new { Success = true };
        });
}

CreateJobWorker(JobWorkerConfig, Func<ActivatedJob, CancellationToken, Task>)

public JobWorker CreateJobWorker(JobWorkerConfig config, Func<ActivatedJob, CancellationToken, Task> handler)

Create a job worker with a handler that doesn't return output variables. The job is auto-completed with no variables on success.

Parameter	Type	Description
config	JobWorkerConfig
handler	Func<ActivatedJob, CancellationToken, Task>

Returns: JobWorker

Example

public static void CreateJobWorkerExample()
{
    using var client = CamundaClient.Create();

    var worker = client.CreateJobWorker(
        new JobWorkerConfig { JobType = "payment-service" },
        async (job, ct) =>
        {
            Console.WriteLine($"Processing job {job.JobKey}");
            return new { Success = true };
        });
}

ActivateJobsAsync(JobActivationRequest, CancellationToken)

public Task<JobActivationResult> ActivateJobsAsync(JobActivationRequest body, CancellationToken ct = default)

Activate jobs

Iterate through all known partitions and activate jobs up to the requested maximum.

Parameter	Type	Description
body	JobActivationRequest
ct	CancellationToken

Returns: Task<JobActivationResult>

Example

public static async Task ActivateJobsExample()
{
    using var client = CamundaClient.Create();

    var result = await client.ActivateJobsAsync(new JobActivationRequest
    {
        Type = "my-job-type",
        MaxJobsToActivate = 10,
        Timeout = 300000,
        Worker = "my-worker",
    });

    foreach (var job in result.Jobs)
    {
        Console.WriteLine($"Job: {job.JobKey}");
    }
}

CompleteJobAsync(JobKey, JobCompletionRequest, CancellationToken)

public Task CompleteJobAsync(JobKey jobKey, JobCompletionRequest body, CancellationToken ct = default)

Complete job

Complete a job with the given payload, which allows completing the associated service task.

Parameter	Type	Description
jobKey	JobKey
body	JobCompletionRequest
ct	CancellationToken

Returns: Task

Example

public static async Task CompleteJobExample(JobKey jobKey)
{
    using var client = CamundaClient.Create();

    await client.CompleteJobAsync(
        jobKey,
        new JobCompletionRequest());
}

FailJobAsync(JobKey, JobFailRequest, CancellationToken)

public Task FailJobAsync(JobKey jobKey, JobFailRequest body, CancellationToken ct = default)

Fail job

Mark the job as failed.

Parameter	Type	Description
jobKey	JobKey
body	JobFailRequest
ct	CancellationToken

Returns: Task

Example

public static async Task FailJobExample(JobKey jobKey)
{
    using var client = CamundaClient.Create();

    await client.FailJobAsync(
        jobKey,
        new JobFailRequest
        {
            Retries = 3,
            RetryBackOff = 5000,
            ErrorMessage = "Something went wrong",
        });
}

GetGlobalJobStatisticsAsync(DateTimeOffset, DateTimeOffset, string?, ConsistencyOptions<GlobalJobStatisticsQueryResult>?, CancellationToken)

public Task<GlobalJobStatisticsQueryResult> GetGlobalJobStatisticsAsync(DateTimeOffset from, DateTimeOffset to, string? jobType = null, ConsistencyOptions<GlobalJobStatisticsQueryResult>? consistency = null, CancellationToken ct = default)

Global job statistics

Returns global aggregated counts for jobs. Filter by the creation time window (required) and optionally by jobType.

Parameter	Type	Description
from	DateTimeOffset
to	DateTimeOffset
jobType	String
consistency	ConsistencyOptions<GlobalJobStatisticsQueryResult>
ct	CancellationToken

Returns: Task<GlobalJobStatisticsQueryResult>

Example

public static async Task GetGlobalJobStatisticsExample()
{
    using var client = CamundaClient.Create();

    var result = await client.GetGlobalJobStatisticsAsync(
        from: new DateTimeOffset(2024, 1, 1, 0, 0, 0, TimeSpan.Zero),
        to: new DateTimeOffset(2024, 12, 31, 23, 59, 59, TimeSpan.Zero));

    Console.WriteLine($"Global job stats: {result}");
}

GetJobErrorStatisticsAsync(JobErrorStatisticsQuery, ConsistencyOptions<JobErrorStatisticsQueryResult>?, CancellationToken)

public Task<JobErrorStatisticsQueryResult> GetJobErrorStatisticsAsync(JobErrorStatisticsQuery body, ConsistencyOptions<JobErrorStatisticsQueryResult>? consistency = null, CancellationToken ct = default)

Get error metrics for a job type

Returns aggregated metrics per error for the given jobType.

Parameter	Type	Description
body	JobErrorStatisticsQuery
consistency	ConsistencyOptions<JobErrorStatisticsQueryResult>
ct	CancellationToken

Returns: Task<JobErrorStatisticsQueryResult>

Example

public static async Task GetJobErrorStatisticsExample()
{
    using var client = CamundaClient.Create();

    var result = await client.GetJobErrorStatisticsAsync(
        new JobErrorStatisticsQuery());

    foreach (var stat in result.Items)
    {
        Console.WriteLine($"Error: {stat.ErrorCode}");
    }
}

GetJobTimeSeriesStatisticsAsync(JobTimeSeriesStatisticsQuery, ConsistencyOptions<JobTimeSeriesStatisticsQueryResult>?, CancellationToken)

public Task<JobTimeSeriesStatisticsQueryResult> GetJobTimeSeriesStatisticsAsync(JobTimeSeriesStatisticsQuery body, ConsistencyOptions<JobTimeSeriesStatisticsQueryResult>? consistency = null, CancellationToken ct = default)

Get time-series metrics for a job type

Returns a list of time-bucketed metrics ordered ascending by time. The from and to fields select the time window of interest. Each item in the response corresponds to one time bucket of the requested resolution.

Parameter	Type	Description
body	JobTimeSeriesStatisticsQuery
consistency	ConsistencyOptions<JobTimeSeriesStatisticsQueryResult>
ct	CancellationToken

Returns: Task<JobTimeSeriesStatisticsQueryResult>

Example

public static async Task GetJobTimeSeriesStatisticsExample()
{
    using var client = CamundaClient.Create();

    var result = await client.GetJobTimeSeriesStatisticsAsync(
        new JobTimeSeriesStatisticsQuery());

    foreach (var stat in result.Items)
    {
        Console.WriteLine($"Time series: {stat}");
    }
}

GetJobTypeStatisticsAsync(JobTypeStatisticsQuery, ConsistencyOptions<JobTypeStatisticsQueryResult>?, CancellationToken)

public Task<JobTypeStatisticsQueryResult> GetJobTypeStatisticsAsync(JobTypeStatisticsQuery body, ConsistencyOptions<JobTypeStatisticsQueryResult>? consistency = null, CancellationToken ct = default)

Get job statistics by type

Get statistics about jobs, grouped by job type.

Parameter	Type	Description
body	JobTypeStatisticsQuery
consistency	ConsistencyOptions<JobTypeStatisticsQueryResult>
ct	CancellationToken

Returns: Task<JobTypeStatisticsQueryResult>

Example

public static async Task GetJobTypeStatisticsExample()
{
    using var client = CamundaClient.Create();

    var result = await client.GetJobTypeStatisticsAsync(
        new JobTypeStatisticsQuery());

    foreach (var stat in result.Items)
    {
        Console.WriteLine($"Job type: {stat.JobType}");
    }
}

GetJobWorkerStatisticsAsync(JobWorkerStatisticsQuery, ConsistencyOptions<JobWorkerStatisticsQueryResult>?, CancellationToken)

public Task<JobWorkerStatisticsQueryResult> GetJobWorkerStatisticsAsync(JobWorkerStatisticsQuery body, ConsistencyOptions<JobWorkerStatisticsQueryResult>? consistency = null, CancellationToken ct = default)

Get job statistics by worker

Get statistics about jobs, grouped by worker, for a given job type.

Parameter	Type	Description
body	JobWorkerStatisticsQuery
consistency	ConsistencyOptions<JobWorkerStatisticsQueryResult>
ct	CancellationToken

Returns: Task<JobWorkerStatisticsQueryResult>

Example

public static async Task GetJobWorkerStatisticsExample()
{
    using var client = CamundaClient.Create();

    var result = await client.GetJobWorkerStatisticsAsync(
        new JobWorkerStatisticsQuery());

    foreach (var stat in result.Items)
    {
        Console.WriteLine($"Worker: {stat.Worker}");
    }
}

SearchJobsAsync(JobSearchQuery, ConsistencyOptions<JobSearchQueryResult>?, CancellationToken)

public Task<JobSearchQueryResult> SearchJobsAsync(JobSearchQuery body, ConsistencyOptions<JobSearchQueryResult>? consistency = null, CancellationToken ct = default)

Search jobs

Search for jobs based on given criteria.

Parameter	Type	Description
body	JobSearchQuery
consistency	ConsistencyOptions<JobSearchQueryResult>
ct	CancellationToken

Returns: Task<JobSearchQueryResult>

Example

public static async Task SearchJobsExample()
{
    using var client = CamundaClient.Create();

    var result = await client.SearchJobsAsync(new JobSearchQuery());

    foreach (var job in result.Items)
    {
        Console.WriteLine($"Job: {job.JobKey}");
    }
}

ThrowJobErrorAsync(JobKey, JobErrorRequest, CancellationToken)

public Task ThrowJobErrorAsync(JobKey jobKey, JobErrorRequest body, CancellationToken ct = default)

Throw error for job

Reports a business error (i.e. non-technical) that occurs while processing a job.

Parameter	Type	Description
jobKey	JobKey
body	JobErrorRequest
ct	CancellationToken

Returns: Task

Example

public static async Task ThrowJobErrorExample(JobKey jobKey)
{
    using var client = CamundaClient.Create();

    await client.ThrowJobErrorAsync(
        jobKey,
        new JobErrorRequest
        {
            ErrorCode = "VALIDATION_ERROR",
            ErrorMessage = "Input validation failed",
        });
}

UpdateJobAsync(JobKey, JobUpdateRequest, CancellationToken)

public Task UpdateJobAsync(JobKey jobKey, JobUpdateRequest body, CancellationToken ct = default)

Update job

Update a job with the given key.

Parameter	Type	Description
jobKey	JobKey
body	JobUpdateRequest
ct	CancellationToken

Returns: Task

Example

public static async Task UpdateJobExample(JobKey jobKey)
{
    using var client = CamundaClient.Create();

    await client.UpdateJobAsync(
        jobKey,
        new JobUpdateRequest
        {
            Changeset = new JobChangeset { Retries = 3 },
        });
}

UpdateJobsBatchOperationAsync(JobBatchUpdateRequest, CancellationToken)

public Task<BatchOperationCreatedResult> UpdateJobsBatchOperationAsync(JobBatchUpdateRequest body, CancellationToken ct = default)

Update jobs (batch)

Creates a batch operation to update jobs matching the given filter. At least one changeset field must be non-null. This is done asynchronously; the progress can be tracked using the batchOperationKey from the response and the batch operation status endpoint (/batch-operations/{batchOperationKey}).

Parameter	Type	Description
body	JobBatchUpdateRequest
ct	CancellationToken

Returns: Task<BatchOperationCreatedResult>

Example

public static async Task UpdateJobsBatchOperationExample()
{
    using var client = CamundaClient.Create();

    var result = await client.UpdateJobsBatchOperationAsync(
        new JobBatchUpdateRequest
        {
            Filter = new JobFilter
            {
                Type = new StringFilterProperty { Eq = "my-job-type" },
            },
            Changeset = new JobChangeset { Retries = 3 },
        });

    Console.WriteLine($"Batch operation key: {result.BatchOperationKey}");
}

Job Workers

RunWorkersAsync(TimeSpan?, CancellationToken)

public Task RunWorkersAsync(TimeSpan? gracePeriod = null, CancellationToken ct = default)

Block until cancellation is requested, keeping all registered workers alive. This is the typical entry point for worker-only applications.

When the token is cancelled, all workers are stopped gracefully.

Parameter	Type	Description
gracePeriod	Nullable<TimeSpan>	Time to wait for in-flight jobs to finish during shutdown. Default: 10 seconds.
ct	CancellationToken	Cancellation token that signals shutdown.

Returns: Task

Example

public static async Task RunWorkersExample(CancellationToken ct)
{
    using var client = CamundaClient.Create();

    client.CreateJobWorker(
        new JobWorkerConfig { JobType = "payment-service" },
        async (job, jobCt) =>
        {
            Console.WriteLine($"Processing job {job.JobKey}");
            return null;
        });

    await client.RunWorkersAsync(gracePeriod: TimeSpan.FromSeconds(10), ct);
}

StopAllWorkersAsync(TimeSpan?)

public Task StopAllWorkersAsync(TimeSpan? gracePeriod = null)

Stop all registered workers and wait for in-flight jobs to drain.

Parameter	Type	Description
gracePeriod	Nullable<TimeSpan>

Returns: Task

Example

public static async Task StopAllWorkersExample()
{
    using var client = CamundaClient.Create();

    client.CreateJobWorker(
        new JobWorkerConfig { JobType = "payment-service" },
        async (job, ct) =>
        {
            Console.WriteLine($"Processing job {job.JobKey}");
            return null;
        });

    await client.StopAllWorkersAsync(gracePeriod: TimeSpan.FromSeconds(5));
}

GetWorkers()

public IReadOnlyList<JobWorker> GetWorkers()

Returns a snapshot of all registered workers.

Returns: IReadOnlyList<JobWorker>

Example

public static void GetWorkersExample()
{
    using var client = CamundaClient.Create();

    client.CreateJobWorker(
        new JobWorkerConfig { JobType = "payment-service" },
        async (job, ct) =>
        {
            Console.WriteLine($"Processing job {job.JobKey}");
            return null;
        });

    var workers = client.GetWorkers();
    foreach (var worker in workers)
    {
        Console.WriteLine($"Worker: {worker.Name}, Active: {worker.ActiveJobs}");
    }
}

Elements

ActivateAdHocSubProcessActivitiesAsync(ElementInstanceKey, AdHocSubProcessActivateActivitiesInstruction, CancellationToken)

public Task ActivateAdHocSubProcessActivitiesAsync(ElementInstanceKey adHocSubProcessInstanceKey, AdHocSubProcessActivateActivitiesInstruction body, CancellationToken ct = default)

Activate activities within an ad-hoc sub-process

Activates selected activities within an ad-hoc sub-process identified by element ID. The provided element IDs must exist within the ad-hoc sub-process instance identified by the provided adHocSubProcessInstanceKey.

Parameter	Type	Description
adHocSubProcessInstanceKey	ElementInstanceKey
body	AdHocSubProcessActivateActivitiesInstruction
ct	CancellationToken

Returns: Task

Example

public static async Task ActivateAdHocSubProcessActivitiesExample(ElementInstanceKey elementInstanceKey)
{
    using var client = CamundaClient.Create();

    await client.ActivateAdHocSubProcessActivitiesAsync(
        elementInstanceKey,
        new AdHocSubProcessActivateActivitiesInstruction());
}

GetElementInstanceAsync(ElementInstanceKey, ConsistencyOptions<ElementInstanceResult>?, CancellationToken)

public Task<ElementInstanceResult> GetElementInstanceAsync(ElementInstanceKey elementInstanceKey, ConsistencyOptions<ElementInstanceResult>? consistency = null, CancellationToken ct = default)

Get element instance

Returns element instance as JSON.

Parameter	Type	Description
elementInstanceKey	ElementInstanceKey
consistency	ConsistencyOptions<ElementInstanceResult>
ct	CancellationToken

Returns: Task<ElementInstanceResult>

Example

public static async Task GetElementInstanceExample(ElementInstanceKey elementInstanceKey)
{
    using var client = CamundaClient.Create();

    var result = await client.GetElementInstanceAsync(
        elementInstanceKey);

    Console.WriteLine($"Element: {result.ElementId}");
}

SearchElementInstanceWaitStatesAsync(ElementInstanceWaitStateQuery, ConsistencyOptions<ElementInstanceWaitStateQueryResult>?, CancellationToken)

public Task<ElementInstanceWaitStateQueryResult> SearchElementInstanceWaitStatesAsync(ElementInstanceWaitStateQuery body, ConsistencyOptions<ElementInstanceWaitStateQueryResult>? consistency = null, CancellationToken ct = default)

Search element instance wait states

Returns the wait states for element instances matching the given filter.

Parameter	Type	Description
body	ElementInstanceWaitStateQuery
consistency	ConsistencyOptions<ElementInstanceWaitStateQueryResult>
ct	CancellationToken

Returns: Task<ElementInstanceWaitStateQueryResult>

Example

public static async Task SearchElementInstanceWaitStatesExample(ProcessInstanceKey processInstanceKey)
{
    using var client = CamundaClient.Create();

    var result = await client.SearchElementInstanceWaitStatesAsync(
        new ElementInstanceWaitStateQuery
        {
            Filter = new ElementInstanceWaitStateFilter
            {
                ProcessInstanceKey = new ProcessInstanceKeyFilterProperty
                {
                    Eq = processInstanceKey,
                },
            },
        });

    foreach (var waitState in result.Items)
    {
        var details = waitState.Details switch
        {
            JobWaitStateDetails job => $"waiting on job '{job.JobType}'",
            MessageWaitStateDetails message => $"waiting for message '{message.MessageName}'",
            _ => "waiting",
        };
        Console.WriteLine($"{waitState.ElementId}: {details}");
    }
}

SearchElementInstancesAsync(ElementInstanceSearchQuery, ConsistencyOptions<ElementInstanceSearchQueryResult>?, CancellationToken)

public Task<ElementInstanceSearchQueryResult> SearchElementInstancesAsync(ElementInstanceSearchQuery body, ConsistencyOptions<ElementInstanceSearchQueryResult>? consistency = null, CancellationToken ct = default)

Search element instances

Search for element instances based on given criteria.

Parameter	Type	Description
body	ElementInstanceSearchQuery
consistency	ConsistencyOptions<ElementInstanceSearchQueryResult>
ct	CancellationToken

Returns: Task<ElementInstanceSearchQueryResult>

Example

public static async Task SearchElementInstancesExample()
{
    using var client = CamundaClient.Create();

    var result = await client.SearchElementInstancesAsync(
        new ElementInstanceSearchQuery());

    foreach (var ei in result.Items)
    {
        Console.WriteLine($"Element instance: {ei.ElementInstanceKey}");
    }
}

Groups

AssignClientToGroupAsync(GroupId, ClientId, CancellationToken)

public Task AssignClientToGroupAsync(GroupId groupId, ClientId clientId, CancellationToken ct = default)

Assign a client to a group

Assigns a client to a group, making it a member of the group. Members of the group inherit the group authorizations, roles, and tenant assignments.

Parameter	Type	Description
groupId	GroupId
clientId	ClientId
ct	CancellationToken

Returns: Task

AssignMappingRuleToGroupAsync(GroupId, MappingRuleId, CancellationToken)

public Task AssignMappingRuleToGroupAsync(GroupId groupId, MappingRuleId mappingRuleId, CancellationToken ct = default)

Assign a mapping rule to a group

Assigns a mapping rule to a group.

Parameter	Type	Description
groupId	GroupId
mappingRuleId	MappingRuleId
ct	CancellationToken

Returns: Task

AssignUserToGroupAsync(GroupId, Username, CancellationToken)

public Task AssignUserToGroupAsync(GroupId groupId, Username username, CancellationToken ct = default)

Assign a user to a group

Assigns a user to a group, making the user a member of the group. Group members inherit the group authorizations, roles, and tenant assignments.

Parameter	Type	Description
groupId	GroupId
username	Username
ct	CancellationToken

Returns: Task

CreateGroupAsync(GroupCreateRequest, CancellationToken)

public Task<GroupCreateResult> CreateGroupAsync(GroupCreateRequest body, CancellationToken ct = default)

Create group

Create a new group.

The supplied groupId is validated against ^[a-zA-Z0-9_~@.+-]+$ (max 256 characters) by IdentifierValidator.validateId in the runtime. This strict validation applies wherever the Groups API is available: in OIDC deployments that set camunda.security.authentication.oidc.groupsClaim the Groups API (including this endpoint) is disabled entirely, so group CRUD never sees externally-minted IdP IDs. The BYOG relaxation only loosens validation when a group is referenced as a member of a role or tenant (assignRoleToGroup, assignGroupToTenant); group CRUD itself always uses the strict default-id regex. The constraint is not advertised on the GroupId schema so that the same schema can be reused at member-reference sites without falsely rejecting externally-minted IdP group IDs there.

Parameter	Type	Description
body	GroupCreateRequest
ct	CancellationToken

Returns: Task<GroupCreateResult>

Example

public static async Task CreateGroupExample(GroupId groupId)
{
    using var client = CamundaClient.Create();

    var result = await client.CreateGroupAsync(new GroupCreateRequest
    {
        GroupId = groupId,
        Name = "Engineering",
    });

    Console.WriteLine($"Group key: {result.GroupId}");
}

DeleteGroupAsync(GroupId, CancellationToken)

public Task DeleteGroupAsync(GroupId groupId, CancellationToken ct = default)

Delete group

Deletes the group with the given ID.

Parameter	Type	Description
groupId	GroupId
ct	CancellationToken

Returns: Task

GetGroupAsync(GroupId, ConsistencyOptions<GroupResult>?, CancellationToken)

public Task<GroupResult> GetGroupAsync(GroupId groupId, ConsistencyOptions<GroupResult>? consistency = null, CancellationToken ct = default)

Get group

Get a group by its ID.

Parameter	Type	Description
groupId	GroupId
consistency	ConsistencyOptions<GroupResult>
ct	CancellationToken

Returns: Task<GroupResult>

SearchClientsForGroupAsync(GroupId, GroupClientSearchQueryRequest, ConsistencyOptions<GroupClientSearchResult>?, CancellationToken)

public Task<GroupClientSearchResult> SearchClientsForGroupAsync(GroupId groupId, GroupClientSearchQueryRequest body, ConsistencyOptions<GroupClientSearchResult>? consistency = null, CancellationToken ct = default)

Search group clients

Search clients assigned to a group.

Parameter	Type	Description
groupId	GroupId
body	GroupClientSearchQueryRequest
consistency	ConsistencyOptions<GroupClientSearchResult>
ct	CancellationToken

Returns: Task<GroupClientSearchResult>

SearchGroupsAsync(GroupSearchQueryRequest, ConsistencyOptions<GroupSearchQueryResult>?, CancellationToken)

public Task<GroupSearchQueryResult> SearchGroupsAsync(GroupSearchQueryRequest body, ConsistencyOptions<GroupSearchQueryResult>? consistency = null, CancellationToken ct = default)

Search groups

Search for groups based on given criteria.

Parameter	Type	Description
body	GroupSearchQueryRequest
consistency	ConsistencyOptions<GroupSearchQueryResult>
ct	CancellationToken

Returns: Task<GroupSearchQueryResult>

Example

public static async Task SearchGroupsExample()
{
    using var client = CamundaClient.Create();

    var result = await client.SearchGroupsAsync(new GroupSearchQueryRequest());

    foreach (var group in result.Items)
    {
        Console.WriteLine($"Group: {group.Name}");
    }
}

SearchMappingRulesForGroupAsync(GroupId, MappingRuleSearchQueryRequest, ConsistencyOptions<GroupMappingRuleSearchResult>?, CancellationToken)

public Task<GroupMappingRuleSearchResult> SearchMappingRulesForGroupAsync(GroupId groupId, MappingRuleSearchQueryRequest body, ConsistencyOptions<GroupMappingRuleSearchResult>? consistency = null, CancellationToken ct = default)

Search group mapping rules

Search mapping rules assigned to a group.

Parameter	Type	Description
groupId	GroupId
body	MappingRuleSearchQueryRequest
consistency	ConsistencyOptions<GroupMappingRuleSearchResult>
ct	CancellationToken

Returns: Task<GroupMappingRuleSearchResult>

SearchUsersForGroupAsync(GroupId, GroupUserSearchQueryRequest, ConsistencyOptions<GroupUserSearchResult>?, CancellationToken)

public Task<GroupUserSearchResult> SearchUsersForGroupAsync(GroupId groupId, GroupUserSearchQueryRequest body, ConsistencyOptions<GroupUserSearchResult>? consistency = null, CancellationToken ct = default)

Search group users

Search users assigned to a group.

Parameter	Type	Description
groupId	GroupId
body	GroupUserSearchQueryRequest
consistency	ConsistencyOptions<GroupUserSearchResult>
ct	CancellationToken

Returns: Task<GroupUserSearchResult>

UnassignClientFromGroupAsync(GroupId, ClientId, CancellationToken)

public Task UnassignClientFromGroupAsync(GroupId groupId, ClientId clientId, CancellationToken ct = default)

Unassign a client from a group

Unassigns a client from a group. The client is removed as a group member, with associated authorizations, roles, and tenant assignments no longer applied.

Parameter	Type	Description
groupId	GroupId
clientId	ClientId
ct	CancellationToken

Returns: Task

UnassignMappingRuleFromGroupAsync(GroupId, MappingRuleId, CancellationToken)

public Task UnassignMappingRuleFromGroupAsync(GroupId groupId, MappingRuleId mappingRuleId, CancellationToken ct = default)

Unassign a mapping rule from a group

Unassigns a mapping rule from a group.

Parameter	Type	Description
groupId	GroupId
mappingRuleId	MappingRuleId
ct	CancellationToken

Returns: Task

UnassignUserFromGroupAsync(GroupId, Username, CancellationToken)

public Task UnassignUserFromGroupAsync(GroupId groupId, Username username, CancellationToken ct = default)

Unassign a user from a group

Unassigns a user from a group. The user is removed as a group member, with associated authorizations, roles, and tenant assignments no longer applied.

Parameter	Type	Description
groupId	GroupId
username	Username
ct	CancellationToken

Returns: Task

UpdateGroupAsync(GroupId, GroupUpdateRequest, CancellationToken)

public Task<GroupUpdateResult> UpdateGroupAsync(GroupId groupId, GroupUpdateRequest body, CancellationToken ct = default)

Update group

Update a group with the given ID.

Parameter	Type	Description
groupId	GroupId
body	GroupUpdateRequest
ct	CancellationToken

Returns: Task<GroupUpdateResult>

Tenants

AssignClientToTenantAsync(TenantId, ClientId, CancellationToken)

public Task AssignClientToTenantAsync(TenantId tenantId, ClientId clientId, CancellationToken ct = default)

Assign a client to a tenant

Assign the client to the specified tenant. The client can then access tenant data and perform authorized actions.

Parameter	Type	Description
tenantId	TenantId
clientId	ClientId
ct	CancellationToken

Returns: Task

AssignGroupToTenantAsync(TenantId, GroupId, CancellationToken)

public Task AssignGroupToTenantAsync(TenantId tenantId, GroupId groupId, CancellationToken ct = default)

Assign a group to a tenant

Assigns a group to a specified tenant. Group members (users, clients) can then access tenant data and perform authorized actions.

Parameter	Type	Description
tenantId	TenantId
groupId	GroupId
ct	CancellationToken

Returns: Task

AssignMappingRuleToTenantAsync(TenantId, MappingRuleId, CancellationToken)

public Task AssignMappingRuleToTenantAsync(TenantId tenantId, MappingRuleId mappingRuleId, CancellationToken ct = default)

Assign a mapping rule to a tenant

Assign a single mapping rule to a specified tenant.

Parameter	Type	Description
tenantId	TenantId
mappingRuleId	MappingRuleId
ct	CancellationToken

Returns: Task

AssignRoleToTenantAsync(TenantId, RoleId, CancellationToken)

public Task AssignRoleToTenantAsync(TenantId tenantId, RoleId roleId, CancellationToken ct = default)

Assign a role to a tenant

Assigns a role to a specified tenant. Users, Clients or Groups, that have the role assigned, will get access to the tenant's data and can perform actions according to their authorizations.

Parameter	Type	Description
tenantId	TenantId
roleId	RoleId
ct	CancellationToken

Returns: Task

AssignUserToTenantAsync(TenantId, Username, CancellationToken)

public Task AssignUserToTenantAsync(TenantId tenantId, Username username, CancellationToken ct = default)

Assign a user to a tenant

Assign a single user to a specified tenant. The user can then access tenant data and perform authorized actions.

Parameter	Type	Description
tenantId	TenantId
username	Username
ct	CancellationToken

Returns: Task

Example

public static async Task AssignUserToTenantExample(TenantId tenantId, Username username)
{
    using var client = CamundaClient.Create();

    await client.AssignUserToTenantAsync(
        tenantId,
        username);
}

CreateTenantAsync(TenantCreateRequest, CancellationToken)

public Task<TenantCreateResult> CreateTenantAsync(TenantCreateRequest body, CancellationToken ct = default)

Create tenant

Creates a new tenant.

Parameter	Type	Description
body	TenantCreateRequest
ct	CancellationToken

Returns: Task<TenantCreateResult>

Example

public static async Task CreateTenantExample(TenantId tenantId)
{
    using var client = CamundaClient.Create();

    var result = await client.CreateTenantAsync(new TenantCreateRequest
    {
        TenantId = tenantId,
        Name = "Acme Corporation",
    });

    Console.WriteLine($"Tenant key: {result.TenantId}");
}

DeleteTenantAsync(TenantId, CancellationToken)

public Task DeleteTenantAsync(TenantId tenantId, CancellationToken ct = default)

Delete tenant

Deletes an existing tenant.

Parameter	Type	Description
tenantId	TenantId
ct	CancellationToken

Returns: Task

Example

public static async Task DeleteTenantExample(TenantId tenantId)
{
    using var client = CamundaClient.Create();

    await client.DeleteTenantAsync(tenantId);
}

GetTenantAsync(TenantId, ConsistencyOptions<TenantResult>?, CancellationToken)

public Task<TenantResult> GetTenantAsync(TenantId tenantId, ConsistencyOptions<TenantResult>? consistency = null, CancellationToken ct = default)

Get tenant

Retrieves a single tenant by tenant ID.

Parameter	Type	Description
tenantId	TenantId
consistency	ConsistencyOptions<TenantResult>
ct	CancellationToken

Returns: Task<TenantResult>

Example

public static async Task GetTenantExample(TenantId tenantId)
{
    using var client = CamundaClient.Create();

    var result = await client.GetTenantAsync(tenantId);
    Console.WriteLine($"Tenant: {result.Name}");
}

GetUsageMetricsAsync(DateTimeOffset, DateTimeOffset, TenantId?, bool?, ConsistencyOptions<UsageMetricsResponse>?, CancellationToken)

public Task<UsageMetricsResponse> GetUsageMetricsAsync(DateTimeOffset startTime, DateTimeOffset endTime, TenantId? tenantId = null, bool? withTenants = null, ConsistencyOptions<UsageMetricsResponse>? consistency = null, CancellationToken ct = default)

Get usage metrics

Retrieve the usage metrics based on given criteria.

Parameter	Type	Description
startTime	DateTimeOffset
endTime	DateTimeOffset
tenantId	Nullable<TenantId>
withTenants	Nullable<Boolean>
consistency	ConsistencyOptions<UsageMetricsResponse>
ct	CancellationToken

Returns: Task<UsageMetricsResponse>

Example

public static async Task GetUsageMetricsExample()
{
    using var client = CamundaClient.Create();

    var result = await client.GetUsageMetricsAsync(
        startTime: new DateTimeOffset(2024, 1, 1, 0, 0, 0, TimeSpan.Zero),
        endTime: new DateTimeOffset(2024, 12, 31, 23, 59, 59, TimeSpan.Zero));

    Console.WriteLine($"Metrics: {result}");
}

SearchClientsForTenantAsync(TenantId, TenantClientSearchQueryRequest, ConsistencyOptions<TenantClientSearchResult>?, CancellationToken)

public Task<TenantClientSearchResult> SearchClientsForTenantAsync(TenantId tenantId, TenantClientSearchQueryRequest body, ConsistencyOptions<TenantClientSearchResult>? consistency = null, CancellationToken ct = default)

Search clients for tenant

Retrieves a filtered and sorted list of clients for a specified tenant.

Parameter	Type	Description
tenantId	TenantId
body	TenantClientSearchQueryRequest
consistency	ConsistencyOptions<TenantClientSearchResult>
ct	CancellationToken

Returns: Task<TenantClientSearchResult>

SearchGroupIdsForTenantAsync(TenantId, TenantGroupSearchQueryRequest, ConsistencyOptions<TenantGroupSearchResult>?, CancellationToken)

public Task<TenantGroupSearchResult> SearchGroupIdsForTenantAsync(TenantId tenantId, TenantGroupSearchQueryRequest body, ConsistencyOptions<TenantGroupSearchResult>? consistency = null, CancellationToken ct = default)

Search groups for tenant

Retrieves a filtered and sorted list of groups for a specified tenant.

Parameter	Type	Description
tenantId	TenantId
body	TenantGroupSearchQueryRequest
consistency	ConsistencyOptions<TenantGroupSearchResult>
ct	CancellationToken

Returns: Task<TenantGroupSearchResult>

Example

public static async Task SearchGroupIdsForTenantExample(TenantId tenantId)
{
    using var client = CamundaClient.Create();

    var result = await client.SearchGroupIdsForTenantAsync(
        tenantId,
        new TenantGroupSearchQueryRequest());

    foreach (var group in result.Items)
    {
        Console.WriteLine($"Group: {group.GroupId}");
    }
}

SearchMappingRulesForTenantAsync(TenantId, MappingRuleSearchQueryRequest, ConsistencyOptions<TenantMappingRuleSearchResult>?, CancellationToken)

public Task<TenantMappingRuleSearchResult> SearchMappingRulesForTenantAsync(TenantId tenantId, MappingRuleSearchQueryRequest body, ConsistencyOptions<TenantMappingRuleSearchResult>? consistency = null, CancellationToken ct = default)

Search mapping rules for tenant

Retrieves a filtered and sorted list of MappingRules for a specified tenant.

Parameter	Type	Description
tenantId	TenantId
body	MappingRuleSearchQueryRequest
consistency	ConsistencyOptions<TenantMappingRuleSearchResult>
ct	CancellationToken

Returns: Task<TenantMappingRuleSearchResult>

SearchRolesForTenantAsync(TenantId, RoleSearchQueryRequest, ConsistencyOptions<TenantRoleSearchResult>?, CancellationToken)

public Task<TenantRoleSearchResult> SearchRolesForTenantAsync(TenantId tenantId, RoleSearchQueryRequest body, ConsistencyOptions<TenantRoleSearchResult>? consistency = null, CancellationToken ct = default)

Search roles for tenant

Retrieves a filtered and sorted list of roles for a specified tenant.

Parameter	Type	Description
tenantId	TenantId
body	RoleSearchQueryRequest
consistency	ConsistencyOptions<TenantRoleSearchResult>
ct	CancellationToken

Returns: Task<TenantRoleSearchResult>

SearchTenantsAsync(TenantSearchQueryRequest, ConsistencyOptions<TenantSearchQueryResult>?, CancellationToken)

public Task<TenantSearchQueryResult> SearchTenantsAsync(TenantSearchQueryRequest body, ConsistencyOptions<TenantSearchQueryResult>? consistency = null, CancellationToken ct = default)

Search tenants

Retrieves a filtered and sorted list of tenants.

Parameter	Type	Description
body	TenantSearchQueryRequest
consistency	ConsistencyOptions<TenantSearchQueryResult>
ct	CancellationToken

Returns: Task<TenantSearchQueryResult>

Example

public static async Task SearchTenantsExample()
{
    using var client = CamundaClient.Create();

    var result = await client.SearchTenantsAsync(new TenantSearchQueryRequest());

    foreach (var tenant in result.Items)
    {
        Console.WriteLine($"Tenant: {tenant.Name}");
    }
}

SearchUsersForTenantAsync(TenantId, TenantUserSearchQueryRequest, ConsistencyOptions<TenantUserSearchResult>?, CancellationToken)

public Task<TenantUserSearchResult> SearchUsersForTenantAsync(TenantId tenantId, TenantUserSearchQueryRequest body, ConsistencyOptions<TenantUserSearchResult>? consistency = null, CancellationToken ct = default)

Search users for tenant

Retrieves a filtered and sorted list of users for a specified tenant.

Parameter	Type	Description
tenantId	TenantId
body	TenantUserSearchQueryRequest
consistency	ConsistencyOptions<TenantUserSearchResult>
ct	CancellationToken

Returns: Task<TenantUserSearchResult>

UnassignClientFromTenantAsync(TenantId, ClientId, CancellationToken)

public Task UnassignClientFromTenantAsync(TenantId tenantId, ClientId clientId, CancellationToken ct = default)

Unassign a client from a tenant

Unassigns the client from the specified tenant. The client can no longer access tenant data.

Parameter	Type	Description
tenantId	TenantId
clientId	ClientId
ct	CancellationToken

Returns: Task

UnassignGroupFromTenantAsync(TenantId, GroupId, CancellationToken)

public Task UnassignGroupFromTenantAsync(TenantId tenantId, GroupId groupId, CancellationToken ct = default)

Unassign a group from a tenant

Unassigns a group from a specified tenant. Members of the group (users, clients) will no longer have access to the tenant's data - except they are assigned directly to the tenant.

Parameter	Type	Description
tenantId	TenantId
groupId	GroupId
ct	CancellationToken

Returns: Task

UnassignMappingRuleFromTenantAsync(TenantId, MappingRuleId, CancellationToken)

public Task UnassignMappingRuleFromTenantAsync(TenantId tenantId, MappingRuleId mappingRuleId, CancellationToken ct = default)

Unassign a mapping rule from a tenant

Unassigns a single mapping rule from a specified tenant without deleting the rule.

Parameter	Type	Description
tenantId	TenantId
mappingRuleId	MappingRuleId
ct	CancellationToken

Returns: Task

UnassignRoleFromTenantAsync(TenantId, RoleId, CancellationToken)

public Task UnassignRoleFromTenantAsync(TenantId tenantId, RoleId roleId, CancellationToken ct = default)

Unassign a role from a tenant

Unassigns a role from a specified tenant. Users, Clients or Groups, that have the role assigned, will no longer have access to the tenant's data - unless they are assigned directly to the tenant.

Parameter	Type	Description
tenantId	TenantId
roleId	RoleId
ct	CancellationToken

Returns: Task

UnassignUserFromTenantAsync(TenantId, Username, CancellationToken)

public Task UnassignUserFromTenantAsync(TenantId tenantId, Username username, CancellationToken ct = default)

Unassign a user from a tenant

Unassigns the user from the specified tenant. The user can no longer access tenant data.

Parameter	Type	Description
tenantId	TenantId
username	Username
ct	CancellationToken

Returns: Task

Example

public static async Task UnassignUserFromTenantExample(TenantId tenantId, Username username)
{
    using var client = CamundaClient.Create();

    await client.UnassignUserFromTenantAsync(
        tenantId,
        username);
}

UpdateTenantAsync(TenantId, TenantUpdateRequest, CancellationToken)

public Task<TenantUpdateResult> UpdateTenantAsync(TenantId tenantId, TenantUpdateRequest body, CancellationToken ct = default)

Update tenant

Updates an existing tenant.

Parameter	Type	Description
tenantId	TenantId
body	TenantUpdateRequest
ct	CancellationToken

Returns: Task<TenantUpdateResult>

Example

public static async Task UpdateTenantExample(TenantId tenantId)
{
    using var client = CamundaClient.Create();

    await client.UpdateTenantAsync(
        tenantId,
        new TenantUpdateRequest
        {
            Name = "Acme Corp International",
        });
}

Roles

AssignRoleToClientAsync(RoleId, ClientId, CancellationToken)

public Task AssignRoleToClientAsync(RoleId roleId, ClientId clientId, CancellationToken ct = default)

Assign a role to a client

Assigns the specified role to the client. The client will inherit the authorizations associated with this role.

Parameter	Type	Description
roleId	RoleId
clientId	ClientId
ct	CancellationToken

Returns: Task

AssignRoleToGroupAsync(RoleId, GroupId, CancellationToken)

public Task AssignRoleToGroupAsync(RoleId roleId, GroupId groupId, CancellationToken ct = default)

Assign a role to a group

Assigns the specified role to the group. Every member of the group (user or client) will inherit the authorizations associated with this role.

Parameter	Type	Description
roleId	RoleId
groupId	GroupId
ct	CancellationToken

Returns: Task

AssignRoleToMappingRuleAsync(RoleId, MappingRuleId, CancellationToken)

public Task AssignRoleToMappingRuleAsync(RoleId roleId, MappingRuleId mappingRuleId, CancellationToken ct = default)

Assign a role to a mapping rule

Assigns a role to a mapping rule.

Parameter	Type	Description
roleId	RoleId
mappingRuleId	MappingRuleId
ct	CancellationToken

Returns: Task

AssignRoleToUserAsync(RoleId, Username, CancellationToken)

public Task AssignRoleToUserAsync(RoleId roleId, Username username, CancellationToken ct = default)

Assign a role to a user

Assigns the specified role to the user. The user will inherit the authorizations associated with this role.

Parameter	Type	Description
roleId	RoleId
username	Username
ct	CancellationToken

Returns: Task

CreateRoleAsync(RoleCreateRequest, CancellationToken)

public Task<RoleCreateResult> CreateRoleAsync(RoleCreateRequest body, CancellationToken ct = default)

Create role

Create a new role.

Parameter	Type	Description
body	RoleCreateRequest
ct	CancellationToken

Returns: Task<RoleCreateResult>

Example

public static async Task CreateRoleExample()
{
    using var client = CamundaClient.Create();

    var result = await client.CreateRoleAsync(new RoleCreateRequest
    {
        Name = "developer",
    });

    Console.WriteLine($"Role key: {result.RoleId}");
}

DeleteRoleAsync(RoleId, CancellationToken)

public Task DeleteRoleAsync(RoleId roleId, CancellationToken ct = default)

Delete role

Deletes the role with the given ID.

Parameter	Type	Description
roleId	RoleId
ct	CancellationToken

Returns: Task

GetRoleAsync(RoleId, ConsistencyOptions<RoleResult>?, CancellationToken)

public Task<RoleResult> GetRoleAsync(RoleId roleId, ConsistencyOptions<RoleResult>? consistency = null, CancellationToken ct = default)

Get role

Get a role by its ID.

Parameter	Type	Description
roleId	RoleId
consistency	ConsistencyOptions<RoleResult>
ct	CancellationToken

Returns: Task<RoleResult>

SearchClientsForRoleAsync(RoleId, RoleClientSearchQueryRequest, ConsistencyOptions<RoleClientSearchResult>?, CancellationToken)

public Task<RoleClientSearchResult> SearchClientsForRoleAsync(RoleId roleId, RoleClientSearchQueryRequest body, ConsistencyOptions<RoleClientSearchResult>? consistency = null, CancellationToken ct = default)

Search role clients

Search clients with assigned role.

Parameter	Type	Description
roleId	RoleId
body	RoleClientSearchQueryRequest
consistency	ConsistencyOptions<RoleClientSearchResult>
ct	CancellationToken

Returns: Task<RoleClientSearchResult>

SearchGroupsForRoleAsync(RoleId, RoleGroupSearchQueryRequest, ConsistencyOptions<RoleGroupSearchResult>?, CancellationToken)

public Task<RoleGroupSearchResult> SearchGroupsForRoleAsync(RoleId roleId, RoleGroupSearchQueryRequest body, ConsistencyOptions<RoleGroupSearchResult>? consistency = null, CancellationToken ct = default)

Search role groups

Search groups with assigned role.

Parameter	Type	Description
roleId	RoleId
body	RoleGroupSearchQueryRequest
consistency	ConsistencyOptions<RoleGroupSearchResult>
ct	CancellationToken

Returns: Task<RoleGroupSearchResult>

SearchMappingRulesForRoleAsync(RoleId, MappingRuleSearchQueryRequest, ConsistencyOptions<RoleMappingRuleSearchResult>?, CancellationToken)

public Task<RoleMappingRuleSearchResult> SearchMappingRulesForRoleAsync(RoleId roleId, MappingRuleSearchQueryRequest body, ConsistencyOptions<RoleMappingRuleSearchResult>? consistency = null, CancellationToken ct = default)

Search role mapping rules

Search mapping rules with assigned role.

Parameter	Type	Description
roleId	RoleId
body	MappingRuleSearchQueryRequest
consistency	ConsistencyOptions<RoleMappingRuleSearchResult>
ct	CancellationToken

Returns: Task<RoleMappingRuleSearchResult>

SearchRolesAsync(RoleSearchQueryRequest, ConsistencyOptions<RoleSearchQueryResult>?, CancellationToken)

public Task<RoleSearchQueryResult> SearchRolesAsync(RoleSearchQueryRequest body, ConsistencyOptions<RoleSearchQueryResult>? consistency = null, CancellationToken ct = default)

Search roles

Search for roles based on given criteria.

Parameter	Type	Description
body	RoleSearchQueryRequest
consistency	ConsistencyOptions<RoleSearchQueryResult>
ct	CancellationToken

Returns: Task<RoleSearchQueryResult>

Example

public static async Task SearchRolesExample()
{
    using var client = CamundaClient.Create();

    var result = await client.SearchRolesAsync(new RoleSearchQueryRequest());

    foreach (var role in result.Items)
    {
        Console.WriteLine($"Role: {role.Name}");
    }
}

SearchRolesForGroupAsync(GroupId, RoleSearchQueryRequest, ConsistencyOptions<GroupRoleSearchResult>?, CancellationToken)

public Task<GroupRoleSearchResult> SearchRolesForGroupAsync(GroupId groupId, RoleSearchQueryRequest body, ConsistencyOptions<GroupRoleSearchResult>? consistency = null, CancellationToken ct = default)

Search group roles

Search roles assigned to a group.

Parameter	Type	Description
groupId	GroupId
body	RoleSearchQueryRequest
consistency	ConsistencyOptions<GroupRoleSearchResult>
ct	CancellationToken

Returns: Task<GroupRoleSearchResult>

SearchUsersForRoleAsync(RoleId, RoleUserSearchQueryRequest, ConsistencyOptions<RoleUserSearchResult>?, CancellationToken)

public Task<RoleUserSearchResult> SearchUsersForRoleAsync(RoleId roleId, RoleUserSearchQueryRequest body, ConsistencyOptions<RoleUserSearchResult>? consistency = null, CancellationToken ct = default)

Search role users

Search users with assigned role.

Parameter	Type	Description
roleId	RoleId
body	RoleUserSearchQueryRequest
consistency	ConsistencyOptions<RoleUserSearchResult>
ct	CancellationToken

Returns: Task<RoleUserSearchResult>

UnassignRoleFromClientAsync(RoleId, ClientId, CancellationToken)

public Task UnassignRoleFromClientAsync(RoleId roleId, ClientId clientId, CancellationToken ct = default)

Unassign a role from a client

Unassigns the specified role from the client. The client will no longer inherit the authorizations associated with this role.

Parameter	Type	Description
roleId	RoleId
clientId	ClientId
ct	CancellationToken

Returns: Task

UnassignRoleFromGroupAsync(RoleId, GroupId, CancellationToken)

public Task UnassignRoleFromGroupAsync(RoleId roleId, GroupId groupId, CancellationToken ct = default)

Unassign a role from a group

Unassigns the specified role from the group. All group members (user or client) no longer inherit the authorizations associated with this role.

Parameter	Type	Description
roleId	RoleId
groupId	GroupId
ct	CancellationToken

Returns: Task

UnassignRoleFromMappingRuleAsync(RoleId, MappingRuleId, CancellationToken)

public Task UnassignRoleFromMappingRuleAsync(RoleId roleId, MappingRuleId mappingRuleId, CancellationToken ct = default)

Unassign a role from a mapping rule

Unassigns a role from a mapping rule.

Parameter	Type	Description
roleId	RoleId
mappingRuleId	MappingRuleId
ct	CancellationToken

Returns: Task

UnassignRoleFromUserAsync(RoleId, Username, CancellationToken)

public Task UnassignRoleFromUserAsync(RoleId roleId, Username username, CancellationToken ct = default)

Unassign a role from a user

Unassigns a role from a user. The user will no longer inherit the authorizations associated with this role.

Parameter	Type	Description
roleId	RoleId
username	Username
ct	CancellationToken

Returns: Task

UpdateRoleAsync(RoleId, RoleUpdateRequest, CancellationToken)

public Task<RoleUpdateResult> UpdateRoleAsync(RoleId roleId, RoleUpdateRequest body, CancellationToken ct = default)

Update role

Update a role with the given ID.

Parameter	Type	Description
roleId	RoleId
body	RoleUpdateRequest
ct	CancellationToken

Returns: Task<RoleUpdateResult>

User Tasks

AssignUserTaskAsync(UserTaskKey, UserTaskAssignmentRequest, CancellationToken)

public Task AssignUserTaskAsync(UserTaskKey userTaskKey, UserTaskAssignmentRequest body, CancellationToken ct = default)

Assign user task

Assigns a user task with the given key to the given assignee. Assignment waits for blocking task listeners on this lifecycle transition. If listener processing is delayed beyond the request timeout, this endpoint can return 504. Other gateway timeout causes are also possible. Retry with backoff and inspect listener worker availability and logs when this repeats.

Parameter	Type	Description
userTaskKey	UserTaskKey
body	UserTaskAssignmentRequest
ct	CancellationToken

Returns: Task

Example

public static async Task AssignUserTaskExample(UserTaskKey userTaskKey)
{
    using var client = CamundaClient.Create();

    await client.AssignUserTaskAsync(
        userTaskKey,
        new UserTaskAssignmentRequest
        {
            Assignee = "user@example.com",
        });
}

CompleteUserTaskAsync(UserTaskKey, UserTaskCompletionRequest, CancellationToken)

public Task CompleteUserTaskAsync(UserTaskKey userTaskKey, UserTaskCompletionRequest body, CancellationToken ct = default)

Complete user task

Completes a user task with the given key. Completion waits for blocking task listeners on this lifecycle transition. If listener processing is delayed beyond the request timeout, this endpoint can return 504. Other gateway timeout causes are also possible. Retry with backoff and inspect listener worker availability and logs when this repeats.

Parameter	Type	Description
userTaskKey	UserTaskKey
body	UserTaskCompletionRequest
ct	CancellationToken

Returns: Task

Example

public static async Task CompleteUserTaskExample(UserTaskKey userTaskKey)
{
    using var client = CamundaClient.Create();

    await client.CompleteUserTaskAsync(
        userTaskKey,
        new UserTaskCompletionRequest());
}

GetUserTaskAsync(UserTaskKey, ConsistencyOptions<UserTaskResult>?, CancellationToken)

public Task<UserTaskResult> GetUserTaskAsync(UserTaskKey userTaskKey, ConsistencyOptions<UserTaskResult>? consistency = null, CancellationToken ct = default)

Get user task

Get the user task by the user task key.

Parameter	Type	Description
userTaskKey	UserTaskKey
consistency	ConsistencyOptions<UserTaskResult>
ct	CancellationToken

Returns: Task<UserTaskResult>

Example

public static async Task GetUserTaskExample(UserTaskKey userTaskKey)
{
    using var client = CamundaClient.Create();

    var result = await client.GetUserTaskAsync(userTaskKey);
    Console.WriteLine($"User task: {result.UserTaskKey}");
}

GetUserTaskFormAsync(UserTaskKey, ConsistencyOptions<FormResult>?, CancellationToken)

public Task<FormResult> GetUserTaskFormAsync(UserTaskKey userTaskKey, ConsistencyOptions<FormResult>? consistency = null, CancellationToken ct = default)

Get user task form

Get the form of a user task. Note that this endpoint will only return linked forms. This endpoint does not support embedded forms.

Parameter	Type	Description
userTaskKey	UserTaskKey
consistency	ConsistencyOptions<FormResult>
ct	CancellationToken

Returns: Task<FormResult>

Example

public static async Task GetUserTaskFormExample(UserTaskKey userTaskKey)
{
    using var client = CamundaClient.Create();

    var result = await client.GetUserTaskFormAsync(userTaskKey);
    Console.WriteLine($"Form: {result.FormKey}");
}

SearchUserTaskAuditLogsAsync(UserTaskKey, UserTaskAuditLogSearchQueryRequest, ConsistencyOptions<AuditLogSearchQueryResult>?, CancellationToken)

public Task<AuditLogSearchQueryResult> SearchUserTaskAuditLogsAsync(UserTaskKey userTaskKey, UserTaskAuditLogSearchQueryRequest body, ConsistencyOptions<AuditLogSearchQueryResult>? consistency = null, CancellationToken ct = default)

Search user task audit logs

Search for user task audit logs based on given criteria.

Parameter	Type	Description
userTaskKey	UserTaskKey
body	UserTaskAuditLogSearchQueryRequest
consistency	ConsistencyOptions<AuditLogSearchQueryResult>
ct	CancellationToken

Returns: Task<AuditLogSearchQueryResult>

Example

public static async Task SearchUserTaskAuditLogsExample(UserTaskKey userTaskKey)
{
    using var client = CamundaClient.Create();

    var result = await client.SearchUserTaskAuditLogsAsync(
        userTaskKey,
        new UserTaskAuditLogSearchQueryRequest());

    foreach (var log in result.Items)
    {
        Console.WriteLine($"Audit log: {log.AuditLogKey}");
    }
}

SearchUserTaskEffectiveVariablesAsync(UserTaskKey, UserTaskEffectiveVariableSearchQueryRequest, bool?, ConsistencyOptions<VariableSearchQueryResult>?, CancellationToken)

public Task<VariableSearchQueryResult> SearchUserTaskEffectiveVariablesAsync(UserTaskKey userTaskKey, UserTaskEffectiveVariableSearchQueryRequest body, bool? truncateValues = null, ConsistencyOptions<VariableSearchQueryResult>? consistency = null, CancellationToken ct = default)

Search user task effective variables

Search for the effective variables of a user task. This endpoint returns deduplicated variables where each variable name appears at most once. When the same variable name exists at multiple scope levels in the scope hierarchy, the value from the innermost scope (closest to the user task) takes precedence. This is useful for retrieving the actual runtime state of variables as seen by the user task. By default, long variable values in the response are truncated.

Parameter	Type	Description
userTaskKey	UserTaskKey
body	UserTaskEffectiveVariableSearchQueryRequest
truncateValues	Nullable<Boolean>
consistency	ConsistencyOptions<VariableSearchQueryResult>
ct	CancellationToken

Returns: Task<VariableSearchQueryResult>

SearchUserTaskVariablesAsync(UserTaskKey, UserTaskVariableSearchQueryRequest, bool?, ConsistencyOptions<VariableSearchQueryResult>?, CancellationToken)

public Task<VariableSearchQueryResult> SearchUserTaskVariablesAsync(UserTaskKey userTaskKey, UserTaskVariableSearchQueryRequest body, bool? truncateValues = null, ConsistencyOptions<VariableSearchQueryResult>? consistency = null, CancellationToken ct = default)

Search user task variables

Search for user task variables based on given criteria. This endpoint returns all variable documents visible from the user task's scope, including variables from parent scopes in the scope hierarchy. If the same variable name exists at multiple scope levels, each scope's variable is returned as a separate result. Use the /user-tasks/{userTaskKey}/effective-variables/search endpoint to get deduplicated variables where the innermost scope takes precedence. By default, long variable values in the response are truncated.

Parameter	Type	Description
userTaskKey	UserTaskKey
body	UserTaskVariableSearchQueryRequest
truncateValues	Nullable<Boolean>
consistency	ConsistencyOptions<VariableSearchQueryResult>
ct	CancellationToken

Returns: Task<VariableSearchQueryResult>

SearchUserTasksAsync(UserTaskSearchQuery, ConsistencyOptions<UserTaskSearchQueryResult>?, CancellationToken)

public Task<UserTaskSearchQueryResult> SearchUserTasksAsync(UserTaskSearchQuery body, ConsistencyOptions<UserTaskSearchQueryResult>? consistency = null, CancellationToken ct = default)

Search user tasks

Search for user tasks based on given criteria.

Parameter	Type	Description
body	UserTaskSearchQuery
consistency	ConsistencyOptions<UserTaskSearchQueryResult>
ct	CancellationToken

Returns: Task<UserTaskSearchQueryResult>

Example

public static async Task SearchUserTasksExample()
{
    using var client = CamundaClient.Create();

    var result = await client.SearchUserTasksAsync(new UserTaskSearchQuery());

    foreach (var task in result.Items)
    {
        Console.WriteLine($"User task: {task.UserTaskKey}");
    }
}

UnassignUserTaskAsync(UserTaskKey, CancellationToken)

public Task UnassignUserTaskAsync(UserTaskKey userTaskKey, CancellationToken ct = default)

Unassign user task

Removes the assignee of a task with the given key. Unassignment waits for blocking task listeners on this lifecycle transition. If listener processing is delayed beyond the request timeout, this endpoint can return 504. Other gateway timeout causes are also possible. Retry with backoff and inspect listener worker availability and logs when this repeats.

Parameter	Type	Description
userTaskKey	UserTaskKey
ct	CancellationToken

Returns: Task

Example

public static async Task UnassignUserTaskExample(UserTaskKey userTaskKey)
{
    using var client = CamundaClient.Create();

    await client.UnassignUserTaskAsync(userTaskKey);
}

UpdateUserTaskAsync(UserTaskKey, UserTaskUpdateRequest, CancellationToken)

public Task UpdateUserTaskAsync(UserTaskKey userTaskKey, UserTaskUpdateRequest body, CancellationToken ct = default)

Update user task

Update a user task with the given key. Updates wait for blocking task listeners on this lifecycle transition. If listener processing is delayed beyond the request timeout, this endpoint can return 504. Other gateway timeout causes are also possible. Retry with backoff and inspect listener worker availability and logs when this repeats.

Parameter	Type	Description
userTaskKey	UserTaskKey
body	UserTaskUpdateRequest
ct	CancellationToken

Returns: Task

Example

public static async Task UpdateUserTaskExample(UserTaskKey userTaskKey)
{
    using var client = CamundaClient.Create();

    await client.UpdateUserTaskAsync(
        userTaskKey,
        new UserTaskUpdateRequest());
}

Signals

BroadcastSignalAsync(SignalBroadcastRequest, CancellationToken)

public Task<SignalBroadcastResult> BroadcastSignalAsync(SignalBroadcastRequest body, CancellationToken ct = default)

Broadcast signal

Broadcasts a signal.

Parameter	Type	Description
body	SignalBroadcastRequest
ct	CancellationToken

Returns: Task<SignalBroadcastResult>

Example

public static async Task BroadcastSignalExample()
{
    using var client = CamundaClient.Create();

    var result = await client.BroadcastSignalAsync(new SignalBroadcastRequest
    {
        SignalName = "orderCancelled",
    });

    Console.WriteLine($"Signal key: {result.SignalKey}");
}

Batch Operations

CancelBatchOperationAsync(BatchOperationKey, CancellationToken)

public Task CancelBatchOperationAsync(BatchOperationKey batchOperationKey, CancellationToken ct = default)

Cancel Batch operation

Cancels a running batch operation. This is done asynchronously, the progress can be tracked using the batch operation status endpoint (/batch-operations/{batchOperationKey}).

Parameter	Type	Description
batchOperationKey	BatchOperationKey
ct	CancellationToken

Returns: Task

Example

public static async Task CancelBatchOperationExample(BatchOperationKey batchOperationKey)
{
    using var client = CamundaClient.Create();

    await client.CancelBatchOperationAsync(batchOperationKey);
}

GetBatchOperationAsync(BatchOperationKey, ConsistencyOptions<BatchOperationResponse>?, CancellationToken)

public Task<BatchOperationResponse> GetBatchOperationAsync(BatchOperationKey batchOperationKey, ConsistencyOptions<BatchOperationResponse>? consistency = null, CancellationToken ct = default)

Get batch operation

Get batch operation by key.

Parameter	Type	Description
batchOperationKey	BatchOperationKey
consistency	ConsistencyOptions<BatchOperationResponse>
ct	CancellationToken

Returns: Task<BatchOperationResponse>

Example

public static async Task GetBatchOperationExample(BatchOperationKey batchOperationKey)
{
    using var client = CamundaClient.Create();

    var result = await client.GetBatchOperationAsync(
        batchOperationKey);

    Console.WriteLine($"Batch operation: {result.BatchOperationKey}");
}

ResumeBatchOperationAsync(BatchOperationKey, CancellationToken)

public Task ResumeBatchOperationAsync(BatchOperationKey batchOperationKey, CancellationToken ct = default)

Resume Batch operation

Resumes a suspended batch operation. This is done asynchronously, the progress can be tracked using the batch operation status endpoint (/batch-operations/{batchOperationKey}).

Parameter	Type	Description
batchOperationKey	BatchOperationKey
ct	CancellationToken

Returns: Task

Example

public static async Task ResumeBatchOperationExample(BatchOperationKey batchOperationKey)
{
    using var client = CamundaClient.Create();

    await client.ResumeBatchOperationAsync(batchOperationKey);
}

SearchBatchOperationItemsAsync(BatchOperationItemSearchQuery, ConsistencyOptions<BatchOperationItemSearchQueryResult>?, CancellationToken)

public Task<BatchOperationItemSearchQueryResult> SearchBatchOperationItemsAsync(BatchOperationItemSearchQuery body, ConsistencyOptions<BatchOperationItemSearchQueryResult>? consistency = null, CancellationToken ct = default)

Search batch operation items

Search for batch operation items based on given criteria.

Parameter	Type	Description
body	BatchOperationItemSearchQuery
consistency	ConsistencyOptions<BatchOperationItemSearchQueryResult>
ct	CancellationToken

Returns: Task<BatchOperationItemSearchQueryResult>

Example

public static async Task SearchBatchOperationItemsExample()
{
    using var client = CamundaClient.Create();

    var result = await client.SearchBatchOperationItemsAsync(
        new BatchOperationItemSearchQuery());

    foreach (var item in result.Items)
    {
        Console.WriteLine($"Item: {item.ItemKey}");
    }
}

SearchBatchOperationsAsync(BatchOperationSearchQuery, ConsistencyOptions<BatchOperationSearchQueryResult>?, CancellationToken)

public Task<BatchOperationSearchQueryResult> SearchBatchOperationsAsync(BatchOperationSearchQuery body, ConsistencyOptions<BatchOperationSearchQueryResult>? consistency = null, CancellationToken ct = default)

Search batch operations

Search for batch operations based on given criteria.

Parameter	Type	Description
body	BatchOperationSearchQuery
consistency	ConsistencyOptions<BatchOperationSearchQueryResult>
ct	CancellationToken

Returns: Task<BatchOperationSearchQueryResult>

Example

public static async Task SearchBatchOperationsExample()
{
    using var client = CamundaClient.Create();

    var result = await client.SearchBatchOperationsAsync(
        new BatchOperationSearchQuery());

    foreach (var op in result.Items)
    {
        Console.WriteLine($"Batch operation: {op.BatchOperationKey}");
    }
}

SuspendBatchOperationAsync(BatchOperationKey, CancellationToken)

public Task SuspendBatchOperationAsync(BatchOperationKey batchOperationKey, CancellationToken ct = default)

Suspend Batch operation

Suspends a running batch operation. This is done asynchronously, the progress can be tracked using the batch operation status endpoint (/batch-operations/{batchOperationKey}).

Parameter	Type	Description
batchOperationKey	BatchOperationKey
ct	CancellationToken

Returns: Task

Example

public static async Task SuspendBatchOperationExample(BatchOperationKey batchOperationKey)
{
    using var client = CamundaClient.Create();

    await client.SuspendBatchOperationAsync(batchOperationKey);
}

Messages

CorrelateMessageAsync(MessageCorrelationRequest, CancellationToken)

public Task<MessageCorrelationResult> CorrelateMessageAsync(MessageCorrelationRequest body, CancellationToken ct = default)

Correlate message

Publishes a message and correlates it to a subscription. If correlation is successful it will return the first process instance key the message correlated with. The message is not buffered. Use the publish message endpoint to send messages that can be buffered.

Parameter	Type	Description
body	MessageCorrelationRequest
ct	CancellationToken

Returns: Task<MessageCorrelationResult>

Example

public static async Task CorrelateMessageExample()
{
    using var client = CamundaClient.Create();

    var result = await client.CorrelateMessageAsync(new MessageCorrelationRequest
    {
        Name = "paymentReceived",
        CorrelationKey = "order-123",
    });

    Console.WriteLine($"Message key: {result.MessageKey}");
}

PublishMessageAsync(MessagePublicationRequest, CancellationToken)

public Task<MessagePublicationResult> PublishMessageAsync(MessagePublicationRequest body, CancellationToken ct = default)

Publish message

Publishes a single message. Messages are published to specific partitions computed from their correlation keys. Messages can be buffered. The endpoint does not wait for a correlation result. Use the message correlation endpoint for such use cases.

Parameter	Type	Description
body	MessagePublicationRequest
ct	CancellationToken

Returns: Task<MessagePublicationResult>

Example

public static async Task PublishMessageExample()
{
    using var client = CamundaClient.Create();

    var result = await client.PublishMessageAsync(new MessagePublicationRequest
    {
        Name = "paymentReceived",
        CorrelationKey = "order-123",
        TimeToLive = 60000,
    });

    Console.WriteLine($"Message key: {result.MessageKey}");
}

SearchCorrelatedMessageSubscriptionsAsync(CorrelatedMessageSubscriptionSearchQuery, ConsistencyOptions<CorrelatedMessageSubscriptionSearchQueryResult>?, CancellationToken)

public Task<CorrelatedMessageSubscriptionSearchQueryResult> SearchCorrelatedMessageSubscriptionsAsync(CorrelatedMessageSubscriptionSearchQuery body, ConsistencyOptions<CorrelatedMessageSubscriptionSearchQueryResult>? consistency = null, CancellationToken ct = default)

Search correlated message subscriptions

Search correlated message subscriptions based on given criteria.

Parameter	Type	Description
body	CorrelatedMessageSubscriptionSearchQuery
consistency	ConsistencyOptions<CorrelatedMessageSubscriptionSearchQueryResult>
ct	CancellationToken

Returns: Task<CorrelatedMessageSubscriptionSearchQueryResult>

Example

public static async Task SearchCorrelatedMessageSubscriptionsExample()
{
    using var client = CamundaClient.Create();

    var result = await client.SearchCorrelatedMessageSubscriptionsAsync(
        new CorrelatedMessageSubscriptionSearchQuery());

    foreach (var sub in result.Items)
    {
        Console.WriteLine($"Correlated subscription: {sub.MessageName}");
    }
}

SearchMessageSubscriptionsAsync(MessageSubscriptionSearchQuery, ConsistencyOptions<MessageSubscriptionSearchQueryResult>?, CancellationToken)

public Task<MessageSubscriptionSearchQueryResult> SearchMessageSubscriptionsAsync(MessageSubscriptionSearchQuery body, ConsistencyOptions<MessageSubscriptionSearchQueryResult>? consistency = null, CancellationToken ct = default)

Search message subscriptions

Search for message subscriptions based on given criteria.

By default, both start and intermediate event subscriptions are returned. Use the messageSubscriptionType filter to restrict results to a single type.

Version notes:

• Start event subscriptions are only captured for deployments made with 8.10 or later.
• The messageSubscriptionType field is only populated for data created

with Camunda 8.10 or later. For pre-8.10 data, intermediate event entries have no messageSubscriptionType value stored. For convenience, the API returns PROCESS_EVENT as a default for such search results, though.

• Searching for intermediate event subscriptions including legacy data can be achieved

by filtering for messageSubscriptionType not matching START_EVENT.

Parameter	Type	Description
body	MessageSubscriptionSearchQuery
consistency	ConsistencyOptions<MessageSubscriptionSearchQueryResult>
ct	CancellationToken

Returns: Task<MessageSubscriptionSearchQueryResult>

Example

public static async Task SearchMessageSubscriptionsExample()
{
    using var client = CamundaClient.Create();

    var result = await client.SearchMessageSubscriptionsAsync(
        new MessageSubscriptionSearchQuery());

    foreach (var sub in result.Items)
    {
        Console.WriteLine($"Subscription: {sub.MessageName}");
    }
}

Authorizations

CreateAuthorizationAsync(AuthorizationRequest, CancellationToken)

public Task<AuthorizationCreateResult> CreateAuthorizationAsync(AuthorizationRequest body, CancellationToken ct = default)

Create authorization

Create the authorization.

Parameter	Type	Description
body	AuthorizationRequest
ct	CancellationToken

Returns: Task<AuthorizationCreateResult>

Example

public static async Task CreateAuthorizationExample()
{
    using var client = CamundaClient.Create();

    var result = await client.CreateAuthorizationAsync(new AuthorizationPropertyBasedRequest
    {
        ResourceType = ResourceTypeEnum.PROCESSDEFINITION,
        PermissionTypes = new List<PermissionTypeEnum> { PermissionTypeEnum.READ, PermissionTypeEnum.UPDATE },
        ResourcePropertyName = "my-process",
        OwnerType = OwnerTypeEnum.USER,
        OwnerId = "user@example.com",
    });

    Console.WriteLine($"Authorization key: {result.AuthorizationKey}");
}

DeleteAuthorizationAsync(AuthorizationKey, CancellationToken)

public Task DeleteAuthorizationAsync(AuthorizationKey authorizationKey, CancellationToken ct = default)

Delete authorization

Deletes the authorization with the given key.

Parameter	Type	Description
authorizationKey	AuthorizationKey
ct	CancellationToken

Returns: Task

Example

public static async Task DeleteAuthorizationExample(AuthorizationKey authorizationKey)
{
    using var client = CamundaClient.Create();

    await client.DeleteAuthorizationAsync(authorizationKey);
}

GetAuthorizationAsync(AuthorizationKey, ConsistencyOptions<AuthorizationResult>?, CancellationToken)

public Task<AuthorizationResult> GetAuthorizationAsync(AuthorizationKey authorizationKey, ConsistencyOptions<AuthorizationResult>? consistency = null, CancellationToken ct = default)

Get authorization

Get authorization by the given key.

Parameter	Type	Description
authorizationKey	AuthorizationKey
consistency	ConsistencyOptions<AuthorizationResult>
ct	CancellationToken

Returns: Task<AuthorizationResult>

Example

public static async Task GetAuthorizationExample(AuthorizationKey authorizationKey)
{
    using var client = CamundaClient.Create();

    var result = await client.GetAuthorizationAsync(
        authorizationKey);

    Console.WriteLine($"Resource type: {result.ResourceType}");
}

SearchAuthorizationsAsync(AuthorizationSearchQuery, ConsistencyOptions<AuthorizationSearchResult>?, CancellationToken)

public Task<AuthorizationSearchResult> SearchAuthorizationsAsync(AuthorizationSearchQuery body, ConsistencyOptions<AuthorizationSearchResult>? consistency = null, CancellationToken ct = default)

Search authorizations

Search for authorizations based on given criteria.

Parameter	Type	Description
body	AuthorizationSearchQuery
consistency	ConsistencyOptions<AuthorizationSearchResult>
ct	CancellationToken

Returns: Task<AuthorizationSearchResult>

Example

public static async Task SearchAuthorizationsExample()
{
    using var client = CamundaClient.Create();

    var result = await client.SearchAuthorizationsAsync(
        new AuthorizationSearchQuery());

    foreach (var auth in result.Items)
    {
        Console.WriteLine($"Authorization: {auth.AuthorizationKey}");
    }
}

UpdateAuthorizationAsync(AuthorizationKey, AuthorizationRequest, CancellationToken)

public Task UpdateAuthorizationAsync(AuthorizationKey authorizationKey, AuthorizationRequest body, CancellationToken ct = default)

Update authorization

Update the authorization with the given key.

Parameter	Type	Description
authorizationKey	AuthorizationKey
body	AuthorizationRequest
ct	CancellationToken

Returns: Task

Example

public static async Task UpdateAuthorizationExample(AuthorizationKey authorizationKey)
{
    using var client = CamundaClient.Create();

    await client.UpdateAuthorizationAsync(
        authorizationKey,
        new AuthorizationPropertyBasedRequest
        {
            ResourceType = ResourceTypeEnum.PROCESSDEFINITION,
            PermissionTypes = new List<PermissionTypeEnum> { PermissionTypeEnum.READ, PermissionTypeEnum.UPDATE, PermissionTypeEnum.DELETE },
            ResourcePropertyName = "my-process",
            OwnerType = OwnerTypeEnum.USER,
            OwnerId = "user@example.com",
        });
}

Deployments

CreateDeploymentAsync(MultipartFormDataContent, CancellationToken)

public Task<DeploymentResult> CreateDeploymentAsync(MultipartFormDataContent content, CancellationToken ct = default)

Deploy resources

Deploys one or more resources, including BPMN processes, DMN decision models, forms, RPA resources, and generic files. A deployment can contain any file type. Files that are not interpreted as BPMN, DMN, form, or RPA resources are stored as deployable generic resources in the engine. This is an atomic call, i.e. either all resources are deployed or none of them are.

Parameter	Type	Description
content	MultipartFormDataContent
ct	CancellationToken

Returns: Task<DeploymentResult>

Example

public static async Task CreateDeploymentExample()
{
    using var client = CamundaClient.Create();

    var content = new MultipartFormDataContent();
    var fileContent = new ByteArrayContent(File.ReadAllBytes("process.bpmn"));
    content.Add(fileContent, "resources", "process.bpmn");

    var result = await client.CreateDeploymentAsync(content);
    Console.WriteLine($"Deployment key: {result.DeploymentKey}");
}

Documents

CreateDocumentAsync(MultipartFormDataContent, string?, DocumentId?, CancellationToken)

public Task<DocumentReference> CreateDocumentAsync(MultipartFormDataContent content, string? storeId = null, DocumentId? documentId = null, CancellationToken ct = default)

Upload document

Upload a document to the Camunda 8 cluster.

Note that this is currently supported for document stores of type: AWS, Azure, GCP, in-memory (non-production), local (non-production)

Parameter	Type	Description
content	MultipartFormDataContent
storeId	String
documentId	Nullable<DocumentId>
ct	CancellationToken

Returns: Task<DocumentReference>

Example

public static async Task CreateDocumentExample()
{
    using var client = CamundaClient.Create();

    using var content = new MultipartFormDataContent();
    content.Add(new ByteArrayContent(System.Text.Encoding.UTF8.GetBytes("Hello, world!")), "file", "hello.txt");

    var result = await client.CreateDocumentAsync(content);

    Console.WriteLine($"Document ID: {result.DocumentId}");
}

CreateDocumentLinkAsync(DocumentId, DocumentLinkRequest, string?, string?, CancellationToken)

public Task<DocumentLink> CreateDocumentLinkAsync(DocumentId documentId, DocumentLinkRequest body, string? storeId = null, string? contentHash = null, CancellationToken ct = default)

Create document link

Create a link to a document in the Camunda 8 cluster.

Note that this is currently supported for document stores of type: AWS, Azure, GCP

Parameter	Type	Description
documentId	DocumentId
body	DocumentLinkRequest
storeId	String
contentHash	String
ct	CancellationToken

Returns: Task<DocumentLink>

Example

public static async Task CreateDocumentLinkExample(DocumentId documentId)
{
    using var client = CamundaClient.Create();

    var result = await client.CreateDocumentLinkAsync(
        documentId,
        new DocumentLinkRequest());

    Console.WriteLine($"Document link: {result.Url}");
}

CreateDocumentsAsync(MultipartFormDataContent, string?, CancellationToken)

public Task<DocumentCreationBatchResponse> CreateDocumentsAsync(MultipartFormDataContent content, string? storeId = null, CancellationToken ct = default)

Upload multiple documents

Upload multiple documents to the Camunda 8 cluster.

The caller must provide a file name for each document, which will be used in case of a multi-status response to identify which documents failed to upload. The file name can be provided in the Content-Disposition header of the file part or in the fileName field of the metadata. You can add a parallel array of metadata objects. These are matched with the files based on index, and must have the same length as the files array. To pass homogenous metadata for all files, spread the metadata over the metadata array. A filename value provided explicitly via the metadata array in the request overrides the Content-Disposition header of the file part.

In case of a multi-status response, the response body will contain a list of DocumentBatchProblemDetail objects, each of which contains the file name of the document that failed to upload and the reason for the failure. The client can choose to retry the whole batch or individual documents based on the response.

Note that this is currently supported for document stores of type: AWS, Azure, GCP, in-memory (non-production), local (non-production)

Parameter	Type	Description
content	MultipartFormDataContent
storeId	String
ct	CancellationToken

Returns: Task<DocumentCreationBatchResponse>

Example

public static async Task CreateDocumentsExample()
{
    using var client = CamundaClient.Create();

    using var content = new MultipartFormDataContent();
    content.Add(new ByteArrayContent(System.Text.Encoding.UTF8.GetBytes("File one")), "files", "one.txt");
    content.Add(new ByteArrayContent(System.Text.Encoding.UTF8.GetBytes("File two")), "files", "two.txt");

    var result = await client.CreateDocumentsAsync(content);

    foreach (var doc in result.CreatedDocuments)
    {
        Console.WriteLine($"Created: {doc.DocumentId}");
    }
}

DeleteDocumentAsync(DocumentId, string?, CancellationToken)

public Task DeleteDocumentAsync(DocumentId documentId, string? storeId = null, CancellationToken ct = default)

Delete document

Delete a document from the Camunda 8 cluster.

Note that this is currently supported for document stores of type: AWS, Azure, GCP, in-memory (non-production), local (non-production)

Parameter	Type	Description
documentId	DocumentId
storeId	String
ct	CancellationToken

Returns: Task

Example

public static async Task DeleteDocumentExample(DocumentId documentId)
{
    using var client = CamundaClient.Create();

    await client.DeleteDocumentAsync(documentId);
}

GetDocumentAsync(DocumentId, string?, string?, CancellationToken)

public Task<byte[]> GetDocumentAsync(DocumentId documentId, string? storeId = null, string? contentHash = null, CancellationToken ct = default)

Download document

Download a document from the Camunda 8 cluster.

Note that this is currently supported for document stores of type: AWS, Azure, GCP, in-memory (non-production), local (non-production)

Parameter	Type	Description
documentId	DocumentId
storeId	String
contentHash	String
ct	CancellationToken

Returns: Task<Byte[]>

Example

public static async Task GetDocumentExample(DocumentId documentId)
{
    using var client = CamundaClient.Create();

    var content = await client.GetDocumentAsync(documentId);

    Console.WriteLine($"Downloaded document: {documentId}");
}

Variables

CreateElementInstanceVariablesAsync(ElementInstanceKey, SetVariableRequest, CancellationToken)

public Task CreateElementInstanceVariablesAsync(ElementInstanceKey elementInstanceKey, SetVariableRequest body, CancellationToken ct = default)

Update element instance variables

Updates all the variables of a particular scope (for example, process instance, element instance) with the given variable data. Specify the element instance in the elementInstanceKey parameter. Variable updates can be delayed by listener-related processing; if processing exceeds the request timeout, this endpoint can return 504. Other gateway timeout causes are also possible. Retry with backoff and inspect listener worker availability and logs when this repeats.

Parameter	Type	Description
elementInstanceKey	ElementInstanceKey
body	SetVariableRequest
ct	CancellationToken

Returns: Task

Example

public static async Task CreateElementInstanceVariablesExample(ElementInstanceKey elementInstanceKey)
{
    using var client = CamundaClient.Create();

    await client.CreateElementInstanceVariablesAsync(
        elementInstanceKey,
        new SetVariableRequest());
}

CreateGlobalClusterVariableAsync(CreateClusterVariableRequest, CancellationToken)

public Task<ClusterVariableResult> CreateGlobalClusterVariableAsync(CreateClusterVariableRequest body, CancellationToken ct = default)

Create a global-scoped cluster variable

Create a global-scoped cluster variable.

Parameter	Type	Description
body	CreateClusterVariableRequest
ct	CancellationToken

Returns: Task<ClusterVariableResult>

Example

public static async Task CreateGlobalClusterVariableExample(ClusterVariableName name)
{
    using var client = CamundaClient.Create();

    var result = await client.CreateGlobalClusterVariableAsync(
        new CreateClusterVariableRequest
        {
            Name = name,
            Value = "my-value",
        });

    Console.WriteLine($"Created variable: {result.Name}");
}

CreateTenantClusterVariableAsync(TenantId, CreateClusterVariableRequest, CancellationToken)

public Task<ClusterVariableResult> CreateTenantClusterVariableAsync(TenantId tenantId, CreateClusterVariableRequest body, CancellationToken ct = default)

Create a tenant-scoped cluster variable

Create a new cluster variable for the given tenant.

Parameter	Type	Description
tenantId	TenantId
body	CreateClusterVariableRequest
ct	CancellationToken

Returns: Task<ClusterVariableResult>

Example

public static async Task CreateTenantClusterVariableExample(TenantId tenantId, ClusterVariableName name)
{
    using var client = CamundaClient.Create();

    var result = await client.CreateTenantClusterVariableAsync(
        tenantId,
        new CreateClusterVariableRequest
        {
            Name = name,
            Value = "tenant-value",
        });

    Console.WriteLine($"Created variable: {result.Name}");
}

DeleteGlobalClusterVariableAsync(ClusterVariableName, CancellationToken)

public Task DeleteGlobalClusterVariableAsync(ClusterVariableName name, CancellationToken ct = default)

Delete a global-scoped cluster variable

Delete a global-scoped cluster variable.

Parameter	Type	Description
name	ClusterVariableName
ct	CancellationToken

Returns: Task

DeleteTenantClusterVariableAsync(TenantId, ClusterVariableName, CancellationToken)

public Task DeleteTenantClusterVariableAsync(TenantId tenantId, ClusterVariableName name, CancellationToken ct = default)

Delete a tenant-scoped cluster variable

Delete a tenant-scoped cluster variable.

Parameter	Type	Description
tenantId	TenantId
name	ClusterVariableName
ct	CancellationToken

Returns: Task

GetGlobalClusterVariableAsync(ClusterVariableName, ConsistencyOptions<ClusterVariableResult>?, CancellationToken)

public Task<ClusterVariableResult> GetGlobalClusterVariableAsync(ClusterVariableName name, ConsistencyOptions<ClusterVariableResult>? consistency = null, CancellationToken ct = default)

Get a global-scoped cluster variable

Get a global-scoped cluster variable.

Parameter	Type	Description
name	ClusterVariableName
consistency	ConsistencyOptions<ClusterVariableResult>
ct	CancellationToken

Returns: Task<ClusterVariableResult>

GetTenantClusterVariableAsync(TenantId, ClusterVariableName, ConsistencyOptions<ClusterVariableResult>?, CancellationToken)

public Task<ClusterVariableResult> GetTenantClusterVariableAsync(TenantId tenantId, ClusterVariableName name, ConsistencyOptions<ClusterVariableResult>? consistency = null, CancellationToken ct = default)

Get a tenant-scoped cluster variable

Get a tenant-scoped cluster variable.

Parameter	Type	Description
tenantId	TenantId
name	ClusterVariableName
consistency	ConsistencyOptions<ClusterVariableResult>
ct	CancellationToken

Returns: Task<ClusterVariableResult>

GetVariableAsync(VariableKey, ConsistencyOptions<VariableResult>?, CancellationToken)

public Task<VariableResult> GetVariableAsync(VariableKey variableKey, ConsistencyOptions<VariableResult>? consistency = null, CancellationToken ct = default)

Get variable

Get a variable by its key.

This endpoint returns both process-level and local (element-scoped) variables. The variable's scopeKey indicates whether it's a process-level variable or scoped to a specific element instance.

Parameter	Type	Description
variableKey	VariableKey
consistency	ConsistencyOptions<VariableResult>
ct	CancellationToken

Returns: Task<VariableResult>

Example

public static async Task GetVariableExample(VariableKey variableKey)
{
    using var client = CamundaClient.Create();

    var result = await client.GetVariableAsync(variableKey);
    Console.WriteLine($"Variable: {result.Name} = {result.Value}");
}

SearchClusterVariablesAsync(ClusterVariableSearchQueryRequest, bool?, ConsistencyOptions<ClusterVariableSearchQueryResult>?, CancellationToken)

public Task<ClusterVariableSearchQueryResult> SearchClusterVariablesAsync(ClusterVariableSearchQueryRequest body, bool? truncateValues = null, ConsistencyOptions<ClusterVariableSearchQueryResult>? consistency = null, CancellationToken ct = default)

Search for cluster variables based on given criteria. By default, long variable values in the response are truncated.

Parameter	Type	Description
body	ClusterVariableSearchQueryRequest
truncateValues	Nullable<Boolean>
consistency	ConsistencyOptions<ClusterVariableSearchQueryResult>
ct	CancellationToken

Returns: Task<ClusterVariableSearchQueryResult>

Example

public static async Task SearchClusterVariablesExample()
{
    using var client = CamundaClient.Create();

    var result = await client.SearchClusterVariablesAsync(
        new ClusterVariableSearchQueryRequest());

    foreach (var variable in result.Items)
    {
        Console.WriteLine($"Variable: {variable.Name}");
    }
}

SearchVariablesAsync(VariableSearchQuery, bool?, ConsistencyOptions<VariableSearchQueryResult>?, CancellationToken)

public Task<VariableSearchQueryResult> SearchVariablesAsync(VariableSearchQuery body, bool? truncateValues = null, ConsistencyOptions<VariableSearchQueryResult>? consistency = null, CancellationToken ct = default)

Search variables

Search for variables based on given criteria.

This endpoint returns variables that exist directly at the specified scopes - it does not include variables from parent scopes that would be visible through the scope hierarchy.

Variables can be process-level (scoped to the process instance) or local (scoped to specific BPMN elements like tasks, subprocesses, etc.).

By default, long variable values in the response are truncated.

Parameter	Type	Description
body	VariableSearchQuery
truncateValues	Nullable<Boolean>
consistency	ConsistencyOptions<VariableSearchQueryResult>
ct	CancellationToken

Returns: Task<VariableSearchQueryResult>

UpdateGlobalClusterVariableAsync(ClusterVariableName, UpdateClusterVariableRequest, CancellationToken)

public Task<ClusterVariableResult> UpdateGlobalClusterVariableAsync(ClusterVariableName name, UpdateClusterVariableRequest body, CancellationToken ct = default)

Update a global-scoped cluster variable

Updates the value of an existing global cluster variable. The variable must exist, otherwise a 404 error is returned.

Parameter	Type	Description
name	ClusterVariableName
body	UpdateClusterVariableRequest
ct	CancellationToken

Returns: Task<ClusterVariableResult>

UpdateTenantClusterVariableAsync(TenantId, ClusterVariableName, UpdateClusterVariableRequest, CancellationToken)

public Task<ClusterVariableResult> UpdateTenantClusterVariableAsync(TenantId tenantId, ClusterVariableName name, UpdateClusterVariableRequest body, CancellationToken ct = default)

Update a tenant-scoped cluster variable

Updates the value of an existing tenant-scoped cluster variable. The variable must exist, otherwise a 404 error is returned.

Parameter	Type	Description
tenantId	TenantId
name	ClusterVariableName
body	UpdateClusterVariableRequest
ct	CancellationToken

Returns: Task<ClusterVariableResult>

Mappings

CreateMappingRuleAsync(MappingRuleCreateRequest, CancellationToken)

public Task<MappingRuleCreateResult> CreateMappingRuleAsync(MappingRuleCreateRequest body, CancellationToken ct = default)

Create mapping rule

Create a new mapping rule

Parameter	Type	Description
body	MappingRuleCreateRequest
ct	CancellationToken

Returns: Task<MappingRuleCreateResult>

Example

public static async Task CreateMappingRuleExample()
{
    using var client = CamundaClient.Create();

    var result = await client.CreateMappingRuleAsync(new MappingRuleCreateRequest
    {
        ClaimName = "groups",
        ClaimValue = "engineering",
        Name = "Engineering Group Mapping",
    });

    Console.WriteLine($"Mapping rule: {result.MappingRuleId}");
}

DeleteMappingRuleAsync(MappingRuleId, CancellationToken)

public Task DeleteMappingRuleAsync(MappingRuleId mappingRuleId, CancellationToken ct = default)

Delete a mapping rule

Deletes the mapping rule with the given ID.

Parameter	Type	Description
mappingRuleId	MappingRuleId
ct	CancellationToken

Returns: Task

GetMappingRuleAsync(MappingRuleId, ConsistencyOptions<MappingRuleResult>?, CancellationToken)

public Task<MappingRuleResult> GetMappingRuleAsync(MappingRuleId mappingRuleId, ConsistencyOptions<MappingRuleResult>? consistency = null, CancellationToken ct = default)

Get a mapping rule

Gets the mapping rule with the given ID.

Parameter	Type	Description
mappingRuleId	MappingRuleId
consistency	ConsistencyOptions<MappingRuleResult>
ct	CancellationToken

Returns: Task<MappingRuleResult>

SearchMappingRuleAsync(MappingRuleSearchQueryRequest, ConsistencyOptions<MappingRuleSearchQueryResult>?, CancellationToken)

public Task<MappingRuleSearchQueryResult> SearchMappingRuleAsync(MappingRuleSearchQueryRequest body, ConsistencyOptions<MappingRuleSearchQueryResult>? consistency = null, CancellationToken ct = default)

Search mapping rules

Search for mapping rules based on given criteria.

Parameter	Type	Description
body	MappingRuleSearchQueryRequest
consistency	ConsistencyOptions<MappingRuleSearchQueryResult>
ct	CancellationToken

Returns: Task<MappingRuleSearchQueryResult>

UpdateMappingRuleAsync(MappingRuleId, MappingRuleUpdateRequest, CancellationToken)

public Task<MappingRuleUpdateResult> UpdateMappingRuleAsync(MappingRuleId mappingRuleId, MappingRuleUpdateRequest body, CancellationToken ct = default)

Update mapping rule

Update a mapping rule.

Parameter	Type	Description
mappingRuleId	MappingRuleId
body	MappingRuleUpdateRequest
ct	CancellationToken

Returns: Task<MappingRuleUpdateResult>

Decision Instances

DeleteDecisionInstanceAsync(DecisionEvaluationKey, DeleteDecisionInstanceRequest, CancellationToken)

public Task DeleteDecisionInstanceAsync(DecisionEvaluationKey decisionEvaluationKey, DeleteDecisionInstanceRequest body, CancellationToken ct = default)

Delete decision instance

Delete all associated decision evaluations based on provided key.

Parameter	Type	Description
decisionEvaluationKey	DecisionEvaluationKey
body	DeleteDecisionInstanceRequest
ct	CancellationToken

Returns: Task

Example

public static async Task DeleteDecisionInstanceExample(DecisionEvaluationKey decisionEvaluationKey)
{
    using var client = CamundaClient.Create();

    await client.DeleteDecisionInstanceAsync(
        decisionEvaluationKey,
        new DeleteDecisionInstanceRequest());
}

DeleteDecisionInstancesBatchOperationAsync(DecisionInstanceDeletionBatchOperationRequest, CancellationToken)

public Task<BatchOperationCreatedResult> DeleteDecisionInstancesBatchOperationAsync(DecisionInstanceDeletionBatchOperationRequest body, CancellationToken ct = default)

Delete decision instances (batch)

Delete multiple decision instances. This will delete the historic data from secondary storage. This is done asynchronously, the progress can be tracked using the batchOperationKey from the response and the batch operation status endpoint (/batch-operations/{batchOperationKey}).

Parameter	Type	Description
body	DecisionInstanceDeletionBatchOperationRequest
ct	CancellationToken

Returns: Task<BatchOperationCreatedResult>

Example

public static async Task DeleteDecisionInstancesBatchOperationExample()
{
    using var client = CamundaClient.Create();

    var result = await client.DeleteDecisionInstancesBatchOperationAsync(
        new DecisionInstanceDeletionBatchOperationRequest());

    Console.WriteLine($"Batch operation key: {result.BatchOperationKey}");
}

GetDecisionInstanceAsync(DecisionEvaluationInstanceKey, ConsistencyOptions<DecisionInstanceGetQueryResult>?, CancellationToken)

public Task<DecisionInstanceGetQueryResult> GetDecisionInstanceAsync(DecisionEvaluationInstanceKey decisionEvaluationInstanceKey, ConsistencyOptions<DecisionInstanceGetQueryResult>? consistency = null, CancellationToken ct = default)

Get decision instance

Returns a decision instance.

Parameter	Type	Description
decisionEvaluationInstanceKey	DecisionEvaluationInstanceKey
consistency	ConsistencyOptions<DecisionInstanceGetQueryResult>
ct	CancellationToken

Returns: Task<DecisionInstanceGetQueryResult>

Example

public static async Task GetDecisionInstanceExample(DecisionEvaluationInstanceKey decisionEvaluationInstanceKey)
{
    using var client = CamundaClient.Create();

    var result = await client.GetDecisionInstanceAsync(
        decisionEvaluationInstanceKey);

    Console.WriteLine($"Decision instance: {result.DecisionDefinitionId}");
}

SearchDecisionInstancesAsync(DecisionInstanceSearchQuery, ConsistencyOptions<DecisionInstanceSearchQueryResult>?, CancellationToken)

public Task<DecisionInstanceSearchQueryResult> SearchDecisionInstancesAsync(DecisionInstanceSearchQuery body, ConsistencyOptions<DecisionInstanceSearchQueryResult>? consistency = null, CancellationToken ct = default)

Search decision instances

Search for decision instances based on given criteria.

Parameter	Type	Description
body	DecisionInstanceSearchQuery
consistency	ConsistencyOptions<DecisionInstanceSearchQueryResult>
ct	CancellationToken

Returns: Task<DecisionInstanceSearchQueryResult>

Example

public static async Task SearchDecisionInstancesExample()
{
    using var client = CamundaClient.Create();

    var result = await client.SearchDecisionInstancesAsync(
        new DecisionInstanceSearchQuery());

    foreach (var di in result.Items)
    {
        Console.WriteLine($"Decision instance: {di.DecisionDefinitionId}");
    }
}

Decisions

EvaluateDecisionAsync(DecisionEvaluationInstruction, CancellationToken)

public Task<EvaluateDecisionResult> EvaluateDecisionAsync(DecisionEvaluationInstruction body, CancellationToken ct = default)

Evaluate decision

Evaluates a decision. You specify the decision to evaluate either by using its unique key (as returned by DeployResource), or using the decision ID. When using the decision ID, the latest deployed version of the decision is used.

Parameter	Type	Description
body	DecisionEvaluationInstruction
ct	CancellationToken

Returns: Task<EvaluateDecisionResult>

Example

public static async Task EvaluateDecisionByIdExample(DecisionDefinitionId decisionDefinitionId)
{
    using var client = CamundaClient.Create();

    var result = await client.EvaluateDecisionAsync(new DecisionEvaluationById
    {
        DecisionDefinitionId = decisionDefinitionId,
    });

    Console.WriteLine($"Decision output: {result.Output}");
}

public static async Task EvaluateDecisionByKeyExample(DecisionDefinitionKey decisionDefinitionKey)
{
    using var client = CamundaClient.Create();

    var result = await client.EvaluateDecisionAsync(new DecisionEvaluationByKey
    {
        DecisionDefinitionKey = decisionDefinitionKey,
    });

    Console.WriteLine($"Decision output: {result.Output}");
}

Audit Logs

GetAuditLogAsync(AuditLogKey, ConsistencyOptions<AuditLogResult>?, CancellationToken)

public Task<AuditLogResult> GetAuditLogAsync(AuditLogKey auditLogKey, ConsistencyOptions<AuditLogResult>? consistency = null, CancellationToken ct = default)

Get audit log

Get an audit log entry by auditLogKey.

Parameter	Type	Description
auditLogKey	AuditLogKey
consistency	ConsistencyOptions<AuditLogResult>
ct	CancellationToken

Returns: Task<AuditLogResult>

Example

public static async Task GetAuditLogExample(AuditLogKey auditLogKey)
{
    using var client = CamundaClient.Create();

    var result = await client.GetAuditLogAsync(auditLogKey);
    Console.WriteLine($"Audit log: {result.AuditLogKey}");
}

SearchAuditLogsAsync(AuditLogSearchQueryRequest, ConsistencyOptions<AuditLogSearchQueryResult>?, CancellationToken)

public Task<AuditLogSearchQueryResult> SearchAuditLogsAsync(AuditLogSearchQueryRequest body, ConsistencyOptions<AuditLogSearchQueryResult>? consistency = null, CancellationToken ct = default)

Search audit logs

Search for audit logs based on given criteria.

Parameter	Type	Description
body	AuditLogSearchQueryRequest
consistency	ConsistencyOptions<AuditLogSearchQueryResult>
ct	CancellationToken

Returns: Task<AuditLogSearchQueryResult>

Example

public static async Task SearchAuditLogsExample()
{
    using var client = CamundaClient.Create();

    var result = await client.SearchAuditLogsAsync(
        new AuditLogSearchQueryRequest());

    foreach (var log in result.Items)
    {
        Console.WriteLine($"Audit log: {log.AuditLogKey}");
    }
}

Decision Definitions

GetDecisionDefinitionAsync(DecisionDefinitionKey, ConsistencyOptions<DecisionDefinitionResult>?, CancellationToken)

public Task<DecisionDefinitionResult> GetDecisionDefinitionAsync(DecisionDefinitionKey decisionDefinitionKey, ConsistencyOptions<DecisionDefinitionResult>? consistency = null, CancellationToken ct = default)

Get decision definition

Returns a decision definition by key.

Parameter	Type	Description
decisionDefinitionKey	DecisionDefinitionKey
consistency	ConsistencyOptions<DecisionDefinitionResult>
ct	CancellationToken

Returns: Task<DecisionDefinitionResult>

Example

public static async Task GetDecisionDefinitionExample(DecisionDefinitionKey decisionDefinitionKey)
{
    using var client = CamundaClient.Create();

    var result = await client.GetDecisionDefinitionAsync(
        decisionDefinitionKey);

    Console.WriteLine($"Decision definition: {result.Name}");
}

GetDecisionDefinitionXmlAsync(DecisionDefinitionKey, ConsistencyOptions<object>?, CancellationToken)

public Task<object> GetDecisionDefinitionXmlAsync(DecisionDefinitionKey decisionDefinitionKey, ConsistencyOptions<object>? consistency = null, CancellationToken ct = default)

Get decision definition XML

Returns decision definition as XML.

Parameter	Type	Description
decisionDefinitionKey	DecisionDefinitionKey
consistency	ConsistencyOptions<Object>
ct	CancellationToken

Returns: Task<Object>

Example

public static async Task GetDecisionDefinitionXmlExample(DecisionDefinitionKey decisionDefinitionKey)
{
    using var client = CamundaClient.Create();

    var result = await client.GetDecisionDefinitionXmlAsync(
        decisionDefinitionKey);

    Console.WriteLine($"XML: {result}");
}

SearchDecisionDefinitionsAsync(DecisionDefinitionSearchQuery, ConsistencyOptions<DecisionDefinitionSearchQueryResult>?, CancellationToken)

public Task<DecisionDefinitionSearchQueryResult> SearchDecisionDefinitionsAsync(DecisionDefinitionSearchQuery body, ConsistencyOptions<DecisionDefinitionSearchQueryResult>? consistency = null, CancellationToken ct = default)

Search decision definitions

Search for decision definitions based on given criteria.

Parameter	Type	Description
body	DecisionDefinitionSearchQuery
consistency	ConsistencyOptions<DecisionDefinitionSearchQueryResult>
ct	CancellationToken

Returns: Task<DecisionDefinitionSearchQueryResult>

Example

public static async Task SearchDecisionDefinitionsExample()
{
    using var client = CamundaClient.Create();

    var result = await client.SearchDecisionDefinitionsAsync(
        new DecisionDefinitionSearchQuery());

    foreach (var dd in result.Items)
    {
        Console.WriteLine($"Decision definition: {dd.Name}");
    }
}

Decision Requirements

GetDecisionRequirementsAsync(DecisionRequirementsKey, ConsistencyOptions<DecisionRequirementsResult>?, CancellationToken)

public Task<DecisionRequirementsResult> GetDecisionRequirementsAsync(DecisionRequirementsKey decisionRequirementsKey, ConsistencyOptions<DecisionRequirementsResult>? consistency = null, CancellationToken ct = default)

Get decision requirements

Returns Decision Requirements as JSON.

Parameter	Type	Description
decisionRequirementsKey	DecisionRequirementsKey
consistency	ConsistencyOptions<DecisionRequirementsResult>
ct	CancellationToken

Returns: Task<DecisionRequirementsResult>

Example

public static async Task GetDecisionRequirementsExample(DecisionRequirementsKey decisionRequirementsKey)
{
    using var client = CamundaClient.Create();

    var result = await client.GetDecisionRequirementsAsync(
        decisionRequirementsKey);

    Console.WriteLine($"DRD: {result.DecisionRequirementsName}");
}

GetDecisionRequirementsXmlAsync(DecisionRequirementsKey, ConsistencyOptions<object>?, CancellationToken)

public Task<object> GetDecisionRequirementsXmlAsync(DecisionRequirementsKey decisionRequirementsKey, ConsistencyOptions<object>? consistency = null, CancellationToken ct = default)

Get decision requirements XML

Returns decision requirements as XML.

Parameter	Type	Description
decisionRequirementsKey	DecisionRequirementsKey
consistency	ConsistencyOptions<Object>
ct	CancellationToken

Returns: Task<Object>

Example

public static async Task GetDecisionRequirementsXmlExample(DecisionRequirementsKey decisionRequirementsKey)
{
    using var client = CamundaClient.Create();

    var result = await client.GetDecisionRequirementsXmlAsync(
        decisionRequirementsKey);

    Console.WriteLine($"XML: {result}");
}

SearchDecisionRequirementsAsync(DecisionRequirementsSearchQuery, ConsistencyOptions<DecisionRequirementsSearchQueryResult>?, CancellationToken)

public Task<DecisionRequirementsSearchQueryResult> SearchDecisionRequirementsAsync(DecisionRequirementsSearchQuery body, ConsistencyOptions<DecisionRequirementsSearchQueryResult>? consistency = null, CancellationToken ct = default)

Search decision requirements

Search for decision requirements based on given criteria.

Parameter	Type	Description
body	DecisionRequirementsSearchQuery
consistency	ConsistencyOptions<DecisionRequirementsSearchQueryResult>
ct	CancellationToken

Returns: Task<DecisionRequirementsSearchQueryResult>

Example

public static async Task SearchDecisionRequirementsExample()
{
    using var client = CamundaClient.Create();

    var result = await client.SearchDecisionRequirementsAsync(
        new DecisionRequirementsSearchQuery());

    foreach (var drd in result.Items)
    {
        Console.WriteLine($"DRD: {drd.DecisionRequirementsName}");
    }
}

Incidents

GetIncidentAsync(IncidentKey, ConsistencyOptions<IncidentResult>?, CancellationToken)

public Task<IncidentResult> GetIncidentAsync(IncidentKey incidentKey, ConsistencyOptions<IncidentResult>? consistency = null, CancellationToken ct = default)

Get incident

Returns incident as JSON.

Parameter	Type	Description
incidentKey	IncidentKey
consistency	ConsistencyOptions<IncidentResult>
ct	CancellationToken

Returns: Task<IncidentResult>

Example

public static async Task GetIncidentExample(IncidentKey incidentKey)
{
    using var client = CamundaClient.Create();

    var result = await client.GetIncidentAsync(incidentKey);
    Console.WriteLine($"Incident: {result.IncidentKey}");
}

ResolveIncidentAsync(IncidentKey, IncidentResolutionRequest, CancellationToken)

public Task ResolveIncidentAsync(IncidentKey incidentKey, IncidentResolutionRequest body, CancellationToken ct = default)

Resolve incident

Marks the incident as resolved; most likely a call to Update job will be necessary to reset the job's retries, followed by this call.

Parameter	Type	Description
incidentKey	IncidentKey
body	IncidentResolutionRequest
ct	CancellationToken

Returns: Task

Example

public static async Task ResolveIncidentExample(IncidentKey incidentKey)
{
    using var client = CamundaClient.Create();

    await client.ResolveIncidentAsync(
        incidentKey,
        new IncidentResolutionRequest());
}

SearchElementInstanceIncidentsAsync(ElementInstanceKey, IncidentSearchQuery, ConsistencyOptions<IncidentSearchQueryResult>?, CancellationToken)

public Task<IncidentSearchQueryResult> SearchElementInstanceIncidentsAsync(ElementInstanceKey elementInstanceKey, IncidentSearchQuery body, ConsistencyOptions<IncidentSearchQueryResult>? consistency = null, CancellationToken ct = default)

Search for incidents of a specific element instance

Search for incidents caused by the specified element instance, including incidents of any child instances created from this element instance.

Although the elementInstanceKey is provided as a path parameter to indicate the root element instance, you may also include an elementInstanceKey within the filter object to narrow results to specific child element instances. This is useful, for example, if you want to isolate incidents associated with nested or subordinate elements within the given element instance while excluding incidents directly tied to the root element itself.

Parameter	Type	Description
elementInstanceKey	ElementInstanceKey
body	IncidentSearchQuery
consistency	ConsistencyOptions<IncidentSearchQueryResult>
ct	CancellationToken

Returns: Task<IncidentSearchQueryResult>

Example

public static async Task SearchElementInstanceIncidentsExample(ElementInstanceKey elementInstanceKey)
{
    using var client = CamundaClient.Create();

    var result = await client.SearchElementInstanceIncidentsAsync(
        elementInstanceKey,
        new IncidentSearchQuery());

    foreach (var incident in result.Items)
    {
        Console.WriteLine($"Incident: {incident.IncidentKey}");
    }
}

SearchIncidentsAsync(IncidentSearchQuery, ConsistencyOptions<IncidentSearchQueryResult>?, CancellationToken)

public Task<IncidentSearchQueryResult> SearchIncidentsAsync(IncidentSearchQuery body, ConsistencyOptions<IncidentSearchQueryResult>? consistency = null, CancellationToken ct = default)

Search incidents

Search for incidents based on given criteria.

Parameter	Type	Description
body	IncidentSearchQuery
consistency	ConsistencyOptions<IncidentSearchQueryResult>
ct	CancellationToken

Returns: Task<IncidentSearchQueryResult>

Example

public static async Task SearchIncidentsExample()
{
    using var client = CamundaClient.Create();

    var result = await client.SearchIncidentsAsync(new IncidentSearchQuery());

    foreach (var incident in result.Items)
    {
        Console.WriteLine($"Incident: {incident.IncidentKey}");
    }
}

Process Definitions

GetProcessDefinitionAsync(ProcessDefinitionKey, ConsistencyOptions<ProcessDefinitionResult>?, CancellationToken)

public Task<ProcessDefinitionResult> GetProcessDefinitionAsync(ProcessDefinitionKey processDefinitionKey, ConsistencyOptions<ProcessDefinitionResult>? consistency = null, CancellationToken ct = default)

Get process definition

Returns process definition as JSON.

Parameter	Type	Description
processDefinitionKey	ProcessDefinitionKey
consistency	ConsistencyOptions<ProcessDefinitionResult>
ct	CancellationToken

Returns: Task<ProcessDefinitionResult>

Example

public static async Task GetProcessDefinitionExample(ProcessDefinitionKey processDefinitionKey)
{
    using var client = CamundaClient.Create();

    var result = await client.GetProcessDefinitionAsync(
        processDefinitionKey);

    Console.WriteLine($"Process definition: {result.Name}");
}

GetProcessDefinitionInstanceStatisticsAsync(ProcessDefinitionInstanceStatisticsQuery, ConsistencyOptions<ProcessDefinitionInstanceStatisticsQueryResult>?, CancellationToken)

public Task<ProcessDefinitionInstanceStatisticsQueryResult> GetProcessDefinitionInstanceStatisticsAsync(ProcessDefinitionInstanceStatisticsQuery body, ConsistencyOptions<ProcessDefinitionInstanceStatisticsQueryResult>? consistency = null, CancellationToken ct = default)

Get process instance statistics

Get statistics about process instances, grouped by process definition and tenant.

Parameter	Type	Description
body	ProcessDefinitionInstanceStatisticsQuery
consistency	ConsistencyOptions<ProcessDefinitionInstanceStatisticsQueryResult>
ct	CancellationToken

Returns: Task<ProcessDefinitionInstanceStatisticsQueryResult>

Example

public static async Task GetProcessDefinitionInstanceStatisticsExample()
{
    using var client = CamundaClient.Create();

    var result = await client.GetProcessDefinitionInstanceStatisticsAsync(
        new ProcessDefinitionInstanceStatisticsQuery());

    foreach (var stat in result.Items)
    {
        Console.WriteLine($"Definition: {stat.ProcessDefinitionId}");
    }
}

GetProcessDefinitionInstanceVersionStatisticsAsync(ProcessDefinitionInstanceVersionStatisticsQuery, ConsistencyOptions<ProcessDefinitionInstanceVersionStatisticsQueryResult>?, CancellationToken)

public Task<ProcessDefinitionInstanceVersionStatisticsQueryResult> GetProcessDefinitionInstanceVersionStatisticsAsync(ProcessDefinitionInstanceVersionStatisticsQuery body, ConsistencyOptions<ProcessDefinitionInstanceVersionStatisticsQueryResult>? consistency = null, CancellationToken ct = default)

Get process instance statistics by version

Get statistics about process instances, grouped by version for a given process definition. The process definition ID must be provided as a required field in the request body filter.

Parameter	Type	Description
body	ProcessDefinitionInstanceVersionStatisticsQuery
consistency	ConsistencyOptions<ProcessDefinitionInstanceVersionStatisticsQueryResult>
ct	CancellationToken

Returns: Task<ProcessDefinitionInstanceVersionStatisticsQueryResult>

Example

public static async Task GetProcessDefinitionInstanceVersionStatisticsExample(ProcessDefinitionId processDefinitionId)
{
    using var client = CamundaClient.Create();

    var result = await client.GetProcessDefinitionInstanceVersionStatisticsAsync(
        new ProcessDefinitionInstanceVersionStatisticsQuery
        {
            Filter = new ProcessDefinitionInstanceVersionStatisticsFilter
            {
                ProcessDefinitionId = processDefinitionId,
            },
        });

    foreach (var stat in result.Items)
    {
        Console.WriteLine($"Version: {stat.ProcessDefinitionVersion}");
    }
}

GetProcessDefinitionMessageSubscriptionStatisticsAsync(ProcessDefinitionMessageSubscriptionStatisticsQuery, ConsistencyOptions<ProcessDefinitionMessageSubscriptionStatisticsQueryResult>?, CancellationToken)

public Task<ProcessDefinitionMessageSubscriptionStatisticsQueryResult> GetProcessDefinitionMessageSubscriptionStatisticsAsync(ProcessDefinitionMessageSubscriptionStatisticsQuery body, ConsistencyOptions<ProcessDefinitionMessageSubscriptionStatisticsQueryResult>? consistency = null, CancellationToken ct = default)

Get message subscription statistics

Get message subscription statistics, grouped by process definition.

Parameter	Type	Description
body	ProcessDefinitionMessageSubscriptionStatisticsQuery
consistency	ConsistencyOptions<ProcessDefinitionMessageSubscriptionStatisticsQueryResult>
ct	CancellationToken

Returns: Task<ProcessDefinitionMessageSubscriptionStatisticsQueryResult>

Example

public static async Task GetProcessDefinitionMessageSubscriptionStatisticsExample()
{
    using var client = CamundaClient.Create();

    var result = await client.GetProcessDefinitionMessageSubscriptionStatisticsAsync(
        new ProcessDefinitionMessageSubscriptionStatisticsQuery());

    foreach (var stat in result.Items)
    {
        Console.WriteLine($"Message subscriptions: {stat.ActiveSubscriptions}");
    }
}

GetProcessDefinitionStatisticsAsync(ProcessDefinitionKey, ProcessDefinitionElementStatisticsQuery, ConsistencyOptions<ProcessDefinitionElementStatisticsQueryResult>?, CancellationToken)

public Task<ProcessDefinitionElementStatisticsQueryResult> GetProcessDefinitionStatisticsAsync(ProcessDefinitionKey processDefinitionKey, ProcessDefinitionElementStatisticsQuery body, ConsistencyOptions<ProcessDefinitionElementStatisticsQueryResult>? consistency = null, CancellationToken ct = default)

Get process definition statistics

Get statistics about elements in currently running process instances by process definition key and search filter.

Parameter	Type	Description
processDefinitionKey	ProcessDefinitionKey
body	ProcessDefinitionElementStatisticsQuery
consistency	ConsistencyOptions<ProcessDefinitionElementStatisticsQueryResult>
ct	CancellationToken

Returns: Task<ProcessDefinitionElementStatisticsQueryResult>

Example

public static async Task GetProcessDefinitionStatisticsExample(ProcessDefinitionKey processDefinitionKey)
{
    using var client = CamundaClient.Create();

    var result = await client.GetProcessDefinitionStatisticsAsync(
        processDefinitionKey,
        new ProcessDefinitionElementStatisticsQuery());

    foreach (var stat in result.Items)
    {
        Console.WriteLine($"Element: {stat.ElementId}");
    }
}

GetProcessDefinitionXmlAsync(ProcessDefinitionKey, ConsistencyOptions<object>?, CancellationToken)

public Task<object> GetProcessDefinitionXmlAsync(ProcessDefinitionKey processDefinitionKey, ConsistencyOptions<object>? consistency = null, CancellationToken ct = default)

Get process definition XML

Returns process definition as XML.

Parameter	Type	Description
processDefinitionKey	ProcessDefinitionKey
consistency	ConsistencyOptions<Object>
ct	CancellationToken

Returns: Task<Object>

Example

public static async Task GetProcessDefinitionXmlExample(ProcessDefinitionKey processDefinitionKey)
{
    using var client = CamundaClient.Create();

    var result = await client.GetProcessDefinitionXmlAsync(
        processDefinitionKey);

    Console.WriteLine($"XML: {result}");
}

GetStartProcessFormAsync(ProcessDefinitionKey, ConsistencyOptions<FormResult>?, CancellationToken)

public Task<FormResult> GetStartProcessFormAsync(ProcessDefinitionKey processDefinitionKey, ConsistencyOptions<FormResult>? consistency = null, CancellationToken ct = default)

Get process start form

Get the start form of a process. Note that this endpoint will only return linked forms. This endpoint does not support embedded forms.

Parameter	Type	Description
processDefinitionKey	ProcessDefinitionKey
consistency	ConsistencyOptions<FormResult>
ct	CancellationToken

Returns: Task<FormResult>

Example

public static async Task GetStartProcessFormExample(ProcessDefinitionKey processDefinitionKey)
{
    using var client = CamundaClient.Create();

    var result = await client.GetStartProcessFormAsync(
        processDefinitionKey);

    Console.WriteLine($"Form: {result.FormKey}");
}

SearchProcessDefinitionVariableNamesAsync(ProcessDefinitionKey, ProcessDefinitionVariableNameSearchQuery, ConsistencyOptions<ProcessDefinitionVariableNameSearchQueryResult>?, CancellationToken)

public Task<ProcessDefinitionVariableNameSearchQueryResult> SearchProcessDefinitionVariableNamesAsync(ProcessDefinitionKey processDefinitionKey, ProcessDefinitionVariableNameSearchQuery body, ConsistencyOptions<ProcessDefinitionVariableNameSearchQueryResult>? consistency = null, CancellationToken ct = default)

Search process definition variable names

Search for distinct variable names defined on a process definition, optionally narrowed by the name filter.

Parameter	Type	Description
processDefinitionKey	ProcessDefinitionKey
body	ProcessDefinitionVariableNameSearchQuery
consistency	ConsistencyOptions<ProcessDefinitionVariableNameSearchQueryResult>
ct	CancellationToken

Returns: Task<ProcessDefinitionVariableNameSearchQueryResult>

Example

public static async Task SearchProcessDefinitionVariableNamesExample(ProcessDefinitionKey processDefinitionKey)
{
    using var client = CamundaClient.Create();

    var result = await client.SearchProcessDefinitionVariableNamesAsync(
        processDefinitionKey,
        new ProcessDefinitionVariableNameSearchQuery());

    foreach (var variable in result.Items)
    {
        Console.WriteLine($"Variable name: {variable.Name}");
    }
}

SearchProcessDefinitionsAsync(ProcessDefinitionSearchQuery, ConsistencyOptions<ProcessDefinitionSearchQueryResult>?, CancellationToken)

public Task<ProcessDefinitionSearchQueryResult> SearchProcessDefinitionsAsync(ProcessDefinitionSearchQuery body, ConsistencyOptions<ProcessDefinitionSearchQueryResult>? consistency = null, CancellationToken ct = default)

Search process definitions

Search for process definitions based on given criteria.

Parameter	Type	Description
body	ProcessDefinitionSearchQuery
consistency	ConsistencyOptions<ProcessDefinitionSearchQueryResult>
ct	CancellationToken

Returns: Task<ProcessDefinitionSearchQueryResult>

Example

public static async Task SearchProcessDefinitionsExample()
{
    using var client = CamundaClient.Create();

    var result = await client.SearchProcessDefinitionsAsync(
        new ProcessDefinitionSearchQuery());

    foreach (var pd in result.Items)
    {
        Console.WriteLine($"Process definition: {pd.Name}");
    }
}