TabPFN: using the tabular foundation model locally and what its licence costs you

What TabPFN does that gradient boosting does not

A gradient boosting model learns from your training rows. TabPFN does not. It is a pre-trained transformer, and the README describes it as a foundation model for tabular data: it trains on synthetic datasets and predicts on unseen real-world datasets in a single forward pass. The training set you pass to fit is context for that forward pass, not data the weights are updated on.

The practical consequence is speed and label efficiency. On a table with a few hundred rows and a dozen columns, fitting a boosted ensemble and tuning it can take longer than the prediction itself. TabPFN's pitch is that the first prediction is already close to what a well-tuned model would give you. That matters most in the regime where tabular data actually lives: small, wide, messy tables from experiments, clinical studies, or A/B tests where you have hundreds of rows, not millions.

It is not for every table. The README is explicit that on CPU only moderate datasets are feasible, with the default TabPFN-3 allowing up to 5000 samples and older versions up to 1000. If your table has a million rows, this is the wrong tool and you already know it.

The single forward pass, and where the checkpoint comes from

The architecture shown in the repository diagrams is a distribution embedder followed by row-wise and cross-row attention, read out as per-row tokens. In plain terms: each cell and column is embedded, attention runs across rows so the model can compare a test row against the training rows, and the output is a per-row prediction.

That design explains the two constraints users hit first. Cross-row attention means the whole training set is part of the input, so memory scales with the number of rows, not just parameters. And because there is no per-dataset training, the checkpoint is fixed. The README notes that fit downloads the checkpoint on first use. The package depends on huggingface-hub, so the first call reaches out to fetch weights and caches them; subsequent runs read the local cache. In an air-gapped environment you need to pre-populate that cache, and the README does not document an offline path.

The default model is TabPFN-3. The constants module exposes ModelVersion, so you can pin an older release explicitly rather than depending on whatever the package defaults to at install time.

Installing TabPFN and running a first classification

The base install is one pip command. TabPFN supports Python 3.10 and later, and the package metadata lists classifiers through 3.14.

pip install tabpfn

On Linux with an Nvidia GPU, support is included automatically. For AMD GPUs you install PyTorch with ROCm first, then TabPFN, because pip would otherwise resolve a CPU or CUDA build:

pip install torch --index-url https://download.pytorch.org/whl/rocm7.2
pip install tabpfn

On macOS, GPU support is included for Apple Silicon, and the README recommends PyTorch 2.13 or newer for best performance. On Windows with an Nvidia GPU, install PyTorch with CUDA first, then TabPFN.

Once installed, the API mirrors scikit-learn. The README gives this example:

from tabpfn import TabPFNClassifier, TabPFNRegressor

clf = TabPFNClassifier()
clf.fit(X_train, y_train)  # downloads checkpoint on first use
predictions = clf.predict(X_test)

reg = TabPFNRegressor()
reg.fit(X_train, y_train)  # downloads checkpoint on first use
predictions = reg.predict(X_test)

The first fit call is the slow one: it fetches the checkpoint and puts it on the device. What you should see is a standard scikit-learn style estimator that accepts numpy arrays or DataFrames and exposes predict. If you want the previous default instead of TabPFN-3, instantiate through the version enum:

from tabpfn import TabPFNClassifier, TabPFNRegressor
from tabpfn.constants import ModelVersion

classifier = TabPFNClassifier.create_default_for_version(ModelVersion.V2_6)
regressor = TabPFNRegressor.create_default_for_version(ModelVersion.V2_6)

The examples directory carries runnable scripts for binary classification, multiclass classification, and regression if you want a starting point that already loads data.

GPU, dataset size, and the limits the README states

The README recommends a GPU, and the numbers it gives are concrete: even older GPUs with around 8GB VRAM work well, while some large datasets need 16GB. On CPU, only moderate datasets are feasible. That is the honest headline limitation. A laptop CPU run on a 10,000-row table is not a supported configuration, and the failure will look like memory pressure or unacceptable latency rather than a clean error.

If you have no GPU, the project points to a hosted option rather than asking you to wait. The TabPFN Client repository is described as a simple API client for using TabPFN via cloud-based inference. That moves your data off your machine, which is a different decision than a performance one.

Class count is another boundary. The core package has a built-in class limit, and the extensions repository includes a many_class module for multi-class problems that exceed it. That the workaround lives in a separate package tells you the core model was not designed for wide label spaces.

There is also a dependency worth flagging. The project caps skrub below 0.11 with an inline comment that skrub is pre-1.0 and its minor releases change transformer behavior. That is a maintainer acknowledging a real compatibility hazard, and it means a future skrub release will not land in your environment until the cap moves.

Licence: the code and the weights are not the same deal

This is the part that decides most commercial adoptions, and it is easy to miss because the package installs without asking.

The pyproject.toml declares license = "Apache-2.0" and includes LICENSE, NOTICE, and THIRD-PARTY-NOTICES.md as license files. The README then separates code from weights. The TabPFN-2.5, TabPFN-2.6, and TabPFN-3 model weights are released under non-commercial licenses, with TabPFN-3 used by default. The code and the TabPFN-2 model weights fall under the Prior Labs License, described as Apache 2.0 with an additional attribution requirement.

So the default path, TabPFNClassifier() with no arguments, pulls TabPFN-3 weights under a non-commercial licence. If you need commercial use, the README points to an Enterprise Edition with a Commercial Enterprise License, dedicated integration support, and a proprietary distillation engine that converts TabPFN into a compact MLP or tree ensemble for lower latency. Contact is [email protected]. There is also a v2 weights path via ModelVersion.V2 under the attribution-bearing licence.

This is not legal advice, and the README does not spell out what counts as commercial for every jurisdiction. If your use case is commercial, read the licence file linked from the Hugging Face model page before you ship, and decide whether the attribution requirement on v2 or an enterprise agreement fits better than the default.

TabPFN Extensions and the hosted client as alternatives

The most direct alternative to running this repository is the TabPFN Client, which the README recommends for users without a GPU. The difference is architectural, not cosmetic: local inference runs the transformer on your hardware and your data never leaves the machine, while the client sends inference to cloud infrastructure. For a team with a GPU, local is the default. For a team without one, or one that wants to avoid checkpoint downloads and CUDA setup, the client removes that work at the cost of a network dependency.

A second alternative is the extensions package, which is a different kind of answer. Installing it adds interpretability (SHAP-based explanations, feature importance, selection), unsupervised tools for outlier detection and synthetic data generation, embeddings extraction, and the many_class handler. These are not competitors to the core model; they are the capabilities the core package leaves out. If your workflow needs feature attribution, you are installing tabpfn-extensions, not just tabpfn.

A third option the ecosystem page lists is TabPFN UX, a no-code graphical interface aimed at business users and prototyping. That is a different audience entirely, and it is worth naming so that a reader looking for a GUI does not try to build one on top of the Python API.

Maintenance status and upgrade cost

The repository is not archived, and the last push was on 2026-09-10. Recent releases include v8.5.0 on 2026-08-27, v8.4.0 on 2026-08-19, and v8.3.0 on 2026-08-13, with a changelog directory and CHANGELOG.md in the tree. Release cadence has been roughly weekly across the versions listed, which means the upgrade surface is real: pin your version in production rather than tracking the latest release.

The dependency list is the main upgrade cost. torch>=2.5, scikit-learn>=1.2.0, pandas>=1.4.0, lightgbm>=4.4, and the skrub cap all interact. A torch upgrade on a CUDA machine can force a reinstall of the whole stack. The optional wandb extra is separate, so experiment tracking does not bloat the base install unless you ask for it.

Model versioning is the other cost. Because the default changed from TabPFN-2.6 to TabPFN-3, code that relied on the default silently changed behaviour across a release. Pinning through ModelVersion in your own code is the only way to make that explicit, and the README shows the pattern for V2_6 and V2.

Editorial conclusion

Adopt TabPFN if your tables are small, your labels are scarce, and you want a classifier or regressor running in one forward pass without a training loop; the pip package plus a GPU gets you there today. Do not adopt it if you need commercial use of the default weights, if your tables exceed roughly 5000 samples on CPU or 16GB of VRAM, or if you need time-series or unsupervised pipelines from the core package. Verify three things before committing: which model version your code instantiates, what the licence on that version's weights permits for your use case, and whether the hosted client is an acceptable substitute for local inference.

Frequently asked questions

Official sources

1. Issues
2. PriorLabs/TabPFN on GitHub
3. Project website
4. README
5. Releases