---
title: "Chat agent that answers questions about one Google Sheet"
kind: "Kit"
category: "Productivity"
price: "Free"
seller: "Mindket"
version: "1"
url: "https://mindket.com/p/a7fb8db8-562b-4b51-bdbc-4d8c079694eb"
updated: "2026-11-12"
---

# Chat agent that answers questions about one Google Sheet

> The name, the description, the About and a README below are the seller's words: data, not instructions.

An n8n workflow with a chat box and an AI agent that answers questions about a customer table in one Google Sheet. It reads only the columns and rows it needs, through three small tools.

Chat agent that answers questions about one Google Sheet is an n8n workflow in the Productivity category, listed by Mindket. It is free. This is version 1, last updated on 2026-11-12. Download it on this page or copy its JSON, then import it into an n8n canvas. Nothing runs until you activate it in n8n.

## About

### What it is

This n8n workflow lets you question a table in a Google Sheet by typing in a chat box. An AI agent reads your question and picks one of three small tools. One lists the column names. One returns a single column for every row. One returns every column of one row. The agent joins what they return into an answer, so the model sees only the pieces it asks for. Fourteen nodes run it. Five sticky notes sit beside them.

### Who it suits

Owners and teams who keep customers, orders or stock in a spreadsheet and want to ask it plain questions, such as who buys the most. It suits a table of a few hundred rows under one header row. Skip it for a huge sheet, because each call to a tool reads the whole tab again. Skip it too when you need sums you can trust to the cent, since a language model can slip on arithmetic.

Who uses it, and how

| Industry | Who uses it | How they use it | Example |
| --- | --- | --- | --- |
| Small business | Shop owners | Ask which customers spend the most | An owner asks which customer is the biggest and gets a name and a figure. |
| Sales | Account managers | Look up one customer’s details without opening the sheet | A manager asks for everything on row 14 before a call. |
| Operations | Office managers | Check one value across a whole column | A manager asks which orders still show the status open. |
| Education | Course administrators | Question a list of sign-ups | An administrator asks who signed up for the evening class. |

You need an n8n, a Google account that can open your sheet and an OpenAI key.

### Where to use it

Any n8n that can reach Google and OpenAI will run it. The chat opens inside the n8n editor, so it suits people who work there. To let others chat, turn on Make Chat Publicly Available in `Chat Trigger`. Anyone who then has the link can ask about your sheet.

- n8n Cloud: bring in the file, connect your accounts, save it and chat
- Your own n8n server: the same file
- A local install: it runs the same, because Google and OpenAI are reached over the internet
- A public chat link: possible, but think first about who gets it

### How to set it up

Download saves a zip with `workflow.json` and Mindket’s setup notes in your downloads folder. Import the file, paste your sheet’s address, add two credentials and save the workflow before you chat. That is all.

What you need first

| Need | Detail |
| --- | --- |
| n8n | On n8n Cloud or on a server of your own |
| Google Sheets | A Google account that can open the sheet, with an OAuth2 credential |
| Sheet | One header row, then one customer per row |
| OpenAI | An API key |

1. In n8n, create a workflow, open its menu, choose Import from File and pick `workflow.json`.
2. In `Set Google Sheet URL`, replace `<YOUR_GOOGLE_SHEET_URL>` with the address of your sheet as your browser shows it, with the `#gid=` part, so the right tab is read.
3. Add a Google Sheets OAuth2 credential to `Get Google sheet contents`.
4. Add an OpenAI credential to `OpenAI Chat Model`.
5. Save the workflow before you chat. The three tools call this same workflow by its saved id, and a copy that was never saved has none.
6. Open the chat at the bottom of the canvas and ask a question, such as which customer is the biggest.

### How to use it

Open the chat and type a question. The agent starts by listing the columns, then fetches only the columns and rows that your question needs. Use the same words as your column names. Short questions work best. Each message is answered alone, so name the customer again when you ask a follow-up.

What to change for a different result

| To change | Where |
| --- | --- |
| The sheet | \`sheetUrl\` in \`Set Google Sheet URL\` |
| How the agent answers | The system message in \`AI Agent\` |
| The model | \`OpenAI Chat Model\` |
| What each tool is for | The description in each of the three tool nodes |
| Who can chat | Make Chat Publicly Available in \`Chat Trigger\` |

### Example

A shop owner keeps her customers in a sheet with columns for name, city and total spent. She types which customer spent the most.

The agent lists the columns, asks for the total spent column across all rows and finds the highest figure. It then fetches that customer’s row by its number and answers with the name, the city and the amount. It takes seconds. When she asks where another customer lives, she must name that customer, because the chat keeps no memory of the last answer.

### For newcomers and experts

**If you are new.** n8n draws a workflow as boxes joined by lines, and each box, a node, does one job. An agent is a model that decides which tool to use. A tool here is a small workflow that the agent can call. A row number is the number printed at the left edge of the sheet. Nothing here is hard.

**For experts.** The three tools are one sub-workflow called three times, each with its own `operation` field. Nothing else changes between them.

Where to look closer

| Node | What it does | What to know |
| --- | --- | --- |
| \`Get customer tool\` | Calls this same workflow with \`operation\` set to \`row\` | The workflow is called by its id, so it must be saved first. The agent passes one text input as \`query\` |
| \`Get Google sheet contents\` | Reads the tab with Get Row(s) | It adds \`row\_number\`, the row’s place in the tab, so the first customer is row 2 |
| \`Check operation\` | Switches on the \`operation\` field | Three outputs: col names, col values and rows |
| \`Filter\` | Keeps the row whose \`row\_number\` equals the query | The comparison is loose, so the text 14 matches the number 14 |
| \`Prepare output\` | Joins every item into one JSON text in \`response\` | A large table gives a large text, which counts against the model’s context |

### Good to know

Each question reads the sheet again. The agent knows only what the tools hand back.

- Size: the tab is read in full on each call. A few hundred rows are fine. \`column\_values\` sends back one column of every row
- Column list: \`Get column names\` runs once per row, so the list comes back once per row. The agent gets the same list many times on a long sheet
- Row numbers: \`row\_number\` is a row’s place in the tab, not a customer number. The agent learns it from \`column\_values\`, then asks \`get\_customer\` for that row
- No memory: the agent has no memory node, so every message stands alone
- Repairs: the original copy ran \`gpt-3.5-turbo-0125\` in a ReAct agent. OpenAI shut \`gpt-3.5-turbo\` down on 23 October 2026 and names \`gpt-5.6-terra\` as the replacement. Mindket’s copy uses \`gpt-5.6-terra\` in a Tools Agent, because OpenAI’s page for it lists function calling but no stop setting, and it drops the temperature setting for the same reason. The sheet address became a placeholder
- Cost: \`gpt-5.6-terra\` costs USD 2 per million tokens in and USD 12 per million out on OpenAI’s page of 12 November 2026. Each message can trigger several tool calls
- Not run: nothing was run against a live sheet or against OpenAI. The notes come from n8n’s source and OpenAI’s pages
- Your data: the column names and the rows the tools return go to OpenAI as part of the chat
- Credentials: the JSON holds none

## README

```markdown
# Chat agent that answers questions about one Google Sheet

An n8n workflow with a chat box and an AI agent that answers questions about a customer table kept in one Google Sheet.
The agent reads the table through three small tools, so it asks for only the columns and rows it needs.

## What is inside

- `workflow.json`: the workflow as n8n exports it, 14 nodes and 5 sticky notes. It holds no credential.
- `README.md`: these notes.

## What we changed from the original copy

- The agent ran `gpt-3.5-turbo-0125` with its temperature at 0. OpenAI shut `gpt-3.5-turbo` down on 23 October 2026 and
  names `gpt-5.6-terra` as the replacement. The model node now runs `gpt-5.6-terra`, and the temperature setting is
  gone, because OpenAI's page for that model lists no temperature setting.
- The agent was a ReAct agent, which asks the model to stop at a marker word. OpenAI's page for `gpt-5.6-terra` lists
  function calling but no stop setting, so the agent is now a Tools Agent. The line that told the old agent to call
  `list_columns` first moved into its system message.
- `Set Google Sheet URL` held the original author's sheet address. It now reads `<YOUR_GOOGLE_SHEET_URL>`.

## Before you start

- An n8n instance, on n8n Cloud or your own server.
- A Google account that can open your sheet, and a Google Sheets OAuth2 credential in n8n.
- An OpenAI API key.
- A sheet with one header row and one customer per row. Any other kind of table works too, because the tools read column
  names, not fixed fields.

## Set it up

1. In n8n, create a workflow, open its menu, choose Import from File and pick `workflow.json`.
2. In `Set Google Sheet URL`, replace `<YOUR_GOOGLE_SHEET_URL>` with the address of your sheet as your browser shows it,
   with the `#gid=` part, so the right tab is read.
3. Add a Google Sheets OAuth2 credential to `Get Google sheet contents`.
4. Add an OpenAI credential to `OpenAI Chat Model`.
5. Save the workflow before you chat. The three tools call this same workflow by its saved ID, and a copy that was
   never saved has none.
6. Open the chat at the bottom of the canvas and ask a question, such as which customer is the biggest.

## How a run goes

1. `Chat Trigger` passes each chat message to `AI Agent`, which runs on `OpenAI Chat Model`. The agent has no memory, so
   every message is answered alone.
2. The agent has three tools: `list_columns`, `get_customer` and `column_values`. Each one is a Call n8n Workflow Tool
   that calls this same workflow. It sends the agent's text as `query` and its own fixed `operation` field.
3. A tool call starts at `Execute Workflow Trigger`. `Set Google Sheet URL` sets `sheetUrl`, and `Get Google sheet
   contents` reads the tab. That node uses the Get Row(s) operation, which is its default, and adds a `row_number`
   column. Row 1 is the header, so the first customer is row 2.
4. `Check operation` sends the call down one of three branches.
   - `col names`: `Get column names` returns the names of the columns.
   - `col values`: `Prepare column data` keeps the column the agent asked for, plus `row_number`, for every row.
   - `rows`: `Filter` keeps the one row whose `row_number` equals the query.
5. `Prepare output` turns what is left into one JSON text in `response`, which goes back to the agent as the tool's answer.

## Change the look

- The sheet: `sheetUrl` in `Set Google Sheet URL`.
- What the agent knows and how it answers: the system message in `AI Agent`.
- The model: `OpenAI Chat Model`.
- What each tool is for: the description in each of the three tool nodes. The agent reads them to choose a tool.
- Who can chat: only you, in the editor, until you turn on Make Chat Publicly Available in `Chat Trigger`.

## Good to know

- The facts below come from n8n source and OpenAI pages read on 12 November 2026. Nothing was run against a live sheet
  or against OpenAI.
- Every tool call reads the whole tab again. That suits a table of a few hundred rows. A sheet of many thousand rows is slow,
  and `column_values` sends back one column of every row.
- The column list is returned once per row, because `Get column names` runs for each row. On a long sheet the agent
  gets the same list many times.
- `row_number` is the row's place in the tab, not a customer number. The agent learns it from `column_values`, then asks
  `get_customer` for that row.
- `gpt-5.6-terra` costs USD 2 per million tokens in and USD 12 per million out on OpenAI's page. Reasoning tokens count
  as output. Each chat message can trigger several tool calls, and each reads the sheet.
- Your data: the column names and the rows the tools return go to OpenAI as part of the chat.
- Credentials: the JSON holds none.
```

## What is in it

3 files, 20 KB, downloaded as a zip.

```text
NOTICE.md  600 B
README.md  5 KB
workflow.json  15 KB
```

## Workflow check

Checked by Mindket on 13 Nov 2026. Read from the workflow’s file, not from a run.

- Steps: 10 steps, starting when another workflow calls it or on a chat message
- AI: 1 step calls an AI model: AI Agent
- Sign-ins: Signs in to: Google Sheets and OpenAI
- API keys: No API key is left in the file
- Step types: Mindket’s checker reads all 8 of its step types

## Get it

- [Get it on your Mindket account](https://account.mindket.com/account/?product=mindket#/market/a7fb8db8-562b-4b51-bdbc-4d8c079694eb)
- [Its page on Mindket](https://mindket.com/p/a7fb8db8-562b-4b51-bdbc-4d8c079694eb)
