Expand description

A rust client for defining, orchestrating, and monitoring business processes across microservices using Zeebe.

What is Zeebe?

Zeebe is a workflow engine for microservices orchestration. Zeebe ensures that, once started, flows are always carried out fully, retrying steps in case of failures. Along the way, Zeebe maintains a complete audit log so that the progress of flows can be monitored. Zeebe is fault tolerant and scales seamlessly to handle growing transaction volumes.


use serde_json::json;
use zeebe::{Client, Job};

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Create a zeebe client
    let client = Client::from_env()?;

    // Deploy a process

    // Create a new process instance
        .with_variables(json!({"orderId": 31243}))

    // Process a job type within the process


async fn handle_job(client: Client, job: Job) {
    /// your job processing logic...

    let _ = client.complete_job().with_job_key(job.key()).send().await;

Or with job success and failure reported for you automatically from your function result:

use futures::future;
use serde::{Deserialize, Serialize};
use thiserror::Error;
use zeebe::{Client, Data};

let client = Client::from_env()?;

// Given an app-specific error
#[derive(Error, Debug)]
enum MyError {
    #[error("unknown error occurred")]

// And app-specific job data
struct MyJobData {
    my_property: String,
    my_other_property: String,

// And app-specific job result
struct MyJobResult {
    result: u32,

// Async job handler function
async fn handle_job(data: Data<MyJobData>) -> Result<MyJobResult, MyError> {
   Ok(MyJobResult { result: 42 })

// You can run a worker from your function with results auto reported
let job = client

// OR you can run a closure and have the results auto reported
let job = client
    .with_auto_handler(|my_job_data: Data<MyJobData>| {
        future::ok::<_, MyError>(MyJobResult { result: 42 })


Zeebe broker info

Cancels a running process instance.

Canceled process instance data.

Client used to communicate with Zeebe.

Config for establishing zeebe client.

Configuration to complete a job

Completed job instance data.

Creates and starts an instance of the specified process.

Created process instance data.

Creates and starts an instance of the specified process with result.

Created process instance with result data.

Data that can be extracted from JSON encoded job variables in auto handlers.

Deploys one or more process to Zeebe.

Deployed process data.

Configuration to fail a job

Failed job instance data.

An activate Zeebe job that is ready to be worked on by a worker.

Configuration for an asynchronous worker process.

Zeebe partition.

Metadata information about a process.

Configuration to publish a message.

The publish message data.

Configuration to resolve an incident.

The resolve incident data.

Updates all the variables of a particular scope (e.g. process instance, flow element instance) from the given JSON document.

Set variables data.

Worker state that persists across job auto handler invocations.

Configuration to throw an error in the context of a job.

Throw error response data.

Request to obtain the current topology of the cluster the gateway is part of.

The current topology of the cluster

Updates the number of retries a job has left. This is mostly useful for jobs that have run out of retries, should the underlying problem be solved.

Update job retries data.


The error type which is returned from zeebe processing failures.

Type Definitions

The result type returned by zeebe methods.