Build Feature-Rich Data Tables in React with Material-Table

Table of Contents

If you’re a React developer and constantly work with data, displaying it in a clear, manageable way is crucial. That’s where Material-Table comes in. This powerful library streamlines the process of building feature-rich tables in your React applications. Let’s dive into understanding what it is, why you should consider using it, and how to effectively implement it in your projects.

What is Material-Table?

Material-Table is a React component library built on top of Material-UI, Google’s popular design system. It provides a comprehensive set of pre-designed components and functionalities for creating highly customizable and interactive data tables within your React applications. Whether you need to display simple lists or complex datasets with actions like editing and deleting, Material-Table has you covered.

Why use Material-Table for your React projects?

Here are some compelling reasons to choose Material-Table:

  • Feature-rich: It goes beyond basic data display, offering features like:
    • Sorting
    • Filtering
    • Pagination
    • Row selection
    • Editing
    • Custom actions
  • Material Design Integration: Material-Table adheres to Material Design principles, ensuring a visually appealing and familiar user interface for your web applications.
  • Highly Customizable: You have extensive control over the appearance and behavior of your tables, allowing you to tailor them perfectly to your project’s requirements.
  • Time-saver: Let Material-Table handle the complexities of table creation. You can focus more on your application’s core logic.
  • Excellent Documentation: Clear and comprehensive documentation with examples makes it easy to learn and troubleshoot.

Setting Up Your React Project

Installing Material-Table

Let’s start by adding Material-Table to your existing React project. You’ll need Node.js and npm (or yarn) installed. Execute the following command in your project’s terminal:


npm install @material-table/core

Since Material-Table relies on Material-UI, you’ll also need to install those dependencies if you haven’t already:


npm install @mui/material @emotion/react @emotion/styled

Basic setup and configuration

The basic import for Material-Table looks like this:


import MaterialTable from '@material-table/core';

Let’s illustrate a simple Material-Table implementation:


import React from 'react'; import MaterialTable from '@material-table/core'; const data = [ { name: 'John', surname: 'Smith', age: 32 }, { name: 'Sarah', surname: 'Connor', age: 25 }, ]; const columns = [ { title: 'Name', field: 'name' }, { title: 'Surname', field: 'surname' }, { title: 'Age', field: 'age', type: 'numeric' }, ]; function App() { return ( <MaterialTable title="User Data" columns={columns} data={data} /> ); } export default App;

In this example, data is an array of objects, columns defines the structure of your table, and the MaterialTable component renders the table.

Understanding Material-Table Components and Props

Overview of Material-Table components

The core component is MaterialTable. Additional components help build out more complex features:

  • MTableToolbar: A customizable toolbar for search, filtering, and other actions.
  • MTableBodyRow: Represents a single table row.
  • MTableCell: Represents an individual table cell.

Key props for customizing tables

Material-Table offers numerous props. Some of the most important include:

  • title: Sets the table’s title.
  • columns: An array defining column headers, data fields, and other properties.
  • data: The data source for your table.
  • options: Controls actions like sorting, filtering, paging, etc.
  • actions: For specifying custom button actions in rows.
  • editable: Enables in-line editing.

Rendering Buttons in Material-Table

Adding action buttons to rows

Material-Table lets you add action buttons to individual rows, enabling users to take actions on specific data items. This is done through the actions prop. Here’s how:


// Inside the <MaterialTable> component actions={[ { icon: 'delete', // Use a Material-UI icon or a custom component tooltip: 'Delete User', onClick: (event, rowData) => handleDelete(rowData) } ]}

  • icon: Specifies the icon to display on the button (refer to Material-UI icons for options).
  • tooltip: Provides a tooltip on hover.
  • onClick: Defines a callback function triggered when the button is clicked.

Customizing button appearance and behavior

You can further customize your action buttons:


actions={[ { icon: 'edit', tooltip: 'Edit User', onClick: (event, rowData) => handleEdit(rowData), color: 'primary', // From Material-UI's color system position: 'row', // Control button position within the row } ]}

Integrating Material-UI Icons with Buttons

Using Material-UI icons in buttons

Material-UI offers a vast library of icons. To use them in your buttons, import the desired icons:


import DeleteIcon from '@mui/icons-material/Delete';
import EditIcon from '@mui/icons-material/Edit';

Then, simply reference the imported icon within the icon prop:


actions={[ { icon: DeleteIcon, tooltip: 'Delete User', onClick: (event, rowData) => handleDelete(rowData) } ]}

Styling and positioning icons within buttons

While Material-Table makes it easy to include icons, here’s how to go beyond basic customization:

  • Icon Size: Control icon size directly or inherit button sizing:

    // Direct sizing <EditIcon style={{ fontSize: 30 }} /> // Inherit via CSS .MuiIconButton-root { font-size: 24px; }
  • Icon Color: Leverage Material-UI theming or inline styles:
    // Theme approach (in your theme) palette: { primary: { main: '#E91E63', // Bold pink } } // Inline Style <DeleteIcon style={{ color: 'red' }} />
  • Hover and Focus States: Provide visual feedback with styles:
    .MuiIconButton-root:hover { background-color: rgba(0, 0, 0, 0.08); /* Subtle background on hover */ }
  • Icon-Only Buttons: For standalone icon buttons, consider customizing size and padding to refine the visual appearance:
    .MuiIconButton-root { padding: 8px; /* Adjust as needed */ }

Precision Positioning of Icons

  • Margins and Padding: Use CSS margins or padding to fine-tune the spacing around your icons within buttons.
  • Vertical Alignment: Ensure icons are visually centered within buttons. Techniques include:
    • Line-height: Set line-height on the icon element to match the button’s height.
    • Flexbox: Use display: flex, align-items: center on the button container.
    • Negative Margins: Employ small negative margins to adjust icon position slightly.
  • Position within Row: The position prop on the actions object lets you control icon button placement:
    • position: "row" – Places the button beside row data.
    • position: "toolbar" – Places the button on the toolbar.
    • position: "toolbarOnSelect" – Shows the button on the toolbar only when a row is selected.

Example: Creating a “Compact” Edit Button


import EditIcon from '@mui/icons-material/Edit'; // Within your actions configuration { icon: () => <EditIcon style={{ fontSize: 16 }} />, // Smaller icon tooltip: 'Edit', onClick: ..., position: 'row', className: 'compact-edit-button' // For additional styling } // CSS for compact styling .compact-edit-button { padding: 4px; /* Reduced padding */ }

Advanced Layout Considerations

  • Multiple Icons per Button: Utilize flexbox or grid layouts within your button container to arrange multiple icons in a visually pleasing manner.
  • Responsive Considerations: Ensure your icon and button layouts adapt well to different screen sizes using appropriate media queries.


  • Browser Dev Tools: Your best friend for fine-tuning styles and positioning.
  • Specificity: Understand CSS specificity rules when overriding default styles.

Implementing Custom Action Handlers

Handling button clicks

The onClick callback in the actions prop receives the event and rowData (data of the clicked row), letting you perform necessary actions:


function handleDelete(rowData) { // Implement logic to delete the data item represented by rowData // Update the table data after successful deletion }

Passing row data to action handlers

Why Pass Row Data to Action Handlers

The ability to access the complete data object of the row where an action button is clicked opens up several possibilities:

  • Contextual Actions: Make buttons smarter—their behavior can change depending on the specific data in the row. For example, an “Approve” button that’s only enabled if the status field of a row is “Pending”.
  • Dynamic Updates: Update other parts of your UI based on the row data. For instance, after a successful delete action, remove the corresponding item from a separate list without a full page refresh.
  • Opening Dialogs/Modals: Pre-populate forms for editing or viewing detailed information based on the row that triggered the action.
  • External Actions: Initiate actions outside of Material-Table, such as sending emails, triggering API calls, or redirecting the user to another page, all with the relevant row data in hand.

Understanding rowData

Within your action handler’s onClick callback, the rowData parameter represents the entire data object associated with the row where the button was clicked. This object’s structure mirrors the data you provide to the Material-Table component.

Example: Delete with Confirmation

Let’s enhance our previous delete example to showcase rowData in action:


function handleDelete(rowData) { if (confirm(`Are you sure you want to delete ${}?`)) { // Implementation of delete logic using or other relevant fields } } // Inside your MaterialTable component actions={[ { icon: DeleteIcon, tooltip: 'Delete User', onClick: (event, rowData) => handleDelete(rowData) } ]}

Beyond Basic Actions

  • Pre-populating Forms:


function handleEdit(rowData) { // Open a modal or dialog openModal(rowData); // Pass rowData to the modal component }

  • Custom API Calls


function handleStatusChange(rowData) { const newStatus = // ... determine the new status fetch(`/api/update-status/${}`, { method: 'POST', body: JSON.stringify({ status: newStatus }), // ... headers, etc. }) .then(...) // Handle API response }

Important Considerations

  • Updating Table State: Remember that after making changes based on row data (especially with server-side interactions), you’ll likely need to update the Material-Table’s state to reflect those changes.
  • Performance: When dealing with actions that involve complex logic or external calls, consider strategies like offloading work to background processes or displaying loading indicators to maintain a responsive UI.

Advanced Use Cases

  • Chaining Actions: Based on the result of one action, potentially trigger another action on the same row data.
  • Batch Operations: Select multiple rows and build custom buttons to perform actions on the aggregated rowData of all selected rows.

Enhancing Table Functionality with Buttons

Let’s see how buttons enable common table actions!

Implementing delete functionality


function handleDelete(rowData) { const newData = data.filter(item => !==; // Example deletion setData(newData); } // Inside your MaterialTable component actions={[ { icon: DeleteIcon, tooltip: 'Delete User', onClick: (event, rowData) => handleDelete(rowData) } ]}

Adding edit functionality through modal forms


function handleEdit(rowData) {
  // Open a modal dialog with an edit form, populated with rowData 

Using Material-Table’s Editable Feature

Configuring editable rows

Material-Table offers built-in editing support:


<MaterialTable // ... other props editable={{ onRowUpdate: (newData, oldData) => handleRowUpdate(newData, oldData), onRowAdd: (newData) => handleRowAdd(newData), onRowDelete: (oldData) => handleRowDelete(oldData) }} />

  • onRowUpdate: Handles updated row data.
  • onRowAdd: Handles new row creation.
  • onRowDelete: Handles row deletion.

Customizing the edit and save actions

Why Customize Edit and Save Actions?

Material-Table’s built-in inline editing is excellent for basic use cases, but often you’ll want to go beyond the default:

  • Complex Forms: Create richer editing interfaces with multiple input types, validation, and conditional logic.
  • External Data Integration: Fetch and prepopulate values from related sources or update other parts of your application during the edit and save process.
  • Workflows: Introduce multi-step editing processes or approval stages.
  • Custom UI: Design editing experiences that seamlessly match your application’s look and feel, going beyond simple table cells.

Techniques for Customization

Material-Table’s editable property gives you several hooks to customize editing behavior:

1. Customizing Inline Editing

  • onRowUpdate: For modifying data directly during edits without a modal. Consider this for simple edits or if you want a lightning-fast editing experience.


<MaterialTable // ...other props editable={{ onRowUpdate: (newData, oldData) => new Promise((resolve, reject) => { // Validate newData for specific rules // ... // Update data (either in state or send to API) // ... resolve(); //Signal successful edit }) }} />

  • render Function for Cells: While not directly edit-related, you can use the render function within your column definitions to display custom inputs or controls while a cell is in edit mode.

2. Modal-Based Editing

  • onRowUpdate and onRowAdd: Use these callbacks to open a dialog or modal when a row enters edit mode or a new row is added. These callbacks receive newData and oldData, allowing you to prepopulate your form.
  • Custom Save Actions: Implement your save logic within the modal. This gives you full flexibility over the form structure, validation, and how data updates are handled upon saving.

3. Completely Custom Edit Components

For maximum control, you can substitute Material-Table’s default editing components with your own using the components prop:


<MaterialTable // ... other props components={{ EditRow: props => ( // Implement your custom editing interface here // Access row data via ) }} />

Example: Modal Editing with External Data


// Inside editable configuration onRowUpdate: (newData, oldData) => new Promise((resolve, reject) => { // Fetch additional data for the row if needed fetch(`/api/details/${}`) .then(res => res.json()) .then(details => { openModal({ ...newData, details }); resolve(); }) })

Key Considerations

  • UI Libraries: Consider integrating with form libraries like React Hook Form or Formik for easier form management and validation.
  • Data Consistency: Implement robust error handling and syncing mechanisms, especially if you’re making server-side updates.
  • Accessibility: Ensure your custom edit components and modals are accessible to users with disabilities.

Sorting and Filtering Table Data

Enabling and customizing sorting

Material-table provides built-in sorting capabilities. To activate it, simply set the sorting property to true within your options prop:


<MaterialTable // ... other props options={{ sorting: true }} />

Now, clicking on column headers will cycle through ascending, descending, and no sorting. You can customize the initial sort order and more:


options={{ sorting: true, initialSortBy: 'name', // Column to sort by initially sortingOrder: ['desc', 'asc'] // Initial sorting order (cycles) }}

Implementing custom filter components

While Material-Table has a basic search field, sometimes you need more complex filtering logic. You can override the default filtering behavior using the components prop:


const CustomFilter = (props) => { // Implement your custom filter component here // Example: a filter that searches multiple fields simultaneously }; <MaterialTable // ... other props components={{ FilterRow: props => <CustomFilter {...props} /> }} />

Remember to manage how the filtered data is applied to your table.

Pagination and Data Management

Configuring pagination options

When dealing with large datasets, pagination becomes indispensable. Control pagination behavior within the options prop:


options={{ paging: true, pageSize: 10, // Items per page pageSizeOptions: [5, 10, 20] // Options for the user to choose }}

Managing large datasets with server-side operations

Why Server-Side Operations Matter

When your datasets grow beyond a manageable size for the browser, these techniques become crucial:

  • Performance: Client-side rendering and manipulation of massive datasets lead to sluggishness, slow load times, and potential browser crashes.
  • Memory Efficiency: Loading all data into the browser consumes excessive memory, especially on less powerful devices.
  • Scalability: As your dataset continues to grow, client-side limitations become even more pronounced.

How Server-Side Operations Work with Material-Table

Material-Table cleverly integrates by providing callback functions within its options prop:

  • onPageChange: Triggered when the user changes the current page.
  • onPageSizeChange: Triggered when the items-per-page setting is modified.
  • onSearchChange: Triggered when the search term changes.
  • onOrderChange: Triggered when column sorting changes.
  • onColumnDragged (Optional): Triggered when column order changes (if you enable drag-and-drop column reordering)

Inside Your Callbacks

Within these callbacks, you’ll typically do the following:

  1. Construct API Queries: Build dynamic API requests based on pagination info (current page, items per page), sorting parameters (sort column, sort order), and any active search filters.
  2. Fetch Data: Send a request to your backend server, passing the constructed query.
  3. Transform Data: Adapt the response from your server to the format Material-Table expects. Material-Table anticipates a response structure like this: JSON{ "data": [...array of row data...], "page": 0, // Current page number "totalCount": 100 // Total number of items across all pages }
  4. Update Table: Return the transformed data from your callback function. Material-Table will then render the appropriate subset of data.

Example: Basic Server-Side Integration


<MaterialTable // ...other props options={{ paging: true, pageSize: 10, filtering: true, sorting: true, search: true, // ... onPageChange: (newPage) => { fetch(`/api/data?page=${newPage + 1}`) // Adjust according to your API .then(res => res.json()) .then(result => { // Return in the Material-Table format (see above) }); } // Implement similar logic for other callback functions }} />

Beyond the Basics

  • Loading Indicators: Display loading spinners or progress bars while data fetches occur to improve user experience.
  • Debouncing/Throttling: Prevent overwhelming your server with requests if users rapidly change filters or pagination. Introduce slight delays before issuing API calls.
  • Caching: Consider implementing a caching layer (either on the client-side or server-side) to optimize frequently requested data.
  • Backend Optimization:
    • Ensure your database is indexed for columns you’ll be sorting and filtering by.
    • Optimize your API queries for efficient data retrieval.

Advanced Considerations

  • “Infinite Scrolling”: Combine server-side operations with techniques for continuously loading more data as the user scrolls, creating a seamless scrolling experience.
  • Data Virtualization: Couple with libraries like react-virtualized to only render the currently visible rows even within massive datasets. This significantly improves performance.

Styling Material-Table

Customizing table styles with Material-UI themes

Material-UI’s theming system makes it easy to style your Material-Table. Create a Material-UI theme and customize aspects like colors, typography, and spacing:


import { createTheme, ThemeProvider } from '@mui/material/styles'; const myTheme = createTheme({ palette: { primary: { main: '#3f50b5', // Customize primary color }, }, // Other theme customizations }); // In your component <ThemeProvider theme={myTheme}> <MaterialTable // ... other props /> </ThemeProvider>

Overriding default styles for a unique look

For more granular control, override individual component styles using the style prop on table elements or the overrides prop within the options:

JavaScriptoptions={{ overrides: { MTableBodyRow: { backgroundColor: '#f5f5f5', // Example row background } } }}

Performance Optimization Tips

Optimizing render performance in large tables

  • Pagination: Limit the number of rows rendered at once.
  • Virtualization: Libraries like react-virtualized can render only visible rows for massive datasets.
  • Memoization: Use techniques like React’s useMemo to avoid redundant recalculations of table data.

Best practices for data fetching and updating

  • Fetch data efficiently: Consider server-side operations and optimized API calls.
  • Debounce or throttle updates Avoid overwhelming the server with too many update requests for frequent changes.

Advanced Customization Techniques

Implementing custom components within cells

Material-Table’s flexibility allows you to replace standard text cells with custom components, providing richer data display or interaction. Define a custom renderer within your column definition:


columns={[ { title: 'Status', field: 'isActive', render: rowData => ( <Chip color={rowData.isActive ? 'success' : 'error'} label={rowData.isActive ? 'Active' : 'Inactive'} /> ) } ]}

In this example, we use a Material-UI Chip component to visually represent a status field.

Extending Material-Table with custom plugins

While Material-Table offers extensive built-in functionality, sometimes you’ll have unique needs. Fortunately, you can create custom plugins. A plugin is essentially a function that receives the Material-Table instance and can modify its behavior. This technique is powerful for adding features like:

  • Row grouping
  • Column pinning
  • Data export to file formats (CSV, Excel)

Real-world Examples and Case Studies

Showcasing advanced usage scenarios

To grasp the full potential of Material-Table, let’s consider a few real-world use cases:

  1. Admin Dashboard: Create a dashboard where admins can view, edit, and manage user data with sorting, filtering, inline editing, and role-based permission controls using buttons.
  2. Inventory Management System: Build an inventory table with stock level indicators (custom cell rendering), real-time updates, and the ability to trigger re-order actions when stock falls below thresholds.
  3. Project Management: Design a table displaying tasks with progress bars (custom components), dependencies, assignment actions (buttons), and drag-and-drop reordering (plugin).

Lessons learned from complex implementations

Large-scale Material-Table projects often highlight the importance of:

  • Performance Optimization: Especially with huge datasets or frequent updates.
  • Data Structure: Structuring data for optimal rendering and manipulation.
  • Clear Documentation: If building custom plugins or complex features.

Troubleshooting Common Issues

Solving common problems with Material-Table

Here are some common issues and how to address them:

  • Unresponsive Table: Check pagination, enable virtualization, or optimize data fetching.
  • Data Update Not Reflecting: Make sure state updates trigger re-renders and that server-side updates are successful.
  • Unexpected Styling: Inspect CSS specificity; Material-UI themes and overrides offer solutions.

Tips for debugging and improving table performance

  • Browser Developer Tools: Profile performance, inspect rendering bottlenecks.
  • Network Monitoring: Check if data fetching is slow.
  • Logging and Monitoring: Implement error logging to catch issues early.

Resources and Further Reading

  • Official Material-Table documentation: The most reliable, up-to-date reference (
  • Recommended Material-UI resources: To gain deeper knowledge of styling and theming, refer to the Material-UI documentation
  • Community forums and Stack Overflow: Get help, discover solutions, and learn from others.


Recap of key points

We’ve covered a vast landscape with Material-Table:

  • Basics: Setup, core components, table configuration.
  • Actions: Using buttons for row-level actions.
  • Editing, Sorting, Filtering: Implementing core interactive features.
  • Styling and Performance: Customization and optimization.
  • Advanced Techniques: Custom components, plugins, and real-world scenarios.

Encouraging experimentation and learning

Material-Table is a fantastic library that gives you a great foundation to build robust, data-driven React applications. Don’t be afraid to experiment, build upon these concepts, and tailor the library to your specific needs!

Welcome to Limitless, where the science of the mind meets the art of marketing.

Get In Touch

Limitless Neuromarketing Lab © 2024 All Rights Reserved