Process models (BPMN) · Exported file link

Bizagi and TestingOps: test scenarios from your exported process model

Bizagi Modeler diagrams often describe a process across several departments, with a lane for each role. Export the diagram to BPMN, link the file, and TestingOps lists the paths through it, with who does what, as test scenario candidates.

Exported file link
Available

Request a demo

Bizagi File TestingOpsAI test agents

Connection: Exported file link
Writes back: Nothing, the file is only read
Last checked: 7 Nov 2026

In short

Bizagi and TestingOps in short

TestingOps reads Bizagi models from a BPMN 2.0 file you export from Bizagi Modeler and link, for example a file in GitHub or GitLab or at any other https address; the file is not uploaded and no Bizagi account is needed.

Each process in the file becomes a knowledge-base document with steps by lane, gateway outcomes, boundary events and numbered paths from start to end, bounded and marked as scenario candidates for review.

The file is fetched again on each sync and the document is rewritten only when the file changed, so replacing the export at the same link updates the candidates.

What it does

What it does for your testing

1
Lanes become roles in the scenario
Input
Pools and lanes of the exported diagram
TestingOps
Names the process after its pool and writes the lane next to each step
Output
Scenarios that say which role performs each step, so test accounts can be planned per role
2
Gateways become decision scenarios
Input
Gateways with named outgoing sequence flows
TestingOps
Shows the flow name in brackets on each path
Output
A scenario candidate per answer, for example Approved and Rejected
3
Embedded sub-processes stay in context
Input
Embedded sub-processes and transactions
TestingOps
Lists their inner steps on the same path, prefixed with the sub-process name
Output
Paths that read end to end without opening another diagram

Step by step

How it works

Export from Bizagi ModelerExport the diagram to BPMN (Export/Import → BPMN) and keep the .bpmn file where TestingOps can fetch it, for example in a Git repository.
Add the Bizagi connectionUnder Integrations → Platforms → Process models (BPMN 2.0) → Bizagi, save the connection. Add an access token only if the file is in a private GitHub or GitLab repository.
Link the fileIn the project's Knowledge tab, add a source under Process models (BPMN 2.0) and paste the file's link, for example https://github.com/…/blob/main/process.bpmn. GitHub and GitLab page links are turned into raw file links.
SyncSync now fetches and parses the file; automatic syncs follow and skip a file whose content did not change.
Review the candidatesAgents and testers read the process document from the knowledge base and write scenarios from the candidates they keep.

Connect

Setup

In Bizagi Modeler, export the diagram (Export/Import → BPMN) and commit the .bpmn file to a repository, or publish it at an https address TestingOps can reach.
In TestingOps, open Integrations → Platforms → Process models (BPMN 2.0) → Bizagi and save the connection, with an access token only for a private GitHub or GitLab repository.
In the project's Knowledge tab, select Add source under Process models (BPMN 2.0) and paste the link of the .bpmn file.
Select Sync now. When you export a new version, replace the file at the same link; the next sync reads it.

Where you connect it in TestingOps: Integrations → Platforms → Process models (BPMN 2.0) → Bizagi

Use cases

Plan role-based tests for a cross-department process

Trigger: A team links the BPMN export of its purchase request process
Uses: The lane of every step and the paths through the gateways
Agent activity: Writes scenarios that switch test users where the path moves to another lane
Result: Scenarios that name the role for each step
Condition: Test accounts for each lane's role must exist in the test environment

Keep scenarios in step with the model

Trigger: An analyst exports a new version of the diagram to the same link
Uses: The file's content, compared on each sync
Agent activity: Works from the re-read process when revising scenarios
Result: Candidates that match the latest export
Condition: Nothing changes in TestingOps until a new export replaces the file

Find the exception paths a workshop missed

Trigger: A diagram with intermediate and boundary events
Uses: The exceptions listed per activity and the paths that branch from them
Agent activity: Proposes scenarios for the timer and error branches
Result: Exception scenarios for review next to the main flow
Condition: Bizagi-specific form and business rule definitions are not read, only standard BPMN 2.0

Capabilities

Capabilities and limits

What is read

A BPMN 2.0 file exported from Bizagi Modeler, fetched from its link: GitHub and GitLab page links become raw file links, other http(s) addresses are fetched as they are, Google Drive links are refused
Per process (named after its pool when there is one): start, end, intermediate and boundary events with their type, such as timer, error or message; tasks, including user, service, script, business rule, manual, send and receive tasks; call activities, without following the called process; sub-processes, ad-hoc sub-processes and transactions with their inner steps; exclusive, inclusive, parallel, event-based and complex gateways; sequence flows with their name or condition; lanes; documentation; inline form fields such as camunda:formField
Not parsed: message flows between pools, data objects and data stores, text annotations, the DMN tables behind business rule tasks, linked forms, and timer or expression details beyond the event type

What is produced

One knowledge-base document per process: steps with kind, lane and documentation, decisions with their outcomes, exceptions from boundary events, form fields, and numbered paths from start to end marked as test scenario candidates

Where it can write

Nothing: TestingOps only downloads the file from its link

How it connects

A link to the exported file. There is no live connection to Bizagi; changes arrive when the file at the link changes

Account and permissions

No Bizagi account
An access token only for files in a private GitHub or GitLab repository; it is sent as a bearer token

Limits

Paths are bounded: at most 30 per process and 60 steps per path; a loop is followed once and the path ends with "back to" the step it returns to; each outgoing branch of a gateway, parallel and inclusive ones included, becomes its own path, so branches are not combined
Paths are candidates for review: no TestingOps scenarios or cases are created from them automatically
A change made in Bizagi Modeler reaches TestingOps only after a new export replaces the file at the link
Bizagi-specific form and business rule definitions are not read beyond standard BPMN 2.0
The file is read from its link; uploading a .bpmn file is not supported
Up to 12,000 characters per process section and 200 processes per model; files and exports up to 15 MB

Example

Example: how a team uses it

Illustrative scenario, not a customer story.

An operations team models supplier onboarding in Bizagi Modeler with lanes for Purchasing, Finance and Compliance, and keeps the BPMN export in a GitLab repository.

After linking the file, the process document shows four paths, one of them ending in "back to Collect documents" where Compliance sends the request back. An agent drafts scenarios for each path with the role that acts at every step, and the team reviews them with the process owner.

Frequently asked questions

Can we upload the Bizagi file instead of linking it?

No. The source is a link to the exported .bpmn file, for example in Git. Linking keeps TestingOps in step with the file: when you replace the export at the same link, the next sync reads the new version.

Does TestingOps connect to our Bizagi environment?

No. There is no live connection to any Bizagi product. TestingOps reads only the BPMN file you export from Bizagi Modeler.

Which parts of a Bizagi diagram are read?

Standard BPMN 2.0: events, tasks, sub-processes, gateways, named sequence flows, pools, lanes and documentation. Bizagi-specific form and rule definitions, message flows between pools, data objects and annotations are not read.

How many scenario candidates will we get?

One per path from a start event to an end, up to 30 per process and 60 steps per path. Loops are followed once and parallel branches are listed as separate paths, so review the list before writing scenarios.

Our repository is private. How is the file fetched?

Add an access token to the Bizagi connection; it is sent as a bearer token when the file is fetched. GitHub and GitLab page links are turned into raw file links first.

Next step

See what your Bizagi diagrams give the test team: request a demo and bring one exported .bpmn file.

Request a demo More process models integrations