ProphitBet and a desktop app for soccer match prediction

A GUI application, not a library

ProphitBet is described as an open source machine learning soccer bet prediction application. The name is a pun on prophet and profit, and the scope is narrow in a useful way: download historical soccer data, analyse the form of teams with machine learning methods, compute team statistics, draw statistical graphs, and predict match outcomes.

The interface is PyQt6. The repository root holds app.py as the entry point, app.bat for Windows and app.sh for Linux, install.py for dependency setup, and a src/ directory for the code itself, alongside a storage/ directory where the league and result tables live and a screenshots/ folder. The primary language is Python, and the licence is MIT, so the code is readable and reusable.

Two data sources sit behind the application, and both are third-party web sources rather than bundled datasets. Historical results come from every league included in football-data.co.uk, and upcoming fixtures are parsed from Footystats. Both require an internet connection, which is the single most important operational fact about the application: it is not an offline tool with a frozen dataset.

The audience is a developer or analyst who wants a working, inspectable pipeline rather than a library to call. The README's own framing is that the app extracts the data, trains and validates the models automatically, and hands you predictions, so the evaluation question is whether that pipeline is a good enough base for your own research.

There is also a version split worth knowing. The previous release lives on the branch ProphitBet-v1, and the current ProphitBet-v2 is the one in the main branch.

The model set and the validation that runs automatically

The supported algorithms are neural networks, random forests and ensemble models, and the requirements file shows what sits underneath them.

TensorFlow 2.15.1 and Keras 2.15.0 carry the neural network side. scikit-learn 1.6.1 provides the random forest and the surrounding machinery. Optuna 4.4.0 is the hyperparameter tuner, which is what makes the training options in the GUI more than a fixed default. Boruta 0.4.3 handles feature selection, and shap 0.48.0 provides explainability, which is what the release notes for the v2 launch refer to as explainable models. imbalanced-learn 0.13.0 is present, and the repository topics name imbalanced learning, feature analysis, feature importance and interpretability methods directly.

What the application does automatically, according to the README, is apply cross-validation and holdout during model training, with the stated aim of producing models with a low probability of being over-fitted. Automatic validation is the part that matters for trust, since a model trained on one split and reported on the same data tells you very little.

The release notes for 01-17-2026 add a metric that is the most distinctive idea in the application: Profit Balance. The note says that if profit balance is lower than accuracy, then the selected matches are mathematically profitable. That inverts the usual reading. Most classifiers report accuracy as the headline number, and accuracy above chance is not the same as making money, because the odds and the stake decide the second. Comparing the two figures is a crude but genuine attempt to separate a model that picks outcomes from one that picks outcomes that pay.

The 03-17-2026 release added analytical evaluation metrics per season, which pushes the same idea into a time dimension, comparing form across individual seasons rather than in aggregate.

Installing it on Windows and elsewhere

The installation instructions are unusually explicit about the environment, which is helpful when a project has this many pinned dependencies.

Python 3.11 is the recommended version, though the README says other versions can be used, naming 3.10, 3.12, 3.13 and 3.14, and that only 3.10 and 3.11 have been tested. On Windows you also need the Microsoft Visual C++ Redistributable, x64 or x86. During the Python installation the Add Python to Path option has to be selected, since the application is launched from a command line.

The code comes from the green Code button on the repository page, either as a zip download or by copying the archive address, and is unzipped into a directory of your choice. The dependencies are pinned with specific versions in requirements.txt, and an advanced user can install them into any environment:

pip install -r requirements.txt

A newer user is pointed at the install.py script, which downloads the required libraries automatically:

python install.py

The script installs into the default Python version by default, and the README gives an alternative that targets a specific environment, which is the option to use if you do not want TensorFlow and PyQt6 in your system interpreter:

python install.py --venv "C:\Users\You\python\envs\myenv"

If the installation goes well, the script prints an Installation complete! message and the installation details, and an error otherwise. Excel support was added to the pipeline in the 03-17-2026 release and needs one extra package, installed from the command line:

pip install openpyxl

The README notes that if the app was installed in a custom environment, that environment should be activated first. The last step is running the application with `python app.py`, or by double-clicking app.bat on Windows and app.sh on Linux. The README warns that an active anti-virus can slow down initialisation.

Fixtures, filters and the Excel output

The pipeline goes beyond training. It parses upcoming fixtures from Footystats and predicts them, and the results can be organised and saved into an Excel file, which is the deliverable most users want.

The 03-17-2026 release changed how that file is written. The release note says the table store no longer replaces the metrics and predictions, and instead tries to append the new metrics or predictions into the existing file, and that this works in both csv and excel format. That is a small change with a large effect on habit: a spreadsheet you can append to is a spreadsheet you can keep, whereas one that is overwritten each run loses history on every execution.

The same release added a Delete Filter button to remove unwanted filters, which suggests league and fixture selection is a filtering operation on a larger table, and the GUI section mentions key shortcuts for creating, opening and deleting leagues to make it faster.

Two fixes in the same release are worth noting because they describe the fragile parts of the pipeline. One is a bug where the footystats parser would fail to parse upcoming fixtures, so the upstream page structure is a moving target. The other is a set of crashes during model evaluation, which is the phase most likely to trip over an unusual league or a small sample.

The graphics are part of the appeal. The application produces statistical graph visualisations of team form, with seaborn 0.13.2 and matplotlib 3.10.3 in the dependency set for the plotting work, and a pandas 2.3.1 dataframe layer underneath the tables.

What this will not do for you

There are limits that the README does not hide, and one it does not address at all.

The first is the data. football-data.co.uk is a collection of CSV files updated per round, with no version control, no schema guarantee and no service level. Footystats is scraped, and the 03-17-2026 fix proves the scraper breaks when the page changes. Every prediction is downstream of a page you do not control, and nothing in the repository describes caching or a fallback when a fetch fails.

The second is the evaluation design. Profit Balance is described in one sentence, in the context of a release note, and the documentation does not define how profit is computed, over what period, or against which odds. A metric whose definition is not written down cannot be audited, and comparing it against accuracy is meaningful only if both are computed on the same held-out set with the same odds source.

The third is the absence of any money model. There is no mention of bankroll management, staking strategy, or the bookmaker odds that a bet's value depends on. A match predictor and a betting system are different products, and this is the first one. If your goal is a return, you would be adding the part that actually determines whether you make money.

The fourth is the dependency weight. The pinned list runs to well over a hundred packages, with TensorFlow, Keras, PyQt6, scipy, numba, lxml, shap, optuna and Boruta among them, and it pins exact versions including transitive ones like astunparse 1.6.3 and gast 0.6.0. That pinning is what makes the install reproducible, and it is also what will break first when you want to run it alongside anything else.

Where the GUI ends and a script begins

The strongest argument for this project is not the models, it is that the whole path from raw CSVs to an explained prediction is assembled and wired together already.

A comparable approach is to build the same thing yourself with pandas and scikit-learn: read the football-data.co.uk CSVs yourself, engineer form features, split chronologically rather than randomly, train a model, calibrate it, and pull live fixtures from a schedule endpoint. That approach gives you control over every step and no dependency on someone else's UI, and it takes considerably longer. The difference in approach is that ProphitBet puts the model choices, the validation strategy and the feature selection behind a graphical interface with a storage directory for your leagues, while the manual path leaves all of that as code you own.

For learning or for a one-off analysis, the application is faster. For anything you intend to run on a schedule against live odds, the code-based path is the one that survives, because you need a pipeline you can re-run, log and monitor, and a PyQt6 window is not that.

The interface details are minor but worth knowing. The v2 GUI is described as more lightweight and prettier than v1, with two themes, Light and Dark, and the dark theme comes from the pyqtdarktheme 2.1.0 package. The darkdetect 0.7.1 dependency suggests the theme follows the system setting. Keyboard shortcuts exist for creating, opening and deleting leagues, which is the operation you will repeat most.

Release history, licensing and the shape of the project

The repository has no GitHub releases, and the release history lives in the README as a series of dated entries. The newest is Release 03-17-2026, which fixed model evaluation crashes, fixed the footystats fixture parser, added Excel support, changed the table store to append rather than replace, added per-season analytical evaluation metrics and added the Delete Filter button. Before that, Release 01-17-2026 fixed several crashes and introduced the Profit Balance metric, and Release 13-11-2025 launched v2 with easier installation, a new interface, more statistics, more analysis tools, more training and evaluation tools, more training options and explainable models, while moving v1 to the branch ProphitBet-v1.

The repository is not archived and the last push was on 2026-10-10, so the work is ongoing, though the cadence in the notes is monthly rather than continuous.

The licence is MIT, which is permissive in the ordinary sense: you can use, modify and redistribute the code, including in a commercial product, and the only obligation is keeping the copyright notice. There is no licence complication around the data, since the historical results come from football-data.co.uk and the fixtures from Footystats, and neither is redistributed by this repository.

Two files are worth a look if you plan to build on it. CITATION.cff is a citation metadata file, which suggests the author intends the work to be citable in academic writing, and Prophitbet.iml is a PyCharm project file, which tells you the development environment. The requirements.txt pinning exact versions down to astunparse and gast is the third file to read, because it is the shortest complete description of what the application actually needs from your machine.

Editorial conclusion

ProphitBet is a good fit for a Python developer who wants a working end-to-end pipeline for soccer match prediction, with historical data ingestion, model training, explainability and a spreadsheet output in one place, because the app ships a GUI rather than requiring you to wire a pipeline together. It is a poor fit for a production betting system, since the data source is a public CSV site with no SLA, the metrics are reported in-sample against historical fixtures, and no bankroll or odds modelling is described. Before adopting, check that the leagues you care about are covered by football-data.co.uk, read the Profit Balance metric before trusting the accuracy figure, and install with `python install.py --venv` into an isolated environment, since the pinned dependency set includes TensorFlow, Keras, PyQt6 and imbalanced-learn.

Frequently asked questions

Official sources

1. Issues
2. kochlisGit/ProphitBet-Soccer-Bets-Predictor on GitHub
3. License: MIT
4. README