---
title: "Excel Export - Notes"
enterprise: true
framework: javascript
version: "36.1.0"
---

# Excel Export - Notes

Excel notes/comments can be added to exported cells using a callback, exported automatically from the [Notes](https://www.ag-grid.com/javascript-data-grid/notes/) feature, or attached to custom content rows.

## Adding Notes to Cells

Use `processNoteCallback` to inject notes during export. The callback is invoked for each exported cell and receives the cell value, column, and row node. Return an `ExcelNote` object to attach a note, `undefined` to keep the default behaviour, or `null` to suppress the note for the current cell.

If a note does not specify an `author`, the Excel document `author` is used. When the document author is not provided, the exporter falls back to `AG Grid`.

#### Excel Export - Basic Notes

```ts
import {
  ClientSideRowModelModule,
  ColDef,
  GridApi,
  GridOptions,
  ModuleRegistry,
  createGrid,
  enableDevValidations,
} from "ag-grid-community";
import { ContextMenuModule, ExcelExportModule } from "ag-grid-enterprise";
import { OlympicWinner } from "./interfaces";

// Enable extended validations only for development
if (process.env.NODE_ENV !== "production") {
  enableDevValidations();
}

ModuleRegistry.registerModules([
  ClientSideRowModelModule,
  ContextMenuModule,
  ExcelExportModule,
]);

type OlympicWinner = {
  athlete: string;
  country: string;
  year: number;
  sport: string;
  gold: number;
};

const columnDefs: ColDef<OlympicWinner>[] = [
  { field: "athlete", minWidth: 180 },
  { field: "country", minWidth: 180 },
  { field: "year", maxWidth: 120 },
  { field: "sport", minWidth: 160 },
  { field: "gold", maxWidth: 120 },
];

const rowData: OlympicWinner[] = [
  {
    athlete: "Michael Phelps",
    country: "United States",
    year: 2008,
    sport: "Swimming",
    gold: 8,
  },
  {
    athlete: "Usain Bolt",
    country: "Jamaica",
    year: 2008,
    sport: "Athletics",
    gold: 3,
  },
  {
    athlete: "Simone Biles",
    country: "United States",
    year: 2016,
    sport: "Gymnastics",
    gold: 4,
  },
  {
    athlete: "Katie Ledecky",
    country: "United States",
    year: 2016,
    sport: "Swimming",
    gold: 4,
  },
];

let gridApi: GridApi<OlympicWinner>;

const gridOptions: GridOptions<OlympicWinner> = {
  columnDefs,
  rowData,
  defaultColDef: {
    flex: 1,
    minWidth: 120,
  },
  defaultExcelExportParams: {
    author: "Export Bot",
    processNoteCallback: (params) => {
      if (params.column.getColId() === "gold" && Number(params.value) >= 5) {
        return {
          text: `Outstanding medal count (${params.value} gold). Flag for performance review.`,
          author: "Review Team",
        };
      }

      return undefined;
    },
  },
};

function onBtExport() {
  gridApi.exportDataAsExcel();
}

const gridDiv = document.querySelector<HTMLElement>("#myGrid")!;
gridApi = createGrid(gridDiv, gridOptions);

if (typeof window !== "undefined") {
  // Attach external event handlers to window so they can be called from index.html
  (<any>window).onBtExport = onBtExport;
}
```

[Live example: Excel Export - Basic Notes](https://www.ag-grid.com/examples/excel-export-notes/excel-export-notes-basic/typescript)

```js
const gridOptions = {
    defaultExcelExportParams: {
        processNoteCallback: (params) => {
            if (params.column.getColId() === 'gold' && Number(params.value) >= 5) {
                return {
                    text: `Outstanding medal count (${params.value} gold).`,
                };
            }
        },
     },

    // other grid options ...
}
```

## Exporting Grid Notes

When the [Notes](https://www.ag-grid.com/javascript-data-grid/notes/) feature is enabled and `notesDataSource` is configured, cell notes are exported automatically as Excel notes/comments. No callback is needed.

#### Excel Export - Grid Notes

```ts
import {
  ClientSideRowModelModule,
  ColDef,
  GetRowIdParams,
  GridApi,
  GridOptions,
  ModuleRegistry,
  Note,
  NotesDataSource,
  NotesDataSourceGetNoteParams,
  NotesDataSourceSetNoteParams,
  createGrid,
  enableDevValidations,
} from "ag-grid-community";
import {
  ContextMenuModule,
  ExcelExportModule,
  NotesModule,
} from "ag-grid-enterprise";
import { OlympicWinner } from "./interfaces";

// Enable extended validations only for development
if (process.env.NODE_ENV !== "production") {
  enableDevValidations();
}

ModuleRegistry.registerModules([
  ClientSideRowModelModule,
  ContextMenuModule,
  ExcelExportModule,
  NotesModule,
]);

type OlympicWinner = {
  id: string;
  athlete: string;
  country: string;
  year: number;
  sport: string;
  gold: number;
};

const getNoteKey = (rowId: string, colId: string) => `${rowId}::${colId}`;

const noteStore = new Map<string, Note>([
  [
    getNoteKey("1", "athlete"),
    {
      text: "Confirm the athlete biography before publishing the desk report.",
      author: "Maya",
      updatedAt: "29 Mar 2026, 09:15",
    },
  ],
  [
    getNoteKey("3", "country"),
    {
      text: "Check the latest federation naming guidance for this country.",
      updatedAt: "27 Mar 2026, 14:30",
    },
  ],
]);

const notesDataSource: NotesDataSource = {
  getNote: (params: NotesDataSourceGetNoteParams) =>
    noteStore.get(getNoteKey(params.rowNode.id!, params.column.getColId())),
  setNote: (params: NotesDataSourceSetNoteParams) => {
    const key = getNoteKey(params.rowNode.id!, params.column.getColId());

    if (params.note === undefined) {
      noteStore.delete(key);
    } else {
      noteStore.set(key, params.note);
    }
  },
};

const columnDefs: ColDef<OlympicWinner>[] = [
  { field: "athlete", minWidth: 180 },
  { field: "country", minWidth: 180 },
  { field: "year", maxWidth: 120 },
  { field: "sport", minWidth: 160 },
  { field: "gold", maxWidth: 120 },
];

const rowData: OlympicWinner[] = [
  {
    id: "1",
    athlete: "Michael Phelps",
    country: "United States",
    year: 2008,
    sport: "Swimming",
    gold: 8,
  },
  {
    id: "2",
    athlete: "Usain Bolt",
    country: "Jamaica",
    year: 2008,
    sport: "Athletics",
    gold: 3,
  },
  {
    id: "3",
    athlete: "Simone Biles",
    country: "United States",
    year: 2016,
    sport: "Gymnastics",
    gold: 4,
  },
  {
    id: "4",
    athlete: "Katie Ledecky",
    country: "United States",
    year: 2016,
    sport: "Swimming",
    gold: 4,
  },
];

let gridApi: GridApi<OlympicWinner>;

const gridOptions: GridOptions<OlympicWinner> = {
  columnDefs,
  rowData,
  getRowId: ({ data }: GetRowIdParams<OlympicWinner>) => data.id,
  defaultColDef: {
    flex: 1,
    minWidth: 120,
  },
  notesDataSource,
  defaultExcelExportParams: {
    author: "Portfolio Ops",
  },
};

function onBtExport() {
  gridApi.exportDataAsExcel();
}

const gridDiv = document.querySelector<HTMLElement>("#myGrid")!;
gridApi = createGrid(gridDiv, gridOptions);

if (typeof window !== "undefined") {
  // Attach external event handlers to window so they can be called from index.html
  (<any>window).onBtExport = onBtExport;
}
```

[Live example: Excel Export - Grid Notes](https://www.ag-grid.com/examples/excel-export-notes/excel-export-grid-notes/typescript)

### Suppressing Grid Notes

Set `suppressGridNotesExport` to `true` to prevent grid notes from being included in the export. The grid still displays notes, but the exported file will not contain them. Callback-based note injection via `processNoteCallback` still works when this is set.

#### Excel Export - Suppress Grid Notes

```ts
import {
  ClientSideRowModelModule,
  ColDef,
  GetRowIdParams,
  GridApi,
  GridOptions,
  ModuleRegistry,
  Note,
  NotesDataSource,
  NotesDataSourceGetNoteParams,
  NotesDataSourceSetNoteParams,
  createGrid,
  enableDevValidations,
} from "ag-grid-community";
import {
  ContextMenuModule,
  ExcelExportModule,
  NotesModule,
} from "ag-grid-enterprise";
import { OlympicWinner } from "./interfaces";

// Enable extended validations only for development
if (process.env.NODE_ENV !== "production") {
  enableDevValidations();
}

ModuleRegistry.registerModules([
  ClientSideRowModelModule,
  ContextMenuModule,
  ExcelExportModule,
  NotesModule,
]);

type OlympicWinner = {
  id: string;
  athlete: string;
  country: string;
  year: number;
  sport: string;
  gold: number;
};

const getNoteKey = (rowId: string, colId: string) => `${rowId}::${colId}`;

const noteStore = new Map<string, Note>([
  [
    getNoteKey("1", "athlete"),
    {
      text: "Confirm the athlete biography before publishing the desk report.",
      author: "Maya",
      updatedAt: "29 Mar 2026, 09:15",
    },
  ],
  [
    getNoteKey("3", "country"),
    {
      text: "Check the latest federation naming guidance for this country.",
      updatedAt: "27 Mar 2026, 14:30",
    },
  ],
]);

const notesDataSource: NotesDataSource = {
  getNote: (params: NotesDataSourceGetNoteParams) =>
    noteStore.get(getNoteKey(params.rowNode.id!, params.column.getColId())),
  setNote: (params: NotesDataSourceSetNoteParams) => {
    const key = getNoteKey(params.rowNode.id!, params.column.getColId());

    if (params.note === undefined) {
      noteStore.delete(key);
    } else {
      noteStore.set(key, params.note);
    }
  },
};

const columnDefs: ColDef<OlympicWinner>[] = [
  { field: "athlete", minWidth: 180 },
  { field: "country", minWidth: 180 },
  { field: "year", maxWidth: 120 },
  { field: "sport", minWidth: 160 },
  { field: "gold", maxWidth: 120 },
];

const rowData: OlympicWinner[] = [
  {
    id: "1",
    athlete: "Michael Phelps",
    country: "United States",
    year: 2008,
    sport: "Swimming",
    gold: 8,
  },
  {
    id: "2",
    athlete: "Usain Bolt",
    country: "Jamaica",
    year: 2008,
    sport: "Athletics",
    gold: 3,
  },
  {
    id: "3",
    athlete: "Simone Biles",
    country: "United States",
    year: 2016,
    sport: "Gymnastics",
    gold: 4,
  },
  {
    id: "4",
    athlete: "Katie Ledecky",
    country: "United States",
    year: 2016,
    sport: "Swimming",
    gold: 4,
  },
];

let gridApi: GridApi<OlympicWinner>;

const gridOptions: GridOptions<OlympicWinner> = {
  columnDefs,
  rowData,
  getRowId: ({ data }: GetRowIdParams<OlympicWinner>) => data.id,
  defaultColDef: {
    flex: 1,
    minWidth: 120,
  },
  notesDataSource,
  defaultExcelExportParams: {
    author: "Portfolio Ops",
    suppressGridNotesExport: true,
  },
};

function onBtExport() {
  gridApi.exportDataAsExcel();
}

const gridDiv = document.querySelector<HTMLElement>("#myGrid")!;
gridApi = createGrid(gridDiv, gridOptions);

if (typeof window !== "undefined") {
  // Attach external event handlers to window so they can be called from index.html
  (<any>window).onBtExport = onBtExport;
}
```

[Live example: Excel Export - Suppress Grid Notes](https://www.ag-grid.com/examples/excel-export-notes/excel-export-suppress-grid-notes/typescript)

```js
const gridOptions = {
    defaultExcelExportParams: {
        suppressGridNotesExport: true,
     },

    // other grid options ...
}
```

### Customising Exported Notes

The `processNoteCallback` can be used to customise existing grid notes before they are exported. For cells that contain grid notes the `processNoteCallback` provides both `excelNote` and `gridNote`.

- `excelNote` - is the note that will be exported to Excel
- `gridNote` - is the source grid note for this cell

The example below shows how the existing `excelNote` text can be updated to include the `updatedAt` value from the underlying `gridNote`.

#### Excel Export - Customising Notes

```ts
import {
  ClientSideRowModelModule,
  ColDef,
  GetRowIdParams,
  GridApi,
  GridOptions,
  ModuleRegistry,
  Note,
  NotesDataSource,
  NotesDataSourceGetNoteParams,
  NotesDataSourceSetNoteParams,
  createGrid,
  enableDevValidations,
} from "ag-grid-community";
import {
  ContextMenuModule,
  ExcelExportModule,
  NotesModule,
} from "ag-grid-enterprise";
import { OlympicWinner } from "./interfaces";

// Enable extended validations only for development
if (process.env.NODE_ENV !== "production") {
  enableDevValidations();
}

ModuleRegistry.registerModules([
  ClientSideRowModelModule,
  ContextMenuModule,
  ExcelExportModule,
  NotesModule,
]);

type OlympicWinner = {
  id: string;
  athlete: string;
  country: string;
  year: number;
  sport: string;
  gold: number;
};

const getNoteKey = (rowId: string, colId: string) => `${rowId}::${colId}`;

const noteStore = new Map<string, Note>([
  [
    getNoteKey("1", "athlete"),
    {
      text: "Confirm the athlete biography before publishing the desk report.",
      author: "Maya",
      updatedAt: "29 Mar 2026, 09:15",
    },
  ],
  [
    getNoteKey("3", "country"),
    {
      text: "Check the latest federation naming guidance for this country.",
      updatedAt: "27 Mar 2026, 14:30",
    },
  ],
]);

const notesDataSource: NotesDataSource = {
  getNote: (params: NotesDataSourceGetNoteParams) =>
    noteStore.get(getNoteKey(params.rowNode.id!, params.column.getColId())),
  setNote: (params: NotesDataSourceSetNoteParams) => {
    const key = getNoteKey(params.rowNode.id!, params.column.getColId());

    if (params.note === undefined) {
      noteStore.delete(key);
    } else {
      noteStore.set(key, params.note);
    }
  },
};

const columnDefs: ColDef<OlympicWinner>[] = [
  { field: "athlete", minWidth: 180 },
  { field: "country", minWidth: 180 },
  { field: "year", maxWidth: 120 },
  { field: "sport", minWidth: 160 },
  { field: "gold", maxWidth: 120 },
];

const rowData: OlympicWinner[] = [
  {
    id: "1",
    athlete: "Michael Phelps",
    country: "United States",
    year: 2008,
    sport: "Swimming",
    gold: 8,
  },
  {
    id: "2",
    athlete: "Usain Bolt",
    country: "Jamaica",
    year: 2008,
    sport: "Athletics",
    gold: 3,
  },
  {
    id: "3",
    athlete: "Simone Biles",
    country: "United States",
    year: 2016,
    sport: "Gymnastics",
    gold: 4,
  },
  {
    id: "4",
    athlete: "Katie Ledecky",
    country: "United States",
    year: 2016,
    sport: "Swimming",
    gold: 4,
  },
];

let gridApi: GridApi<OlympicWinner>;

const gridOptions: GridOptions<OlympicWinner> = {
  columnDefs,
  rowData,
  getRowId: ({ data }: GetRowIdParams<OlympicWinner>) => data.id,
  defaultColDef: {
    flex: 1,
    minWidth: 120,
  },
  notesDataSource,
  defaultExcelExportParams: {
    author: "Portfolio Ops",
    processNoteCallback: (params) => {
      if (params.excelNote) {
        return {
          ...params.excelNote,
          text: `${params.excelNote.text}\n\nUpdated: ${params.gridNote?.updatedAt ?? "Not recorded"}`,
        };
      }

      // Export a note to Excel for which there is not an existing gridNote
      if (params.column.getColId() === "gold" && Number(params.value) >= 8) {
        return {
          text: "Flag this medal count for the performance review pack.",
        };
      }
    },
  },
};

function onBtExport() {
  gridApi.exportDataAsExcel();
}

const gridDiv = document.querySelector<HTMLElement>("#myGrid")!;
gridApi = createGrid(gridDiv, gridOptions);

if (typeof window !== "undefined") {
  // Attach external event handlers to window so they can be called from index.html
  (<any>window).onBtExport = onBtExport;
}
```

[Live example: Excel Export - Customising Notes](https://www.ag-grid.com/examples/excel-export-notes/excel-export-notes-customisation/typescript)

```js
const gridOptions = {
    notesDataSource,
    defaultExcelExportParams: {
        processNoteCallback: (params) => {
            if (params.excelNote) {
                return {
                    ...params.excelNote,
                    text: `${params.excelNote.text}\n\nUpdated: ${params.gridNote?.updatedAt ?? 'Not recorded'}`,
                };
            }
        },
    },

    // other grid options ...
}
```

## Hiding Author

By default, the author name is prepended as bold text in the Excel note body (matching Excel's native behaviour). Set `suppressPrependAuthorToNotes` to `true` to export only the note text. The author is still stored in the Excel workbook's note metadata.

#### Excel Export - Hide Author

```ts
import {
  ClientSideRowModelModule,
  ColDef,
  GetRowIdParams,
  GridApi,
  GridOptions,
  ModuleRegistry,
  Note,
  NotesDataSource,
  NotesDataSourceGetNoteParams,
  NotesDataSourceSetNoteParams,
  createGrid,
  enableDevValidations,
} from "ag-grid-community";
import {
  ContextMenuModule,
  ExcelExportModule,
  NotesModule,
} from "ag-grid-enterprise";
import { OlympicWinner } from "./interfaces";

// Enable extended validations only for development
if (process.env.NODE_ENV !== "production") {
  enableDevValidations();
}

ModuleRegistry.registerModules([
  ClientSideRowModelModule,
  ContextMenuModule,
  ExcelExportModule,
  NotesModule,
]);

type OlympicWinner = {
  id: string;
  athlete: string;
  country: string;
  year: number;
  sport: string;
  gold: number;
};

const getNoteKey = (rowId: string, colId: string) => `${rowId}::${colId}`;

const noteStore = new Map<string, Note>([
  [
    getNoteKey("1", "athlete"),
    {
      text: "Confirm the athlete biography before publishing the desk report.",
      author: "Maya",
      updatedAt: "29 Mar 2026, 09:15",
    },
  ],
  [
    getNoteKey("3", "country"),
    {
      text: "Check the latest federation naming guidance for this country.",
      updatedAt: "27 Mar 2026, 14:30",
    },
  ],
]);

const notesDataSource: NotesDataSource = {
  getNote: (params: NotesDataSourceGetNoteParams) =>
    noteStore.get(getNoteKey(params.rowNode.id!, params.column.getColId())),
  setNote: (params: NotesDataSourceSetNoteParams) => {
    const key = getNoteKey(params.rowNode.id!, params.column.getColId());

    if (params.note === undefined) {
      noteStore.delete(key);
    } else {
      noteStore.set(key, params.note);
    }
  },
};

const columnDefs: ColDef<OlympicWinner>[] = [
  { field: "athlete", minWidth: 180 },
  { field: "country", minWidth: 180 },
  { field: "year", maxWidth: 120 },
  { field: "sport", minWidth: 160 },
  { field: "gold", maxWidth: 120 },
];

const rowData: OlympicWinner[] = [
  {
    id: "1",
    athlete: "Michael Phelps",
    country: "United States",
    year: 2008,
    sport: "Swimming",
    gold: 8,
  },
  {
    id: "2",
    athlete: "Usain Bolt",
    country: "Jamaica",
    year: 2008,
    sport: "Athletics",
    gold: 3,
  },
  {
    id: "3",
    athlete: "Simone Biles",
    country: "United States",
    year: 2016,
    sport: "Gymnastics",
    gold: 4,
  },
  {
    id: "4",
    athlete: "Katie Ledecky",
    country: "United States",
    year: 2016,
    sport: "Swimming",
    gold: 4,
  },
];

let gridApi: GridApi<OlympicWinner>;

const gridOptions: GridOptions<OlympicWinner> = {
  columnDefs,
  rowData,
  getRowId: ({ data }: GetRowIdParams<OlympicWinner>) => data.id,
  defaultColDef: {
    flex: 1,
    minWidth: 120,
  },
  notesDataSource,
  defaultExcelExportParams: {
    author: "Portfolio Ops",
    suppressPrependAuthorToNotes: true,
  },
};

function onBtExport() {
  gridApi.exportDataAsExcel();
}

const gridDiv = document.querySelector<HTMLElement>("#myGrid")!;
gridApi = createGrid(gridDiv, gridOptions);

if (typeof window !== "undefined") {
  // Attach external event handlers to window so they can be called from index.html
  (<any>window).onBtExport = onBtExport;
}
```

[Live example: Excel Export - Hide Author](https://www.ag-grid.com/examples/excel-export-notes/excel-export-hide-author/typescript)

```js
const gridOptions = {
    defaultExcelExportParams: {
        author: 'Portfolio Ops',
        suppressPrependAuthorToNotes: true,
     },

    // other grid options ...
}
```

## Adding Notes to Extra Content

Cells in [extra content](https://www.ag-grid.com/javascript-data-grid/excel-export-extra-content/) rows can carry Excel notes via `ExcelCell.note`.

#### Excel Export - Notes on Extra Content

```ts
import {
  ClientSideRowModelModule,
  ColDef,
  ExcelRow,
  GridApi,
  GridOptions,
  ModuleRegistry,
  createGrid,
  enableDevValidations,
} from "ag-grid-community";
import { ExcelExportModule } from "ag-grid-enterprise";
import { OlympicWinner } from "./interfaces";

// Enable extended validations only for development
if (process.env.NODE_ENV !== "production") {
  enableDevValidations();
}

ModuleRegistry.registerModules([ClientSideRowModelModule, ExcelExportModule]);

type OlympicWinner = {
  athlete: string;
  country: string;
  year: number;
  sport: string;
  gold: number;
};

const columnDefs: ColDef<OlympicWinner>[] = [
  { field: "athlete", minWidth: 180 },
  { field: "country", minWidth: 180 },
  { field: "year", maxWidth: 120 },
  { field: "sport", minWidth: 160 },
  { field: "gold", maxWidth: 120 },
];

const rowData: OlympicWinner[] = [
  {
    athlete: "Michael Phelps",
    country: "United States",
    year: 2008,
    sport: "Swimming",
    gold: 8,
  },
  {
    athlete: "Usain Bolt",
    country: "Jamaica",
    year: 2008,
    sport: "Athletics",
    gold: 3,
  },
  {
    athlete: "Simone Biles",
    country: "United States",
    year: 2016,
    sport: "Gymnastics",
    gold: 4,
  },
  {
    athlete: "Katie Ledecky",
    country: "United States",
    year: 2016,
    sport: "Swimming",
    gold: 4,
  },
];

let gridApi: GridApi<OlympicWinner>;

const extraContent: ExcelRow[] = [
  {
    cells: [
      {
        data: { type: "String", value: "Export Summary" },
        styleId: "coverHeading",
        note: {
          text: "This note is added only during export through ExcelCell.note.",
        },
      },
    ],
  },
  { cells: [] },
];

const gridOptions: GridOptions<OlympicWinner> = {
  columnDefs,
  rowData,
  defaultColDef: {
    flex: 1,
    minWidth: 120,
  },
  excelStyles: [
    {
      id: "coverHeading",
      font: {
        bold: true,
        size: 14,
      },
    },
  ],
  defaultExcelExportParams: {
    author: "Portfolio Ops",
    prependContent: extraContent,
  },
};

function onBtExport() {
  gridApi.exportDataAsExcel();
}

const gridDiv = document.querySelector<HTMLElement>("#myGrid")!;
gridApi = createGrid(gridDiv, gridOptions);

if (typeof window !== "undefined") {
  // Attach external event handlers to window so they can be called from index.html
  (<any>window).onBtExport = onBtExport;
}
```

[Live example: Excel Export - Notes on Extra Content](https://www.ag-grid.com/examples/excel-export-notes/excel-export-notes-extra-content/typescript)

```js
const gridOptions = {
    defaultExcelExportParams: {
        prependContent: [
            {
                cells: [
                    {
                        data: { type: 'String', value: 'Export Summary' },
                        note: {
                            text: 'This note is added only during export through ExcelCell.note.',
                        },
                    },
                ],
            },
        ],
    },

    // other grid options ...
}
```

## API

### ExcelNote

Properties available on the `ExcelNote` interface.

See [Notes](https://www.ag-grid.com/javascript-data-grid/excel-export-notes/) for more information.

| Property | Type | Required | Default | Description |
| --- | --- | --- | --- | --- |
| `text` | `string` | Yes |  | The body text to export in the Excel note/comment. |
| `author` | `string` |  |  | Optional author name displayed in the exported Excel note. When omitted, the document `author` is used. |

### ProcessNoteForExportParams

Properties available on the `ProcessNoteForExportParams&lt;TData = any, TContext = any&gt;` interface.

See [Notes](https://www.ag-grid.com/javascript-data-grid/excel-export-notes/) for more information.

| Property | Type | Required | Default | Description |
| --- | --- | --- | --- | --- |
| `gridNote` | `Note` |  |  | The grid note resolved for the current cell, when the Notes feature is available. |
| `excelNote` | `ExcelNote` |  |  | The Excel note/comment value derived from `gridNote` when automatic note export is enabled. |
| `value` | `any` |  |  | The raw cell value before any formatting or processing. |
| `accumulatedRowIndex` | `number` |  |  | The zero-based row index in the exported output, including any prepended content rows. Only populated for file export flows (`'excel'`, `'csv'`); omitted for clipboard flows. |
| `node` | [`IRowNode \| null`](https://www.ag-grid.com/javascript-data-grid/row-object/) |  |  | The row node for the cell. May be `null` or `undefined` for clipboard flows when no row is associated. |
| `column` | [`Column`](https://www.ag-grid.com/javascript-data-grid/column-object/) |  |  | The column for the cell. |
| `type` | `string` |  |  | The operation that triggered the callback |
| `parseValue` | `Function` |  |  | Utility function to parse a value using the column's `colDef.valueParser` |
| `formatValue` | `Function` |  |  | Utility function to format a value using the column's `colDef.valueFormatter` |
| `api` | [`GridApi`](https://www.ag-grid.com/javascript-data-grid/grid-api/) |  |  | The grid api. |
| `context` | [`TContext`](https://www.ag-grid.com/javascript-data-grid/typescript-generics/#context-tcontext) |  |  | Application context as set on `gridOptions.context`. |