# streamlit-aggrid, a real data grid inside a Streamlit app

> streamlit-aggrid wraps the Ag-Grid web component for Streamlit, so a Streamlit app can show a grid with sorting, filtering, editing and cell renderers, and get the edited rows back as a Python object. It is maintained by one developer, it carries a JavaScript build next to the Python package, and its 2.0 line is still a release candidate.

**PablocFonseca/streamlit-aggrid** — Implementation of Ag-Grid component for Streamlit

- Repository: https://github.com/PablocFonseca/streamlit-aggrid
- Website: https://pypi.org/project/streamlit-aggrid/
- Stars: 1,297 · Forks: 224
- Language: Python
- License: MIT
- Published: 2026-10-19 · Updated: 2026-10-19 · Language: en
- Canonical page: https://hysenlabs.com/projects/pablocfonseca-streamlit-aggrid

## Why a Streamlit app needs a grid component at all

Streamlit's built in dataframe widget is a table. streamlit-aggrid exists because a lot of applications need a grid instead, and the project description says it plainly, an implementation of the Ag-Grid component for Streamlit. The upstream Ag-Grid is described as a grid for the web frontend, and the current AgGrid version carried by the package is 34.3.1, which the documentation links to the vendor's archive. What the component brings is the Ag-Grid feature set inside a Streamlit app, so sorting, filtering, row selection, cell editing, sparklines and custom cell renderers become available without leaving the Python script. The audience is a Python data person who has moved past the exploration stage and needs the grid to be part of an application, and the vendor note in the README is a reminder that the enterprise features of Ag-Grid are a paid product, not part of this package.

## Install and first render

The install is a single pip command, and the package is on PyPI.

```bash
pip install streamlit-aggrid
```

The quick use example is four lines of Python, and the data is an ordinary pandas DataFrame.

```python
from st_aggrid import AgGrid
import pandas as pd

df = pd.read_csv('https://raw.githubusercontent.com/fivethirtyeight/data/master/airline-safety/airline-safety.csv')
AgGrid(df)
```

The app is then run with the standard Streamlit command.

```bash
streamlit run example.py
```

The component renders the DataFrame as a grid, and the README also points to live examples hosted on Streamlit Cloud and to a separate examples repository in the tree. The examples matter more than usual for a component like this, because the interesting behaviour is in the interaction between the grid and the Python session rather than in the first render, and the hosted demos are the fastest way to see the editing, selection and event handling before writing any of it yourself.

## Grid data comes back to Python

The point of the component is that the grid is not a dead end. The README says grid data is sent back to Streamlit and can be reused in other components, and the demo shows a chart that updates when the grid is edited. The return object has changed shape more than once, and the current design is a dataclass, GridReturn, with rowIndex added to the selected rows, so that the earlier version returned only the selected data and now you can know which row was selected. The update_on parameter accepts a list of grid events that will trigger a Streamlit refresh, which makes it possible to subscribe to any grid event, and the GridUpdateMode name was deprecated in favour of it. Version 1.2.0 added the server_sync_strategy parameter to control the data synchronisation between server and client, and the try_to_convert_back_to_original_types behaviour was deprecated, since the grid now always tries to keep proper datatypes when editing data. A team upgrading across these versions has to read the changelog, because the return object is a different shape.

## The 1.1.8 refactor moved the work to the Python side

The development notes in the README read as a change log with the reasoning left in, and the 1.1.8 entry is the one that reshaped the library. It is described as a major refactor that introduced a collector based architecture for grid data return processing, with a new DataReturnMode.CUSTOM that allows custom JavaScript data collection logic. Data is now transferred using Streamlit's ArrowTable protobuf, which the entry lists as an improvement to data serialization and handling of complex data types, and the entry also claims enhanced performance for large datasets through optimised data processing, plus a comprehensive test suite for grid return functionality. The 1.0.2 entry says the same thing in shorter form, that a lot of response processing moved to the Python side. The tradeoff is visible in the 1.0.0 warning, where the author says that version broke compatibility with previous versions and that many people reported it as unstable, and advises using the last 0.3.4 release if things are not working.

## The Ag-Grid licence question, and the enterprise modules

The licensing situation is documented rather than hidden, and it has already caused a bug. Version 1.1.3 fixed enterprise modules being enabled by default, and the entry notes that if you are using enterprise features you should buy a licence from Ag Grid. The README is equally direct, that you should consider purchasing a licence from Ag-Grid if you are going to use enterprise features. A related entry, 1.1.5, fixes licensing when not using the licence bundled with AgCharts, which suggests the interaction between the grid, the charts module and the vendor licence key has needed attention more than once. For an evaluator, the practical point is that the component is MIT licensed and free to install, but the grid inside it is Ag-Grid, and a team that depends on the enterprise feature set needs a commercial agreement with the vendor. Everything else in the package, the Streamlit glue, the data return handling and the frontend build, is covered by the MIT terms.

## A Python package with a JavaScript build attached

The repository is a hybrid, and the packaging reflects it. The Python side is the st_aggrid package, built with poetry-core, and the pyproject file declares the project as streamlit-aggrid version 1.2.0-2, requiring Python 3.10 or later with streamlit 1.2 or later, pandas 1.4.0 or later and python-decouple as runtime dependencies. The JavaScript side is a yarn workspace, with the package manager pinned at yarn 4.1.0 and the workspace glob pointing at the frontend directories inside st_aggrid, and the build script runs the yarn workspaces build and then the poetry build. There is a resolutions entry that pins the Apache Arrow package used by the Streamlit component library to 9.0.0, which is the kind of pin that matters for a component that ships its own frontend. The development dependencies are pytest with playwright and pytest-playwright, plus watchdog and ruff, which says the component is tested through a real browser. One inconsistency is worth flagging, since an old setup.py is still in the tree with version 0.2.1 and a different dependency list including simplejson and numpy, so the pyproject file is the one to trust.

## A 2.0 release candidate and a single maintainer

The release history shows a project that is active but small. The tags are 1.1.8 from 2025-07-27, 1.2.0 from 2025-10-20 and v2.0.0rc1 from 2026-07-09, and the last push was on 2026-08-18, so the 2.0 line is in release candidate and the branch is still moving. The README asks directly for support, describing the project as the result of countless hours of dedication by a solo Python developer, and pointing at a PayPal donation link and an email address for sponsorship and feature prioritisation. That is the honest picture for an adopter. A component library that wraps a fast moving vendor grid, with a data return path that has been redesigned twice in a year and a 2.0 candidate in flight, benefits from an author who is paid to care about it, and the alternative is maintaining your own fork of the component. The licence is MIT, the package is on PyPI as streamlit-aggrid, and the source is in the repository, so the exit path exists if you need one.

## Conclusion

streamlit-aggrid fits a Streamlit developer who has outgrown st.dataframe and needs editing, sorting, filtering and selection that come back as Python data, and it fits a team that already uses Ag-Grid elsewhere and wants the same grid in a Streamlit app. It does not fit a team that needs enterprise grid features without buying an Ag-Grid licence, since the enterprise modules are not free, and it does not fit a production app that needs a stable API, since the 2.0 line is still a release candidate. Verify three things first: whether your use needs the enterprise features, which are paid for, which version you pin, since the 1.0 release broke compatibility and the 2.0 release candidate should not be treated as stable, and how your Streamlit version interacts with the Arrow transport, since the data path changed when the collector based architecture and the ArrowTable protobuf arrived in 1.1.8.

## FAQ

### What does streamlit-aggrid do?

It is an implementation of the Ag-Grid component for Streamlit, so a Streamlit app can render an Ag-Grid table with sorting, filtering, editing and selection, and the grid data is sent back to Streamlit and can be reused in other components. The AgGrid version carried by the package is 34.3.1.

### How do I install and use streamlit-aggrid?

Install it with pip install streamlit-aggrid, then import AgGrid from st_aggrid, pass it a pandas DataFrame with AgGrid(df), and run the script with streamlit run example.py.

### Do the enterprise features of Ag-Grid cost money in streamlit-aggrid?

Yes. The README says to consider purchasing a licence from Ag-Grid if you are going to use enterprise features, and the 1.1.3 release notes record a fix for enterprise modules being enabled by default. The streamlit-aggrid package itself is MIT licensed.

### What changed in the streamlit-aggrid 2.0 line?

The 2.0.0 release candidate follows the 1.1.8 major refactor, which introduced a collector based architecture for grid data return processing, a DataReturnMode.CUSTOM for custom JavaScript collection logic, and a data transport using the Streamlit ArrowTable protobuf. The 1.0.0 release previously broke compatibility with earlier versions, and the author advises pinning a known good release such as 0.3.4 if issues appear.

## Sources

- [License: MIT](https://github.com/PablocFonseca/streamlit-aggrid/blob/main/LICENSE)
- [PablocFonseca/streamlit-aggrid on GitHub](https://github.com/PablocFonseca/streamlit-aggrid)
- [Project website](https://pypi.org/project/streamlit-aggrid/)
- [README](https://github.com/PablocFonseca/streamlit-aggrid/blob/main/README.md)
- [Releases](https://github.com/PablocFonseca/streamlit-aggrid/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/pablocfonseca-streamlit-aggrid