PM4Py — Process Mining for Python The open-source process mining library for Python.

See how your processes really run, where they differ from the plan and where time is lost, all with just a few lines of Python code. Researchers, developers and software companies around the world build on PM4Py.

$ pip install pm4py

Building a commercial product? See licensing options

In a Nutshell What is PM4Py?

A toolbox for process mining

PM4Py is a collection of ready-made process mining functions for the Python programming language. Instead of clicking through a user interface, you pick the tools you need and use them directly in your own code, so you don't have to build the algorithms yourself.

Your analysis, your rules

With PM4Py, you're never limited to the buttons and menus of a user interface. Every step of your analysis is up to you: automate recurring analyses, combine PM4Py with any other Python tool, or build something completely new. If you can imagine it, you can build it.

Made for people who code

Software companies, data scientists and researchers build on PM4Py instead of starting from scratch, from quick one-time analyses to complete software products. Our own tool, PMTk, is built on it too. PM4Py is downloaded more than 100,000+ times every month¹.

¹ According to pypistats.org

Why PM4Py?

Quick to learn, close to the latest research, and ready for commercial use.

Easy to start

Runs on all major platforms. Step-by-step tutorials and complete API documentation get you to your first result quickly.

Installation instructions

Latest research, ready to use

PM4Py covers the full range of process mining, from discovering processes and checking whether they run as planned to predictive and object-centric process mining. Developed close to research, it brings you new methods early.

List of PM4Py features

Open source, ready for business

PM4Py is free and open source under the AGPL v3 license. If you build a commercial product and want to keep your source code private, we offer dedicated licenses and professional support.

Compare licensing options

PM4Py in Action Visual Examples

A selection of features with visual output, each in just a few lines of Python.

Process Discovery

Discover process models from event data, from directly-follows graphs to Petri nets, BPMN models, and process trees.

Directly-follows graph with activity frequencies on its nodes and edges

Directly-follows frequenciesShows the observed order of activities and how often they follow each other in the event log

import pm4py
log = pm4py.read_xes("tests/input_data/running-example.xes")
dfg, starts, ends = pm4py.discover_dfg(log)
pm4py.save_vis_dfg(dfg, starts, ends, "visualization.svg", graph_title="Directly-follows frequencies")

import pm4py
log = pm4py.read_xes("tests/input_data/running-example.xes")
net, initial, final = pm4py.discover_petri_net_inductive(log)
pm4py.save_vis_petri_net(net, initial, final, "visualization.svg", graph_title="Inductive miner: approval process")

import pm4py
log = pm4py.read_xes("tests/input_data/running-example.xes")
model = pm4py.discover_bpmn_inductive(log)
pm4py.save_vis_bpmn(model, "visualization.svg", graph_title="BPMN discovered from the approval log")

import pm4py
log = pm4py.read_xes("tests/input_data/running-example.xes")
tree = pm4py.discover_process_tree_inductive(log)
pm4py.save_vis_process_tree(tree, "visualization.svg", graph_title="Process tree: choices, concurrency and repetition")

Conformance Checking

Compare observed behavior with a process model, case by case, and measure how well the model fits.

Petri net decorated with the frequencies of token-based replay on its transitions and arcs

Replay frequencies on a Petri netReplay the log on its discovered Petri net and decorate transitions and arcs with execution counts

import pm4py
log = pm4py.read_xes("tests/input_data/running-example.xes")
net, initial, final = pm4py.discover_petri_net_inductive(log)
pm4py.save_vis_petri_net(net, initial, final, "visualization.svg", log=log, variant_str="token_decoration_frequency", graph_title="Token replay: transition and arc frequencies")

import pm4py
import matplotlib.pyplot as plt
log = pm4py.read_xes("tests/input_data/running-example.xes")
net, initial, final = pm4py.discover_petri_net_inductive(pm4py.filter_variants_top_k(log, 1))
data = pm4py.conformance_diagnostics_alignments(log, net, initial, final, return_diagnostics_dataframe=True)
ax = data.plot.bar(x="case_id", y="fitness", figsize=(9, 5), legend=False, color="#2166ac")
ax.set(title="Alignment fitness against the dominant variant", xlabel="Case", ylabel="Alignment fitness", ylim=(0, 1.05))
ax.figure.savefig("visualization.svg", bbox_inches="tight")

import pm4py
import matplotlib.pyplot as plt
log = pm4py.read_xes("tests/input_data/running-example.xes")
net, initial, final = pm4py.discover_petri_net_inductive(log)
data = {"Replay fitness": pm4py.fitness_token_based_replay(log, net, initial, final)["log_fitness"], "Precision": pm4py.precision_token_based_replay(log, net, initial, final), "Generalization": pm4py.generalization_tbr(log, net, initial, final)}
fig, ax = plt.subplots(figsize=(9, 5), subplot_kw={"title": "Quality of the inductive model on its input log", "ylabel": "Score", "ylim": (0, 1.05)})
ax.bar(list(data), list(data.values()), color=["#2166ac", "#4393c3", "#92c5de"])
fig.savefig("visualization.svg", bbox_inches="tight")

Performance Analysis

Find out where time is spent: between activities, along process paths, and across whole cases.

Directly-follows graph annotated with the mean elapsed time between activities

Waiting between activitiesLocate slow transitions using mean elapsed time between consecutive events

import pm4py
log = pm4py.read_xes("tests/input_data/running-example.xes")
dfg, starts, ends = pm4py.discover_performance_dfg(log)
pm4py.save_vis_performance_dfg(dfg, starts, ends, "visualization.svg", graph_title="Mean elapsed time between consecutive events")

import pm4py
log = pm4py.read_xes("tests/input_data/running-example.xes")
pm4py.save_vis_performance_spectrum(log, ["register request", "check ticket", "decide"], "visualization.svg", graph_title="Register → check → decide<BR/>Redder segments indicate longer elapsed times")

import pm4py
import matplotlib.pyplot as plt
log = pm4py.read_xes("tests/input_data/running-example.xes")
fig, ax = plt.subplots(figsize=(11, 5), subplot_kw={"title": "Approval events by time and case", "xlabel": "Date (UTC)", "ylabel": "Case identifier", "yticks": sorted(log["case:concept:name"].astype(int).unique())})
for activity, events in log.groupby("concept:name"):
    ax.scatter(events["time:timestamp"], events["case:concept:name"].astype(int), label=activity, s=36)
ax.legend(title="Activity", bbox_to_anchor=(1.02, 1), loc="upper left")
fig.savefig("visualization.svg", bbox_inches="tight")

import pm4py
import matplotlib.pyplot as plt
log = pm4py.read_xes("tests/input_data/roadtraffic100traces.xes")
data = [seconds / 86400 for seconds in pm4py.get_all_case_durations(log)]
fig, ax = plt.subplots(figsize=(9, 5))
ax.hist(data, bins=16, color="#2166ac", edgecolor="white")
ax.set(title="Traffic case duration distribution", xlabel="Elapsed days", ylabel="Cases")
fig.savefig("visualization.svg", bbox_inches="tight")

Process Statistics

Summarize an event log at a glance: its variants, activity volumes, and when events happen.

Horizontal bar chart of the most frequent variants of an event log

Most frequent variantsRank the most frequent complete activity sequences in a given event log

import pm4py
import matplotlib.pyplot as plt
log = pm4py.read_xes("tests/input_data/roadtraffic100traces.xes")
data = sorted(pm4py.get_variants_as_tuples(log).items(), key=lambda item: item[1], reverse=True)[:6]
fig, ax = plt.subplots(figsize=(10, 8))
ax.barh([" →\n".join(variant) for variant, count in data][::-1], [count for variant, count in data][::-1], color="#2166ac")
ax.set(title="Most frequent traffic variants", xlabel="Cases", ylabel="")
fig.savefig("visualization.svg", bbox_inches="tight")

import pm4py
import matplotlib.pyplot as plt
log = pm4py.read_xes("tests/input_data/running-example.xes")
data = dict(sorted(pm4py.get_event_attribute_values(log, "concept:name").items(), key=lambda item: item[1]))
fig, ax = plt.subplots(figsize=(9, 5))
ax.barh(list(data), list(data.values()), color="#2166ac")
ax.set(title="Activity volumes", xlabel="Events", ylabel="")
fig.savefig("visualization.svg", bbox_inches="tight")

import pm4py
log = pm4py.read_xes("tests/input_data/roadtraffic100traces.xes")
pm4py.save_vis_events_distribution_graph(log, "visualization.svg", distr_type="days_week", graph_title="Traffic events by weekday")

Organizational Mining

See how work is handed over between resources, where it is done in batches, and which roles emerge from the data.

Handover-of-work network between resources, with handover ratios on the edges

Handover of workShow directed handovers between the resources of consecutive events within cases

from pathlib import Path
import pm4py
from graphviz import Digraph
log = pm4py.read_xes("tests/input_data/running-example.xes")
metric = pm4py.discover_handover_of_work_network(log)
graph = Digraph(graph_attr={"label": "Handover of work", "labelloc": "t", "rankdir": "LR"}, node_attr={"shape": "ellipse", "style": "filled", "fillcolor": "#e5f0fa"})
for (source, target), weight in sorted((pair, weight) for pair, weight in metric.connections.items() if weight > 0 and (metric.is_directed or pair[0] < pair[1])):
    graph.edge(source, target, label=f"{weight:.2f}")
Path("visualization.svg").write_bytes(graph.pipe(format="svg"))

import pm4py
import matplotlib.pyplot as plt
log = pm4py.read_xes("tests/input_data/receipt.xes")
data = pm4py.discover_batches(log)[:10]
fig, ax = plt.subplots(figsize=(9, 5))
ax.barh([" / ".join(pair) for pair, count, details in data][::-1], [count for pair, count, details in data][::-1], color="#2166ac")
ax.set(title="Activity-resource pairs with most batches", xlabel="Detected batches", ylabel="")
fig.savefig("visualization.svg", bbox_inches="tight")

import pm4py
import matplotlib.pyplot as plt
log = pm4py.read_xes("tests/input_data/running-example.xes")
data = pm4py.discover_organizational_roles(log)
fig, ax = plt.subplots(figsize=(9, 6))
ax.barh([" /\n".join(role.activities) for role in data], [len(role.originator_importance) for role in data], color="#2166ac")
ax.set(title="Discovered organizational roles", xlabel="Distinct resources in role", ylabel="Activities grouped into each role")
fig.savefig("visualization.svg", bbox_inches="tight")

Event Log Filtering

Narrow an event log down to the cases and paths that matter before you analyze it.

Directly-follows graph of the case segments between two activities

Crop cases between two activitiesExtract subprocess segments between two activities before discovering their directly-follows graph

import pm4py
log = pm4py.read_xes("tests/input_data/running-example.xes")
log = pm4py.filter_between(log, "register request", "decide")
dfg, starts, ends = pm4py.discover_dfg(log)
pm4py.save_vis_dfg(dfg, starts, ends, "visualization.svg", graph_title="From registration to decision")

import pm4py
log = pm4py.read_xes("tests/input_data/running-example.xes")
log = pm4py.filter_end_activities(log, ["reject request"])
dfg, starts, ends = pm4py.discover_dfg(log)
pm4py.save_vis_dfg(dfg, starts, ends, "visualization.svg", graph_title="Routes ending in rejection")

import pm4py
log = pm4py.read_xes("tests/input_data/roadtraffic100traces.xes")
log = pm4py.filter_case_performance(log, min_performance=365 * 86400, max_performance=float("inf"))
dfg, starts, ends = pm4py.discover_dfg(log)
pm4py.save_vis_dfg(dfg, starts, ends, "visualization.svg", graph_title="Traffic cases lasting over one year")

Machine Learning Features

Turn cases into feature tables for machine learning, ready for pandas and scikit-learn.

Stacked bar chart of activity occurrence counts per case, as extracted into a feature table

Activity count features per caseExtract machine-learning-ready case vectors and visualize their activity counts as stacked bars

import pm4py
import matplotlib.pyplot as plt
log = pm4py.read_xes("tests/input_data/running-example.xes")
data = pm4py.extract_features_dataframe(log, str_ev_attr=["concept:name"], count_occurrences=True)
ax = data.rename(columns=lambda name: name.replace("concept:name_", "")).plot.bar(stacked=True, figsize=(11, 5), colormap="tab20")
ax.set(title="Case feature vectors: activity occurrence counts", xlabel="Case index in feature table", ylabel="Events")
ax.legend(title="Activity", bbox_to_anchor=(1.02, 1), loc="upper left")
ax.figure.savefig("visualization.svg", bbox_inches="tight")

import pm4py
import matplotlib.pyplot as plt
log = pm4py.read_xes("tests/input_data/running-example.xes")
data = pm4py.extract_features_dataframe(log, str_ev_attr=["concept:name"], count_occurrences=True)
fig, ax = plt.subplots(figsize=(13, 5))
fig.colorbar(ax.pcolormesh(data, cmap=plt.get_cmap("Blues", 4), vmin=-0.5, vmax=3.5, edgecolors="white", linewidth=1), ax=ax, label="Occurrences", ticks=range(4))
ax.set(title="Case activity count features", xlabel="Activity", ylabel="Case index in feature table", xticks=[index + 0.5 for index in range(data.shape[1])], xticklabels=[name.replace("concept:name_", "").replace(" ", "\n") for name in data], yticks=[index + 0.5 for index in range(len(data))], yticklabels=range(len(data)), ylim=(len(data), 0))
fig.savefig("visualization.svg", bbox_inches="tight")

import pm4py
import matplotlib.pyplot as plt
from sklearn.decomposition import PCA
log = pm4py.read_xes("tests/input_data/roadtraffic100traces.xes")
data = PCA(n_components=2).fit_transform(pm4py.extract_features_dataframe(log, str_ev_attr=["concept:name"], count_occurrences=True))
fig, ax = plt.subplots(figsize=(8, 6), subplot_kw={"title": "Traffic cases projected from activity counts", "xlabel": "Principal component 1", "ylabel": "Principal component 2"})
ax.scatter(data[:, 0], data[:, 1], alpha=0.6, color="#2166ac")
fig.savefig("visualization.svg", bbox_inches="tight")

Object-Centric Process Mining

Analyze processes in which events relate to several objects at once, such as orders, items, and deliveries.

Object-centric directly-follows graph with one color per object type

Object-centric directly-follows graphDiscover separate directly-follows relationships for each object type, with shared activities

import re
import pm4py
from pm4py.visualization.ocel.ocdfg import visualizer
log = pm4py.read_ocel("tests/input_data/ocel/example_log.jsonocel")
model = pm4py.discover_ocdfg(log)
graph = visualizer.apply(model, parameters={"format": "svg", "bgcolor": "white", "rankdir": "TB", "annotation": "frequency", "enable_graph_title": True, "graph_title": "OC-DFG: orders, items and deliveries"})
graph.body = [re.sub(r'fontcolor="[^"]+"', "fontcolor=black", re.sub(r'fillcolor=("[^"]+")', r"color=\1 fillcolor=white", line) if "shape=ellipse" in line else line).replace("fontsize=8", "fontsize=10") for line in graph.body]
visualizer.save(graph, "visualization.svg")

import pm4py
log = pm4py.read_ocel("tests/input_data/ocel/example_log.jsonocel")
model = pm4py.discover_oc_petri_net(log)
pm4py.save_vis_ocpn(model, "visualization.svg", graph_title="Object-centric Petri net: shared activities")

import pm4py
log = pm4py.read_ocel("tests/input_data/ocel/example_log.jsonocel")
flat = pm4py.ocel_flattening(log, "order")
dfg, starts, ends = pm4py.discover_dfg(flat)
pm4py.save_vis_dfg(dfg, starts, ends, "visualization.svg", graph_title="Flattened OCEL: order perspective")

import pm4py
import matplotlib.pyplot as plt
log = pm4py.read_ocel("tests/input_data/ocel/example_log.jsonocel")
data = pm4py.ocel_objects_summary(log).sort_values("lifecycle_duration")
fig, ax = plt.subplots(figsize=(9, 6))
ax.barh(data["ocel:oid"], data["lifecycle_duration"] / 3600, color="#2166ac")
ax.set(title="Object lifecycle durations", xlabel="Hours from first to last recorded event (symlog scale)", ylabel="Object", xscale="symlog")
fig.savefig("visualization.svg", bbox_inches="tight")

More example scripts can be found online:Tutorials & Examples More examples on GitHub

Licensing

PM4Py is available under two licensing options: an open-source license for academic and research purposes, and a closed-source license for commercial use.

PM4Py Community and Commercial Version compared
Comparison	Community VersionOpen-Source License	Commercial VersionClosed-Source License
Main User Groups	Students, teachers, lecturers, and researchers	Companies and other commercial organizations
Main Use Case	Teaching, research, and open-source projects	Commercial applications
License	GNU Affero General Public License v3.0 (GNU AGPL V3)	Individual license agreement
Modifications	Modifications allowed	Modifications allowed
Covered Work¹	Covered work¹ (e.g., scripts or software using PM4Py) must be published open-source under AGPL	Covered work¹ (e.g., scripts or software using PM4Py) may remain closed-source
Commercial Usage	Not viable for most commercial use: any script or software using PM4Py must be published open-source under AGPL	Unrestricted commercial use permitted
Distribution	GitHub	Private repository
Release Cycle	No fixed release schedule	Regular releases with early feature access
Support	—	Dedicated professional support
Pricing	Free of charge	Request a Quote

¹ A covered work (as defined in the AGPL) includes any software or script using PM4Py in any way, such as by importing or using its functionality. This applies regardless of whether PM4Py itself is modified. Furthermore, if a covered work is made accessible over a network (e.g., as a web service or API), the AGPL requires the source code to be made available to users of that service.

FAQ

Something else on your mind?

Get in touch

Licensing Basics

PM4Py started as an open-source project, and we want to keep a powerful set of process mining algorithms freely available for research, teaching, and open-source projects. That's why PM4Py is licensed under the GNU AGPL v3. Developing and maintaining a library like this requires ongoing resources, though. Companies that build proprietary software on PM4Py, and don't want to publish their source code under the AGPL, can get a commercial license instead. The license fees help fund PM4Py's continued development.

Yes, but only under the conditions of the GNU AGPL v3. If you distribute software that uses PM4Py, or make it available to users over a network, you must publish its source code under the AGPL as well. Most companies can't open-source their proprietary code, so they need a commercial license.

The AGPL in Detail

Yes. The AGPL applies to PM4Py whether or not you modify it, and software that imports or uses PM4Py is generally considered a work based on it. Its requirements, such as publishing your source code under the AGPL, apply when you distribute that software or, in certain cases, make it available to users over a network.

The AGPL defines a covered work as "either the unmodified Program or a work based on the Program". For PM4Py, this means PM4Py itself and software built on it, which generally includes scripts and applications that import PM4Py, whether or not you modify PM4Py.

The AGPL has a network clause (Section 13) for exactly this case. If you modify PM4Py or build it into your own software, and users interact with it over a network, you must offer the corresponding source code, even if you never distribute the software itself. This generally means the source code of your entire application, not only PM4Py. If you don't want to publish your source code, you'll need a commercial license.

Commercial Version

The Commercial Version adds four things:

Use in proprietary software: you can build PM4Py into closed-source products and services without publishing your source code.
Early access: you get new features before they reach the Community Version.
Regular releases: updates follow a fixed release cycle, so you can plan upgrades.
Professional support: our team is available to help when you need it.

Yes. Our startup licensing lets you build PM4Py into your product right away and only start paying license fees as your business grows. We agree on the terms together upfront, so you know exactly what to expect. Contact us to find the right setup for you.

Please contact us at info@processintelligence.solutions, and we will provide you with an evaluation license specific to this purpose.

About PM4Py

PM4Py is a Python library for developers who build their own process mining applications. PMTk is a no-code application for business teams who want to analyze processes without programming. Both are developed by the same team and complement each other. Not sure which one is right for you? Contact us

PM4Py was originally developed at Fraunhofer FIT. Since 2024, its spin-off Process Intelligence Solutions GmbH has been fully responsible for PM4Py, including its development, maintenance, distribution, and licensing.

We welcome contributions from the community! Our contribution guidelines explain how to get started.

PM4Py — Process Mining for Python The open-source process mining library for Python.

In a Nutshell What is PM4Py?

A toolbox for process mining

Your analysis, your rules

Made for people who code

Why PM4Py?

Easy to start

Latest research, ready to use

Open source, ready for business

PM4Py in Action Visual Examples

Process Discovery

Conformance Checking

Performance Analysis

Process Statistics

Organizational Mining

Event Log Filtering

Machine Learning Features

Object-Centric Process Mining

Licensing

FAQ

Why are there two licensing options for PM4Py?

Can I use the Community Version for commercial purposes?

Does the AGPL apply even if I don't modify PM4Py?

What is a 'covered work' under the AGPL?

What if I use PM4Py in a web service, API, or SaaS product?

What does the Commercial Version offer that the Community Version doesn't?

I'm a startup with little or no revenue. Can I still build on PM4Py?

Can I use the Community Version for commercial evaluation without making my code open-source?

What is the difference between PM4Py and PMTk?

Who is behind the development of PM4Py?

How can I contribute to PM4Py?