Every business has one: the inbox that’s secretly a database. Orders, invoice copies, form notifications, receipts — all landing in Gmail, all needing to eventually live in a spreadsheet where a human can actually work with them. Copy-pasting them is the task everyone intends to stop doing “next week” and does for three years.

This is the exact automation we set up for a client’s order emails, taking about 15 minutes in either Make or Zapier. We’ll build the Make version (our preference for this pattern — the visual flow makes the field mapping easier to verify), and note where Zapier differs.

What you’ll build

Gmail (new email matching search)
  → parse fields from the email
  → (optional) skip if already in the sheet
  → Google Sheets (add row)

By the end, an email like “New order #4521 from Jane Doe, jane@example.com, $189.00, Pro plan” becomes a spreadsheet row with the order number, name, email, amount, and plan in separate columns — no human touching anything.

Prerequisites

  • A Gmail account (Google Workspace works the same)
  • A Google Sheet with header row already created
  • A Make or Zapier account
  • 15 minutes

Step 1: Trigger on the right emails

In Make, create a new scenario and add a Gmail → Watch Emails module. The critical setting is the search query — don’t trigger on everything:

from:orders@yourvendor.com subject:"New order" is:unread

Using a specific sender and subject filter means the automation only fires on emails with predictable structure. This one setting is the difference between an automation that runs for a year and one that quietly creates garbage rows from reply-all threads.

Zapier equivalent: Gmail → “New Email Matching Search,” same query syntax.

Step 2: Extract the fields

Here’s where the email’s structure matters. Two paths, depending on how well-behaved your sender is:

Path A — reliably formatted emails: use Make’s Text Parser → Match Pattern module with a regular expression. For an email body like:

Order number: 4521
Customer: Jane Doe
Email: jane@example.com
Total: $189.00
Plan: Pro

the pattern Order number:\s*(\d+) with a capture group grabs 4521, and one module per field (or one regex with named groups) fills your columns. Clunky but bulletproof.

Path B — messy emails: use an AI extraction step. Make’s OpenAI (or Anthropic) module with a prompt like:

Extract from this email and return JSON with fields: order_number, customer_name, customer_email, total_amount, plan_name. Return null for any field you can’t find.

Then a JSON parser module turns the response into mappable fields. This costs a fraction of a cent per email and handles format drift gracefully. The catch: add a validation step (a router checking for nulls) so malformed emails get flagged to a human instead of creating broken rows.

We run Path A for the vendor whose format never changes and Path B for everything else. Path B has an ongoing token cost but survives the vendor redesigning their email template — which they will, eventually, without telling you.

Add a Google Sheets → Search Rows module before the append. Search for the order number (or email + date combination); if found, route to an “ignore” path; if not, continue to the append. Gmail triggering twice on the same email is rare but real — usually after a reconnection or an automation error mid-run — and duplicates are annoying to clean out of a sheet that people trust.

Step 4: Append the row

Google Sheets → Add a Row, map your parsed fields to columns, done. Make sure the sheet has a header row and that you map to the correct spreadsheet/worksheet — Make’s module dropdown lists every sheet your Google account can reach, and picking the client’s “test sheet v3” instead of the real one is a rite of passage.

Step 5: Handle the failures

Set the scenario’s error handler to email you when the run fails. In Make, this is the scenario settings (the wrench icon) → “if an error occurs” → send email to yourself. The most common failures, in order of our observed frequency:

  1. The sender changed their email format — your regex/parse returns nulls. Fix: update the pattern or switch to Path B extraction.
  2. Google auth expired — reconnect the account; happens after password changes. Both tools handle this gracefully as long as you notice.
  3. Gmail API rate limits — only at silly volumes; if you hit this, batch instead of per-email triggering.

A worked example: the catering company that stopped losing orders

To make the whole picture concrete, here’s the first client we deployed this exact flow for — a three-person catering company that took orders through a food-industry marketplace. Every morning, 10-25 order emails arrived from the marketplace, and someone spent 40 minutes transcribing them into a Google Sheet the kitchen used for prep lists. Orders were occasionally missed entirely — roughly two a month, each worth $300-800 — and the transcription itself introduced errors: wrong quantities on a Friday rush produced one very apologetic phone call to a corporate client.

We built the Path A version in 20 minutes (their marketplace’s emails were rigidly formatted), added the dedup search step, and ran it in parallel with manual entry for two weeks. The parallel run caught the two failure modes it needed to: one duplicated order when the Gmail connection dropped and re-fetched (the dedup search caught it), and one malformed email when the marketplace ran a one-day promo that changed the subject line (the subject:"New order" filter simply didn’t fire, and the missing row was obvious the next morning because the row count didn’t match the inbox).

After cutover, the numbers: 40 minutes a day of transcription eliminated (about 17 hours a month, roughly $460 at their admin’s loaded cost), missed orders went to zero because a missing row became visible within hours instead of at delivery time, and the two-a-month miss-cost stopped. Total cost: Make free tier, because 25 emails a day × 5 operations is about 3,700 operations a month — just under the free tier’s 1,000-op cap. Wait, no — that’s over, so they’re on Core at $9/month. The whole setup paid for itself with the first prevented missed order.

The point of the story isn’t the catering company — it’s that the automation’s biggest value wasn’t the hours saved, it was the error elimination. The hours were the visible win; the two missed orders a month were the real one.

Troubleshooting checklist

When your version of this flow misbehaves (it will, eventually), run down this list before touching anything else:

  • Symptom: no rows appearing, no errors. Cause: the Gmail search filter doesn’t match — usually the sender changed an address (orders@ → noreply@) or the subject got a suffix (“New order” → “New order ✅”). Fix: search Gmail manually with the exact query string and confirm it returns the emails you expect. If it doesn’t, your automation is correctly doing nothing.
  • Symptom: rows appear with null/empty fields. Cause: the parse pattern stopped matching — sender added a line, changed “Order number” to “Order #”, or the amount format changed from $1,234.56 to 1234.56 USD. Fix: copy a fresh email body into a regex tester, rebuild the pattern, and re-run. If the sender’s format drifts repeatedly, switch to Path B.
  • Symptom: “Authorization expired” or “invalid credentials” errors. Cause: Google password change or security-policy update dropped the OAuth token. Fix: open the scenario, reconnect the Gmail and Sheets connections, run once manually. Both tools make this a two-click fix once you know to look for it.
  • Symptom: duplicate rows. Cause: Gmail module re-fetching the same message — typically after a connection drop or a scenario error mid-run, where the module didn’t record the message as processed. Fix: the dedup search step (Step 3) exists precisely for this; if you skipped it, add it now, then clean the existing duplicates manually once.
  • Symptom: dates in the sheet are hours off. Cause: the UTC default somewhere in the chain. Fix: set the scenario’s timezone in scenario settings to yours, and re-map the date field using the format function with your timezone — not the raw Gmail timestamp.

Tool differences: Make vs Zapier for this exact flow

Same pattern, but the implementations differ in ways that matter:

  • Trigger latency: Zapier fires within seconds of email arrival; Make’s free tier polls every 15 minutes. For order emails feeding a prep list that’s read at 6am, 15 minutes is irrelevant. For leads, it’s not — use your judgment.

  • The parse step: Make’s Text Parser with regex is more transparent (you see the pattern and the matched groups side by side); Zapier’s Formatter is friendlier but hides the regex, which means when it breaks you’re clicking through menus instead of editing one line.

  • The dedup search: Zapier’s “Lookup Row” action with a fallback path is arguably cleaner than Make’s search module for this; if you’re in Zapier, use it.

  • Operation/task math: the full flow with dedup costs 5-6 Make operations per email versus 4-5 Zapier tasks. Nearly a wash; don’t let it decide the tool.

  • Make’s Gmail module polls on a schedule, not instantly. Default is every 15 minutes on free plans. For near-real-time rows, that’s fine for 99% of uses; if you need instant, Zapier’s triggering is faster out of the box.

  • Timezone bugs in date fields. Make and Zapier both default to UTC somewhere in the chain. If your sheet has a “received date” column and it’s off by hours, that’s why — set the scenario timezone explicitly in settings.

  • Emails with attachments we didn’t want. The row-append doesn’t care, but if you later add a “save attachment to Drive” step, filter by file extension first or you’ll archive every corporate signature image ever sent.

  • The free-tier operation math. This scenario costs ~4-6 operations per email in Make. At 100 emails a month that’s 500 operations — comfortably free tier. At 1,000 emails a month you’re at Core-plan territory ($9/mo). Fine, but know the number.

Where to take it next

Once the rows land reliably, the natural extensions:

  • Slack notification for orders over a threshold (“flag anything over $500 for manual review”)
  • Daily digest instead of per-email rows, if the sheet is more archive than workspace
  • The reverse direction — mail-merge FROM the sheet through Gmail ( Sheets row added → personalized email), which is the same machinery run backwards and takes another 10 minutes

The order-emails-to-spreadsheet flow is usually the first automation we build for any new client, because it’s fast, visibly impressive, and teaches the concepts (trigger, parse, dedupe, append) that every later automation reuses. If this is your first automation, it’s the right one.