--- title: Quick Start --- TanStack Table is a headless table library. It manages your table's state and logic (sorting, filtering, pagination, selection, and more) while you keep 100% control over the markup and styles. This page gets you from install to a rendering React table, then shows how to layer on your first feature. ## Installation ```bash npm install @tanstack/react-table ``` ## Your First Table The component below is complete. Paste it into a React app and you will see a working table. ```tsx import { tableFeatures, useTable } from '@tanstack/react-table' import type { ColumnDef } from '@tanstack/react-table' // 1. Define the shape of your data type Person = { firstName: string lastName: string age: number } // 2. Give your data a stable reference (module scope, useState, useQuery, etc.) const data: Array = [ { firstName: 'tanner', lastName: 'linsley', age: 24 }, { firstName: 'tandy', lastName: 'miller', age: 40 }, { firstName: 'joe', lastName: 'dirte', age: 45 }, ] // 3. New in v9: declare which features this table uses (none yet) const features = tableFeatures({}) // 4. Define your columns const columns: Array> = [ { accessorKey: 'firstName', // accessorKey shorthand header: 'First Name', cell: (info) => info.getValue(), }, { accessorFn: (row) => row.lastName, // accessorFn alternative with a custom id id: 'lastName', header: () => Last Name, cell: (info) => {info.getValue()}, }, { accessorKey: 'age', header: () => 'Age', }, ] export function PersonTable() { // 5. Create the table instance const table = useTable({ key: 'person-table', // needed for devtools, omit if you don't want to use the devtools features, columns, data, }) // 6. Render markup from the table instance APIs return ( {table.getHeaderGroups().map((headerGroup) => ( {headerGroup.headers.map((header) => ( ))} ))} {table.getRowModel().rows.map((row) => ( {row.getAllCells().map((cell) => ( ))} ))}
{header.isPlaceholder ? null : ( )}
) } ``` A few things to note: - `tableFeatures({})` declares which optional features the table uses. Registering only what you need keeps bundles small and gives TypeScript accurate types for the table instance. - The core row model is always included automatically. Feature row models (sorting, filtering, pagination) are registered as slots on the features object when you need them. - `table.FlexRender` renders the `header`, `cell`, and `footer` definitions from your columns, whether they are plain values or React components. - The `key` option is optional unless you use the [TanStack Table Devtools](../../devtools). The devtools identify tables by `key`, and you register a table by calling `useTanStackTableDevtools(table)` from `@tanstack/react-table-devtools`. See the full [Basic useTable example](./examples/basic-use-table) for a runnable version with more columns and a footer. ## Add a Feature: Sorting Features are opt-in in v9. To make columns sortable, register `rowSortingFeature` and the sorted row model in `tableFeatures`, then wire the header click handler. ```tsx import { createSortedRowModel, rowSortingFeature, sortFns, tableFeatures, useTable, } from '@tanstack/react-table' const features = tableFeatures({ rowSortingFeature, // enables sorting APIs and state sortedRowModel: createSortedRowModel(), // client-side sorting sortFns, }) export function PersonTable() { const table = useTable({ key: 'person-table', features, columns, data, }) return ( {table.getHeaderGroups().map((headerGroup) => ( {headerGroup.headers.map((header) => ( ))} ))} {/* tbody unchanged from above */}
{header.isPlaceholder ? null : (
{{ asc: ' 🔼', desc: ' 🔽', }[header.column.getIsSorted() as string] ?? null}
)}
) } ``` Clicking a header now toggles between ascending, descending, and unsorted. Every other feature follows this same pattern: register the feature and its row model factory (if it has one) in `tableFeatures`, then use the APIs it adds to the table, columns, and rows. See the [Sorting Guide](./guide/sorting) and the [Sorting example](./examples/sorting) for custom sort functions, multi-sorting, and per-column options. ## Where to Go Next **Table state.** In v9, table state is backed by TanStack Store atoms. You usually do not need to manage it yourself: set `initialState` for starting values and call feature APIs like `table.setSorting(...)` or `table.nextPage()`. When your app should own a state slice, or you want fine-grained subscriptions, read the [Table State Guide](./guide/table-state). It is the foundational guide for everything else. **Feature guides.** Each feature has its own guide, such as [Column Filtering](./guide/column-filtering), [Pagination](./guide/pagination), [Row Selection](./guide/row-selection), and [Column Visibility](./guide/column-visibility). **Composable tables.** When multiple tables in your app share features, row models, and component conventions, define them once with `createTableHook`: ```tsx const features = tableFeatures({ rowSortingFeature, sortedRowModel: createSortedRowModel(), sortFns, }) const { useAppTable, createAppColumnHelper } = createTableHook({ features }) ``` See the [Composable Tables Guide](./guide/composable-tables) for the full pattern, including pre-bound cell and header components. **Examples.** Browse the runnable [React examples](./examples/basic-use-table), from basic tables to feature demos, to see intended usage end to end.