TabPFN Client

TabPFN is a foundation model for tabular data that outperforms traditional methods while being dramatically faster. This client library provides easy access to the TabPFN API, enabling state-of-the-art tabular machine learning in just a few lines of code.

Interactive Notebook Tutorial

[!TIP]

Dive right in with our interactive Colab notebook! It's the best way to get a hands-on feel for TabPFN, walking you through installation, classification, and regression examples.

✅ Stable Release

This API is now in a stable release. It has been extensively tested and is used across multiple use cases. While we continue to make improvements, the core service is reliable for day-to-day use. Please reach out to us if you encounter any stability issues.

This is a cloud-based service: your data will be sent to our servers for processing.

Please only upload data you have permission to share, and avoid sensitive, confidential, or personally identifiable information. Consider anonymizing or pseudonymizing your data in line with your organization’s policies.

🌐 TabPFN Ecosystem

Choose the right TabPFN implementation for your needs:

• TabPFN Client (this repo): Easy-to-use API client for cloud-based inference
• TabPFN Extensions: Community extensions and integrations
• TabPFN: Core implementation for local deployment and research
• TabPFN UX: No-code TabPFN usage

🏁 Quick Start

Installation

bash pip install tabpfn-client

Basic Usage

```python from tabpfnclient import init, TabPFNClassifier, TabPFNRegressor from sklearn.datasets import loadbreastcancer from sklearn.modelselection import traintestsplit

Load an example dataset

X, y = loadbreastcancer(returnXy=True) Xtrain, Xtest, ytrain, ytest = traintestsplit(X, y, testsize=0.5, randomstate=42)

Use it like any sklearn model

model = TabPFNClassifier() model.fit(Xtrain, ytrain)

Get predictions

predictions = model.predict(X_test)

Get probability estimates

probabilities = model.predictproba(Xtest) ```

Best Results

For optimal performance, use the AutoTabPFNClassifier or AutoTabPFNRegressor for post-hoc ensembling. These can be found in the TabPFN Extensions repository. Post-hoc ensembling combines multiple TabPFN models into an ensemble.

🔑 Authentication

Load Your Token

python import tabpfn_client token = tabpfn_client.get_access_token()

and login (on another machine) using your access token, skipping the interactive flow, use:

python tabpfn_client.set_access_token(token)

🤝 Join Our Community

We're building the future of tabular machine learning and would love your involvement! Here's how you can participate and get help:

1. Try TabPFN: Use it in your projects and share your experience
2. Connect & Learn:
   • Join our Discord Community for discussions and support
   • Read our Documentation for detailed guides
   • Check out GitHub Issues for known issues and feature requests
3. Contribute:
   • Report bugs or request features through issues
   • Submit pull requests (see development guide below)
   • Share your success stories and use cases
4. Stay Updated: Star the repo and join Discord for the latest updates

📊 Usage Limits

API Cost Calculation

Each API request consumes usage credits based on the following formula:

python api_cost = (num_train_rows + num_test_rows) * num_cols * n_estimators

Where n_estimators defaults to:

• 4 for classification tasks
• 8 for regression tasks

Per day the current prediction allowance is 5,000,000 cells. We will adjust this limit based on usage patterns.

Monitoring Usage

Track your API usage through response headers:

• X-RateLimit-Limit: Your total allowed usage
• X-RateLimit-Remaining: Remaining usage
• X-RateLimit-Reset: Reset timestamp (UTC)

Usage limits reset daily at 00:00:00 UTC.

Size Limitations

1. Maximum total cells per request must be below 500,000:

python max_cells = (num_train_rows + num_test_rows) * num_cols

1. For regression with full output (return_full_output=True), the number of test samples must be below 500:

python if task == 'regression' and return_full_output and num_test_samples > 500: raise ValueError("Cannot return full output for regression with >500 test samples")

These limits will be increased in future releases.

Access/Delete Personal Information

You can use our UserDataClient to access and delete personal information.

```python from tabpfn_client import UserDataClient

print(UserDataClient.getdatasummary()) ```

📚 Citation

```bibtex @article{hollmann2025tabpfn, title={Accurate predictions on small data with a tabular foundation model}, author={Hollmann, Noah and M{\"u}ller, Samuel and Purucker, Lennart and Krishnakumar, Arjun and K{\"o}rfer, Max and Hoo, Shi Bin and Schirrmeister, Robin Tibor and Hutter, Frank}, journal={Nature}, year={2025}, month={01}, day={09}, doi={10.1038/s41586-024-08328-6}, publisher={Springer Nature}, url={https://www.nature.com/articles/s41586-024-08328-6}, }

@inproceedings{hollmann2023tabpfn, title={TabPFN: A transformer that solves small tabular classification problems in a second}, author={Hollmann, Noah and M{\"u}ller, Samuel and Eggensperger, Katharina and Hutter, Frank}, booktitle={International Conference on Learning Representations 2023}, year={2023} } ```

🤝 License

This project is licensed under the Apache License 2.0 - see the LICENSE.txt file for details.

Development

To encourage better coding practices, ruff has been added to the pre-commit hooks. This will ensure that the code is formatted properly before being committed. To enable pre-commit (if you haven't), run the following command:

bash pre-commit install

Additionally, it is recommended that developers install the ruff extension in their preferred editor. For installation instructions, refer to the Ruff Integrations Documentation.

Build from GitHub

bash git clone https://github.com/PriorLabs/tabpfn-client cd tabpfn-client git submodule update --init --recursive pip install -e . cd ..

NOTE: For development, you will need to download some additional dev dependencies. Use the below command to get it ready for development and running tests.

bash pip install -e ".[dev]"

Release

1. First ensure you've bumped the version in pyproject.toml. Use an rc suffix until you're sure it works. Something like x.y.zrc1.

2. Build, upload to the test PyPI, install and run a quick test.

bash rm -rf .venv_test dist python3 -m pip install --upgrade build && python3 -m build python3 -m pip install --upgrade twine && python3 -m twine upload --repository testpypi dist/* python3 -m venv .venv_test && source .venv_test/bin/activate python3 -m pip install --pre --index-url https://test.pypi.org/simple/ --no-deps tabpfn-client pip install -r requirements.txt python tabpfn_client/tests/quick_test.py deactivate

1. Correct the version. Ideally this should be what is in main. It shouldn't have an rc suffix unless we're doing broader pre-release testing.

2. Build, upload to the real PyPI, install and run a quick test.

bash rm -rf .venv_test dist python3 -m pip install --upgrade build && python3 -m build python3 -m pip install --upgrade twine && python3 -m twine upload --repository pypi dist/* python3 -m venv .venv_test && source .venv_test/bin/activate python3 -m pip install --pre tabpfn-client python tabpfn_client/tests/quick_test.py deactivate