Make.com Google Sheets Integration: How to Read, Write, and Sync Data Automatically

Google Sheets is the most widely used data layer in small business operations. It is where leads get tracked, where project statuses live, where financial summaries are maintained, and where teams share information without paying for more specialised software. Make.com's Google Sheets integration connects that data layer to the rest of your automation stack, letting you read from and write to Sheets automatically as part of larger workflows.

This tutorial covers the complete Make.com Google Sheets integration: connecting the platforms, the key modules, common automation patterns, and the technical details that make a difference in production. If Make.com itself is new to you, start with Make.com Tutorial for Beginners.

Setting Up the Connection

Make.com connects to Google Sheets via OAuth. In any scenario, add a Google Sheets module and create a new connection. Make will redirect you to a Google authentication page where you grant permission for Make to read and write your Google Sheets data.

You will need to grant access to the Google account that owns or has edit access to the sheets you want to work with. If you are building automations for a client, use their Google account for the connection so the access is tied to their data, not yours.

One connection per Google account. If you work with multiple Google accounts, create a separate connection for each. Make allows multiple connections of the same type in a single account.

Key Modules

Watch New Rows. A trigger module that fires when a new row is added to a specified sheet. Polls on a schedule (every 15 minutes down to every minute depending on plan). Use this when you want to trigger an automation whenever data is added to a sheet — a new lead in a tracking sheet, a new order in an order log, a new task in a project sheet.

Watch Rows (All Changes). Similar to Watch New Rows but also fires when existing rows are modified. Use this when you need to respond to updates, not just new entries.

Search Rows. Looks for rows in a sheet that match a specific column value. Returns matching rows for use in downstream modules. Use this to check whether a record already exists before creating a duplicate.

Get a Row. Retrieves a specific row by its row number. Useful when you know the exact row position and want its values.

Add a Row. Appends a new row to the specified sheet. Maps values from upstream modules to your column structure. Returns the row number of the new row.

Update a Row. Modifies specific cells in an existing row. Requires the row number of the row to update, which you get from a prior Search Rows or Get a Row call.

Clear a Row. Removes the content from a row without deleting the row itself.

Delete a Row. Removes the row entirely, shifting rows below it up.

Common Pattern 1: Inbound Webhook to Google Sheets Log

One of the most common Make.com Google Sheets use cases is using a sheet as an automatic log for events from external systems.

Scenario: every time a Retell AI call ends, the key data from that call — caller name, phone number, reason for call, outcome, duration — is automatically added as a new row in a Google Sheet. The team sees a real-time call log without anyone manually entering data. Make.com Webhook Tutorial covers the receiving side of this pattern in detail.

Structure:

1. Custom Webhook trigger receives the Retell post-call payload
2. Filter: duration greater than 30 seconds (skip hang-ups)
3. Set Variables: extract caller name, phone, call outcome from transcript fields
4. Google Sheets Add a Row: write the extracted values to the correct columns

The sheet grows automatically with every qualifying call. The team can filter, sort, and review the log in the familiar Google Sheets interface without touching Make.

Common Pattern 2: Google Sheets as a Trigger for CRM Actions

The Watch New Rows trigger turns a Google Sheet into an automation trigger surface. When a new row appears, Make responds.

Practical example: a sales team adds new prospects to a Google Sheet as they identify them. When a new row appears, Make creates a contact in GoHighLevel, applies the source tag from a column in the sheet, and triggers the initial outreach sequence — the same follow-up pattern described in AI Follow-Up System for Sales. The team works in the spreadsheet they know; the automation handles the CRM work.

For this pattern to work reliably, the sheet needs a consistent column structure — the same columns in the same positions on every row. Make maps columns by position (column A, column B) or by header name if you have a header row. Header-based mapping is more maintainable because it survives column reordering.

Common Pattern 3: Lookup and Update

A common pattern for syncing data between systems involves looking up whether a record exists in a sheet and then either updating it or adding a new row.

Scenario: a payment comes through Stripe. You want to update the corresponding row in a payment tracking sheet with the payment status. If the row exists (customer already in the sheet), update it. If it does not exist, add a new row.

Structure:

1. Webhook from Stripe payment event
2. Google Sheets Search Rows: search the Customer Email column for the payer email
3. Router: Branch 1 if rows found (has results), Branch 2 if not
4. Branch 1: Google Sheets Update a Row with the payment status and date
5. Branch 2: Google Sheets Add a Row with the full customer and payment data

The key in the Update a Row module is getting the row number. Search Rows returns the row number as part of the result. Map {{2.rowNumber}} (from the Search Rows module output) into the Row Number field of the Update a Row module.

Common Pattern 4: Scheduled Batch Processing

Some workflows need to process all rows in a sheet on a schedule — nightly reporting, daily syncs, weekly cleanup.

Make.com handles this with the Get All Rows module (or Search Rows without a filter to return all rows) combined with an Iterator. The scenario triggers on a schedule, retrieves all rows, and processes each one in turn.

For large sheets, be mindful of Make.com operation count. Each row returned from Get All Rows counts as one operation when passed through an Iterator. A sheet with 500 rows costs 500+ operations per scheduled run. Design batch processing scenarios carefully and consider whether you actually need to process every row or just rows that meet specific criteria. The Make.com Pricing Calculator helps you check this math against your plan before it becomes a surprise.

Working With Named Ranges and Multiple Sheets

Most Google Sheets modules in Make allow you to specify which sheet (tab) within a spreadsheet to work with. Always specify the sheet name explicitly rather than relying on defaults, especially for spreadsheets with multiple tabs.

For complex spreadsheets with data across multiple tabs, you may need separate module instances for each tab. Make does not natively support cross-tab operations in a single module call.

If your sheet uses named ranges, you can reference them in some modules for cleaner configuration that is more resilient to column changes than position-based references.

Handling Formatting and Data Types

Google Sheets stores values in ways that can trip up automation if you are not careful.

Dates. Sheets stores dates as serial numbers internally. When you read a date cell through the API, Make converts it to an ISO 8601 string. When you write a date to Sheets, format it as a string in the format Sheets expects: YYYY-MM-DD for date columns formatted as dates. If the formatting looks wrong in Sheets after writing, check the cell format settings in the sheet itself.

Numbers. Numbers read from Sheets come through as strings if the column is formatted as text. If you need to perform math on a value from Sheets, wrap it in a parseNumber() function in Make to convert it explicitly.

Empty cells. When a row has empty cells, Make returns them as empty strings or undefined depending on the module and position. Add null checks in downstream modules if your logic depends on whether a cell has a value.

For verifying data structures coming out of the Google Sheets modules before mapping them downstream, the JSON Formatter is useful for visualising complex row structures clearly.

Rate Limits and Performance

The Google Sheets API has a rate limit of 60 requests per minute per user per project. For most small business Make.com integrations, this is not a concern. For high-volume batch operations that call the Sheets API repeatedly in quick succession, you may hit this limit.

If you see rate limit errors (HTTP 429 from Google), add a Sleep module between iterations or switch to a batch approach that writes multiple rows in a single API call where possible. Make.com's Bulk operations in some Google Sheets module versions allow writing multiple rows at once, which is more efficient than writing row by row.

Building Something Specific?

The Make.com Google Sheets integration is one of the most versatile in the platform because of how widely Sheets is used as a business data layer. Whether you are building a simple logging automation or a complex bidirectional sync between Sheets and a CRM, the patterns above provide the foundation — and they show up constantly in the client automation stacks I build, usually as the reporting or logging layer sitting behind a voice agent or CRM workflow.

If you want help building a specific Google Sheets integration in Make or are running into issues with row lookups or data formatting, book a free 30-minute call. Bring your sheet structure and the automation outcome you need and we will work through the implementation together.