BPMN 2.0 · 5-Minute Setup · No Infrastructure

From zero to running BPMN
in under 5 minutes.

Sign up, upload your BPMN file with one REST call, start your first process. No Kubernetes cluster, no Zeebe to configure, no Operate to install. Just a REST API and your existing BPMN file.

Get your free API key →

Quickstart guide

Four steps. No infrastructure.

Sign up and get your API key

Enter your email below. You'll receive a verification link instantly. Click it - your API key is in the confirmation email. Takes 60 seconds.

Save your process as a .bpmn file

Model in Camunda Modeler, bpmn.io or Signavio as you do today, then save or export the process as a .bpmn file. A modeler's own Deploy button cannot reach Priostack: no route serves a modeler's deploy, so the file goes up with the REST call in step 3.

Your BPMN models, including zeebe:taskDefinition, deploy as they are. Existing Zeebe or Camunda workers keep their job logic, but their transport must be rewritten to call the REST endpoints in step 5 with your API key: there is no gRPC endpoint.

Deploy your BPMN file

Upload the file to the deploy route. It answers 200 with the deployed bpmnProcessId and version, and costs no credit. Redeploying the same XML returns the existing version; changed XML under the same process id becomes version n+1.

curl -X POST https://priostack.com/api/v1/process-definitions \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -F "file=@my-process.bpmn"

Raw XML works too: send the file as the body with -H "Content-Type: application/xml" --data-binary @my-process.bpmn. The API reference lists every field of the answer.

Start an instance and watch it run

Trigger a process instance by its bpmnProcessId (the id of the <process> element). The call answers 201 Created and costs 1 credit. Open your dashboard at priostack.com/account - every active instance, job queue and incident is visible in real time.

curl -X POST https://priostack.com/api/v1/process-instances \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"bpmnProcessId":"my-process","variables":{}}'

Step 5 - Run a worker

Workers poll for jobs and complete them. Activation answers at once (there is no long polling), so each snippet pauses 2 seconds after an empty poll and checks the status of every call. Job keys are strings. Copy the snippet in your language, swap in your API key, run it. The worker guides add failure reporting and graceful shutdown.

package main

import (
  "bytes"
  "encoding/json"
  "fmt"
  "io"
  "log"
  "net/http"
  "time"
)

const (
  baseURL = "https://priostack.com/api/v1"
  apiKey  = "YOUR_API_KEY"
)

// Job keys are opaque strings, never numbers.
type Job struct {
  Key       string                 `json:"key"`
  Variables map[string]interface{} `json:"variables"`
  Retries   int                    `json:"retries"`
}

func main() {
  for {
    jobs, err := activateJobs("credit-check", 5)
    if err != nil {
      log.Println(err)
    }
    for _, job := range jobs {
      result := map[string]interface{}{"creditScore": 720}
      if err := completeJob(job.Key, result); err != nil {
        log.Println(err)
        continue
      }
      fmt.Printf("completed job %s\n", job.Key)
    }
    if len(jobs) == 0 {
      time.Sleep(2 * time.Second) // activation answers at once: pause between empty polls
    }
  }
}

func post(path string, body interface{}) ([]byte, error) {
  b, err := json.Marshal(body)
  if err != nil {
    return nil, err
  }
  req, err := http.NewRequest("POST", baseURL+path, bytes.NewReader(b))
  if err != nil {
    return nil, err
  }
  req.Header.Set("Authorization", "Bearer "+apiKey)
  req.Header.Set("Content-Type", "application/json")
  resp, err := http.DefaultClient.Do(req)
  if err != nil {
    return nil, err
  }
  defer resp.Body.Close()
  data, err := io.ReadAll(resp.Body)
  if err != nil {
    return nil, err
  }
  // activate answers 200 and complete answers 204: accept any 2xx
  if resp.StatusCode/100 != 2 {
    return nil, fmt.Errorf("%s: status %d: %s", path, resp.StatusCode, data)
  }
  return data, nil
}

func activateJobs(jobType string, max int) ([]Job, error) {
  data, err := post("/jobs/activate", map[string]interface{}{"type": jobType, "maxJobsToActivate": max})
  if err != nil {
    return nil, err
  }
  var result struct {
    Jobs []Job `json:"jobs"`
  }
  err = json.Unmarshal(data, &result)
  return result.Jobs, err
}

func completeJob(key string, vars map[string]interface{}) error {
  _, err := post("/jobs/"+key+"/complete", map[string]interface{}{"variables": vars})
  return err
}
    

import requests, time

BASE_URL = "https://priostack.com/api/v1"
API_KEY  = "YOUR_API_KEY"
HEADERS  = {"Authorization": f"Bearer {API_KEY}"}

def activate_jobs(job_type, max_to_activate=5):
    r = requests.post(f"{BASE_URL}/jobs/activate", headers=HEADERS, json={
        "type": job_type, "maxJobsToActivate": max_to_activate
    }, timeout=15)
    r.raise_for_status()  # anything outside 2xx is an error
    return r.json().get("jobs", [])

def complete_job(key, variables):
    r = requests.post(f"{BASE_URL}/jobs/{key}/complete", headers=HEADERS,
                      json={"variables": variables}, timeout=15)
    r.raise_for_status()  # success is 204 No Content

if __name__ == "__main__":
    while True:
        try:
            jobs = activate_jobs("credit-check")
        except requests.RequestException as exc:
            print(f"activate failed: {exc}")
            jobs = []
        for job in jobs:
            try:
                complete_job(job["key"], {"creditScore": 720})
                print(f"completed job {job['key']}")
            except requests.RequestException as exc:
                print(f"complete failed: {exc}")
        if not jobs:
            time.sleep(2)  # activation answers at once: pause between empty polls
    

const BASE_URL = "https://priostack.com/api/v1";
const API_KEY  = "YOUR_API_KEY";
const headers  = { Authorization: `Bearer ${API_KEY}`, "Content-Type": "application/json" };

// fetch does not reject on 4xx/5xx, so check resp.ok on every call
async function post(path, body) {
  const r = await fetch(`${BASE_URL}${path}`, { method: "POST", headers, body: JSON.stringify(body) });
  const text = await r.text();
  if (!r.ok) throw new Error(`${path} failed ${r.status}: ${text}`);
  return text ? JSON.parse(text) : null; // complete answers 204 with no body
}

async function activateJobs(type, maxJobsToActivate = 5) {
  const data = await post("/jobs/activate", { type, maxJobsToActivate });
  return data?.jobs ?? [];
}

async function completeJob(key, variables) {
  await post(`/jobs/${key}/complete`, { variables });
}

(async () => {
  while (true) {
    let jobs = [];
    try {
      jobs = await activateJobs("credit-check");
    } catch (err) {
      console.error(err.message);
    }
    for (const job of jobs) {
      try {
        await completeJob(job.key, { creditScore: 720 });
        console.log(`completed job ${job.key}`);
      } catch (err) {
        console.error(err.message);
      }
    }
    // activation answers at once: pause between empty polls
    if (jobs.length === 0) await new Promise(r => setTimeout(r, 2000));
  }
})();
    

From zero to running BPMNin under 5 minutes.