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.
Activate jobs
Iterate through all known partitions and activate jobs up to the requested maximum.
async function activateJobsExample() {
const camunda = createCamundaClient();
const result = await camunda.activateJobs({
type: 'payment-processing',
timeout: 30000,
maxJobsToActivate: 5,
});
for (const job of result.jobs) {
console.log(`Job ${job.jobKey}: ${job.type}`);
// Each enriched job has helper methods
await job.complete({ paymentId: 'PAY-123' });
}
}
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.
Assign a client to a tenant
Assign the client to the specified tenant. The client can then access tenant data and perform authorized actions.
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.
Assign a mapping rule to a group
Assigns a mapping rule to a group. *
Assign a mapping rule to a tenant
Assign a single mapping rule to a specified tenant. *
Assign a role to a client
Assigns the specified role to the client. The client will inherit the authorizations associated with this role. *
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. *
Assign a role to a mapping rule
Assigns a role to a mapping rule. *
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.
Assign a role to a user
Assigns the specified role to the user. The user will inherit the authorizations associated with this role. *
Assign user task
Assigns a user task with the given key to the given assignee. *
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.
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. *
Broadcast signal
Broadcasts a signal. *
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}).
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. *
async function cancelProcessInstanceExample() {
const camunda = createCamundaClient();
// Create a process instance and get its key from the response
const created = await camunda.createProcessInstance({
processDefinitionId: ProcessDefinitionId.assumeExists('order-process'),
});
// Cancel the process instance using the key from the creation response
await camunda.cancelProcessInstance({
processInstanceKey: created.processInstanceKey,
});
}
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}).
Optionalopts: { disk?: boolean; memory?: boolean }Complete job
Complete a job with the given payload, which allows completing the associated service task.
Complete user task
Completes a user task with the given key. *
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.
async function correlateMessageExample() {
const camunda = createCamundaClient();
const result = await camunda.correlateMessage({
name: 'order-payment-received',
correlationKey: 'ORD-12345',
variables: {
paymentId: 'PAY-123',
amount: 99.95,
},
});
console.log(`Message correlated to: ${result.processInstanceKey}`);
}
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. *
Create authorization
Create the authorization. *
Deploy resources
Deploys one or more resources (e.g. processes, decision models, or forms). This is an atomic call, i.e. either all resources are deployed or none of them are.
Enriched deployment result with typed arrays (processes, decisions, decisionRequirements, forms, resources).
async function createDeploymentExample() {
const camunda = createCamundaClient();
const file = new File(['<xml/>'], 'order-process.bpmn', { type: 'application/xml' });
const result = await camunda.createDeployment({
resources: [file],
});
console.log(`Deployment key: ${result.deploymentKey}`);
for (const process of result.processes ?? []) {
console.log(` Process: ${process.processDefinitionId} v${process.processDefinitionVersion}`);
}
}
Upload document
Upload a document to the Camunda 8 cluster.
Note that this is currently supported for document stores of type: AWS, GCP, in-memory (non-production), local (non-production)
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, GCP
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, GCP, in-memory (non-production), local (non-production)
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.
Create a global-scoped cluster variable
Create a global-scoped cluster variable. *
Create global user task listener
Create a new global user task listener. *
Create group
Create a new group. *
Create a job worker that activates and processes jobs of the given type.
Worker configuration
async function createJobWorkerExample() {
const camunda = createCamundaClient();
const worker = camunda.createJobWorker({
jobType: 'payment-processing',
jobTimeoutMs: 30000,
maxParallelJobs: 5,
jobHandler: async (job): Promise<JobActionReceipt> => {
console.log(`Processing job ${job.jobKey}`);
return job.complete({ processed: true });
},
});
// Workers run continuously until closed
// worker.close();
}
async function jobWorkerWithErrorHandlingExample() {
const camunda = createCamundaClient();
const worker = camunda.createJobWorker({
jobType: 'email-sending',
jobTimeoutMs: 60000,
maxParallelJobs: 10,
pollIntervalMs: 300,
jobHandler: async (job): Promise<JobActionReceipt> => {
try {
console.log(`Sending email for job ${job.jobKey}`);
return job.complete({ sent: true });
} catch (err) {
return job.fail({
errorMessage: String(err),
retries: (job.retries ?? 1) - 1,
});
}
},
});
void worker;
}
Create mapping rule
Create a new mapping rule
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.
async function createProcessInstanceByIdExample() {
const camunda = createCamundaClient();
const result = await camunda.createProcessInstance({
processDefinitionId: ProcessDefinitionId.assumeExists('order-process'),
variables: {
orderId: 'ORD-12345',
amount: 99.95,
},
});
console.log(`Started process instance: ${result.processInstanceKey}`);
}
async function createProcessInstanceByKeyExample() {
const camunda = createCamundaClient();
// Key from a previous API response (e.g. deployment)
const processDefinitionKey = ProcessDefinitionKey.assumeExists('2251799813685249');
const result = await camunda.createProcessInstance({
processDefinitionKey,
variables: {
orderId: 'ORD-12345',
amount: 99.95,
},
});
console.log(`Started process instance: ${result.processInstanceKey}`);
}
Create role
Create a new role. *
Create tenant
Creates a new tenant. *
Create a tenant-scoped cluster variable
Create a new cluster variable for the given tenant. *
Create user
Create a new user. *
Delete authorization
Deletes the authorization with the given key. *
Delete decision instance
Delete all associated decision evaluations based on provided key. *
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}).
Delete document
Delete a document from the Camunda 8 cluster.
Note that this is currently supported for document stores of type: AWS, GCP, in-memory (non-production), local (non-production)
Delete a global-scoped cluster variable
Delete a global-scoped cluster variable. *
Delete global user task listener
Deletes a global user task listener. *
Delete group
Deletes the group with the given ID. *
Delete a mapping rule
Deletes the mapping rule with the given ID.
Delete process instance
Deletes a process instance. Only instances that are completed or terminated can be deleted. *
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}).
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.
*
OptionaldeleteHistory?: booleanIndicates if the historic data of a process resource should be deleted via a batch operation asynchronously.
This flag is only effective for process resources. For other resource types
(decisions, forms, generic resources), this flag is ignored and no history
will be deleted. In those cases, the batchOperation field in the response
will not be populated.
OptionaloperationReference?: numberDelete role
Deletes the role with the given ID. *
Delete tenant
Deletes an existing tenant. *
Delete a tenant-scoped cluster variable
Delete a tenant-scoped cluster variable. *
Delete user
Deletes a user. *
Node-only convenience: deploy resources from local filesystem paths.
Absolute or relative file paths to BPMN/DMN/form/resource files.
Optionaloptions: { tenantId?: string }Optional: tenantId.
ExtendedDeploymentResult
Emit the standard support log preamble & redacted configuration to the current support logger. Safe to call multiple times; subsequent calls are ignored (idempotent). Useful when a custom supportLogger was injected and you still want the canonical header & config dump.
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.
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.
async function evaluateDecisionByIdExample() {
const camunda = createCamundaClient();
const result = await camunda.evaluateDecision({
decisionDefinitionId: DecisionDefinitionId.assumeExists('invoice-classification'),
variables: {
amount: 1000,
invoiceCategory: 'Misc',
},
});
console.log(`Decision: ${result.decisionDefinitionId}`);
console.log(`Output: ${result.output}`);
}
async function evaluateDecisionByKeyExample() {
const camunda = createCamundaClient();
const decisionDefinitionKey = DecisionDefinitionKey.assumeExists('2251799813685249');
const result = await camunda.evaluateDecision({
decisionDefinitionKey,
variables: {
amount: 1000,
invoiceCategory: 'Misc',
},
});
console.log(`Decision output: ${result.output}`);
}
Evaluate an expression
Evaluates a FEEL expression and returns the result. Supports references to tenant scoped cluster variables when a tenant ID is provided. *
Get audit log
Get an audit log entry by auditLogKey. *
Get current user
Retrieves the current authenticated user. *
Get authorization
Get authorization by the given key. *
Public accessor for current backpressure adaptive limiter state (stable)
Get batch operation
Get batch operation by key. *
Read-only snapshot of current hydrated configuration (do not mutate directly). Use configure(...) to apply changes.
Get decision definition
Returns a decision definition by key. *
async function getDecisionDefinitionExample() {
const camunda = createCamundaClient();
const decisionDefinitionKey = DecisionDefinitionKey.assumeExists('2251799813685249');
const definition = await camunda.getDecisionDefinition(
{ decisionDefinitionKey },
{ consistency: { waitUpToMs: 5000 } }
);
console.log(`Decision: ${definition.decisionDefinitionId}`);
console.log(`Version: ${definition.version}`);
}
Get decision definition XML
Returns decision definition as XML. *
Get decision instance
Returns a decision instance. *
Get decision requirements
Returns Decision Requirements as JSON. *
Get decision requirements XML
Returns decision requirements as XML. *
Download document
Download a document from the Camunda 8 cluster.
Note that this is currently supported for document stores of type: AWS, GCP, in-memory (non-production), local (non-production)
Get element instance
Returns element instance as JSON. *
Internal accessor (read-only) for eventual consistency error mode.
Get a global-scoped cluster variable
Get a global-scoped cluster variable. *
Global job statistics
Returns global aggregated counts for jobs. Optionally filter by the creation time window and/or jobType.
Get group
Get a group by its ID. *
Get incident
Returns incident as JSON.
async function getIncidentExample() {
const camunda = createCamundaClient();
const incidentKey = IncidentKey.assumeExists('2251799813685249');
const incident = await camunda.getIncident(
{ incidentKey },
{ consistency: { waitUpToMs: 5000 } }
);
console.log(`Type: ${incident.errorType}`);
console.log(`State: ${incident.state}`);
console.log(`Message: ${incident.errorMessage}`);
}
Get license status
Obtains the status of the current Camunda license. *
Get a mapping rule
Gets the mapping rule with the given ID.
Get process definition
Returns process definition as JSON. *
Get process instance statistics
Get statistics about process instances, grouped by process definition and tenant.
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.
Get message subscription statistics
Get message subscription statistics, grouped by process definition.
Get process definition statistics
Get statistics about elements in currently running process instances by process definition key and search filter. *
Get process definition XML
Returns process definition as XML. *
Get process instance
Get the process instance by the process instance key. *
async function getProcessInstanceExample() {
const camunda = createCamundaClient();
const processInstanceKey = ProcessInstanceKey.assumeExists('2251799813685249');
const instance = await camunda.getProcessInstance(
{ processInstanceKey },
{ consistency: { waitUpToMs: 5000 } }
);
console.log(`State: ${instance.state}`);
console.log(`Process: ${instance.processDefinitionId}`);
}
Get call hierarchy
Returns the call hierarchy for a given process instance, showing its ancestry up to the root instance. *
Get sequence flows
Get sequence flows taken by the process instance. *
Get element instance statistics
Get statistics about elements by the process instance key. *
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.
Get process instance statistics by error
Returns statistics for active process instances that currently have active incidents, grouped by incident error hash code.
Get resource
Returns a deployed resource. :::info Currently, this endpoint only supports RPA resources. :::
Get resource content
Returns the content of a deployed resource. :::info Currently, this endpoint only supports RPA resources. :::
Get role
Get a role by its ID. *
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.
Get cluster status
Checks the health status of the cluster by verifying if there's at least one partition with a healthy leader. *
Get tenant
Retrieves a single tenant by tenant ID. *
Get a tenant-scoped cluster variable
Get a tenant-scoped cluster variable. *
Get cluster topology
Obtains the current topology of the cluster the gateway is part of. *
async function getTopologyExample() {
const camunda = createCamundaClient();
const topology = await camunda.getTopology();
console.log(`Cluster size: ${topology.clusterSize}`);
console.log(`Partitions: ${topology.partitionsCount}`);
for (const broker of topology.brokers ?? []) {
console.log(` Broker ${broker.nodeId}: ${broker.host}:${broker.port}`);
}
}
Get usage metrics
Retrieve the usage metrics based on given criteria. *
Get user
Get a user by its username. *
Get user task
Get the user task by the user task key. *
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.
Get variable
Get the variable by the variable key. *
Return a read-only snapshot of currently registered job workers.
Access a scoped logger (internal & future user emission).
Optionalscope: stringMigrate 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.
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}).
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.
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}).
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.
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.
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.
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.
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}).
Resolve related incidents
Creates a batch operation to resolve multiple incidents of a process instance. *
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}).
Search audit logs
Search for audit logs based on given criteria. *
Search authorizations
Search for authorizations based on given criteria. *
Search batch operation items
Search for batch operation items based on given criteria. *
Search batch operations
Search for batch operations based on given criteria. *
Search group clients
Search clients assigned to a group. *
Search role clients
Search clients with assigned role. *
Search clients for tenant
Retrieves a filtered and sorted list of clients for a specified tenant. *
Search for cluster variables based on given criteria. By default, long variable values in the response are truncated. *
Search correlated message subscriptions
Search correlated message subscriptions based on given criteria. *
Search decision definitions
Search for decision definitions based on given criteria. *
async function searchDecisionDefinitionsExample() {
const camunda = createCamundaClient();
const result = await camunda.searchDecisionDefinitions(
{
filter: { decisionDefinitionId: DecisionDefinitionId.assumeExists('invoice-classification') },
},
{ consistency: { waitUpToMs: 5000 } }
);
for (const definition of result.items ?? []) {
console.log(`${definition.decisionDefinitionId} v${definition.version}`);
}
}
Search decision instances
Search for decision instances based on given criteria. *
Search decision requirements
Search for decision requirements based on given criteria. *
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.
Search element instances
Search for element instances based on given criteria. *
Search groups for tenant
Retrieves a filtered and sorted list of groups for a specified tenant. *
Search groups
Search for groups based on given criteria. *
Search role groups
Search groups with assigned role. *
Search incidents
Search for incidents based on given criteria.
async function searchIncidentsExample() {
const camunda = createCamundaClient();
const result = await camunda.searchIncidents(
{
filter: { state: 'ACTIVE' },
sort: [{ field: 'creationTime', order: 'DESC' }],
page: { limit: 20 },
},
{ consistency: { waitUpToMs: 5000 } }
);
for (const incident of result.items ?? []) {
console.log(`${incident.incidentKey}: ${incident.errorType} — ${incident.errorMessage}`);
}
console.log(`Total active incidents: ${result.page.totalItems}`);
}
Search jobs
Search for jobs based on given criteria. *
Search mapping rules
Search for mapping rules based on given criteria.
Search group mapping rules
Search mapping rules assigned to a group. *
Search role mapping rules
Search mapping rules with assigned role. *
Search mapping rules for tenant
Retrieves a filtered and sorted list of MappingRules for a specified tenant. *
Search message subscriptions
Search for message subscriptions based on given criteria. *
Search process definitions
Search for process definitions based on given criteria. *
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.
Search process instances
Search for process instances based on given criteria. *
async function searchProcessInstancesExample() {
const camunda = createCamundaClient();
const result = await camunda.searchProcessInstances(
{
filter: { processDefinitionId: ProcessDefinitionId.assumeExists('order-process') },
sort: [{ field: 'startDate', order: 'DESC' }],
page: { limit: 10 },
},
{ consistency: { waitUpToMs: 5000 } }
);
for (const instance of result.items ?? []) {
console.log(`${instance.processInstanceKey}: ${instance.state}`);
}
console.log(`Total: ${result.page.totalItems}`);
}
Search roles
Search for roles based on given criteria. *
Search group roles
Search roles assigned to a group. *
Search roles for tenant
Retrieves a filtered and sorted list of roles for a specified tenant. *
Search tenants
Retrieves a filtered and sorted list of tenants. *
Search users
Search for users based on given criteria. *
Search group users
Search users assigned to a group. *
Search role users
Search users with assigned role. *
Search users for tenant
Retrieves a filtered and sorted list of users for a specified tenant. *
Search user task audit logs
Search for user task audit logs based on given criteria. *
Search user tasks
Search for user tasks based on given criteria. *
async function searchUserTasksExample() {
const camunda = createCamundaClient();
const result = await camunda.searchUserTasks(
{
filter: { assignee: 'alice', state: 'CREATED' },
sort: [{ field: 'creationDate', order: 'DESC' }],
page: { limit: 10 },
},
{ consistency: { waitUpToMs: 5000 } }
);
for (const task of result.items ?? []) {
console.log(`${task.userTaskKey}: ${task.name} (${task.state})`);
}
}
Search user task variables
Search for user task variables based on given criteria. By default, long variable values in the response are truncated. *
Search variables
Search for process and local variables based on given criteria. By default, long variable values in the response are truncated. *
Stop all registered job workers (best-effort).
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}).
Throw error for job
Reports a business error (i.e. non-technical) that occurs while processing a job.
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.
Unassign a client from a tenant
Unassigns the client from the specified tenant. The client can no longer access tenant data.
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.
Unassign a mapping rule from a group
Unassigns a mapping rule from a group. *
Unassign a mapping rule from a tenant
Unassigns a single mapping rule from a specified tenant without deleting the rule. *
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. *
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. *
Unassign a role from a mapping rule
Unassigns a role from a mapping rule. *
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.
Unassign a role from a user
Unassigns a role from a user. The user will no longer inherit the authorizations associated with this role. *
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.
Unassign a user from a tenant
Unassigns the user from the specified tenant. The user can no longer access tenant data.
Unassign user task
Removes the assignee of a task with the given key. *
Update authorization
Update the authorization with the given key. *
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.
Update global user task listener
Updates a global user task listener. *
Update group
Update a group with the given ID. *
Update job
Update a job with the given key. *
Update mapping rule
Update a mapping rule.
Update role
Update a role with the given ID. *
Update tenant
Updates an existing tenant. *
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.
Update user
Updates a user. *
Update user task
Update a user task with the given key. *
Internal accessor for support logger (no public API commitment yet).