Finance & Invoicing

Every finance team faces the same slow, error-prone cycle: invoices arrive by email, someone manually logs them in a spreadsheet, another person checks if the vendor looks legitimate, and a third person tries to figure out how this payment affects the month-end cash position. This tutorial shows you how to collapse all four of those steps into a single n8n workflow powered by Google Gemini AI, one that analyzes invoices for fraud, logs them automatically, predicts cash flow impact, and emails a report to your team.

By the end you’ll have a live automation that accepts invoice submissions through a form, uses Gemini Flash to flag anomalies and classify spend categories, alerts your Slack channel when a high-risk invoice appears, appends every invoice to a Google Sheets financial database, runs a 30-day cash flow prediction, and delivers a formatted HTML report via Gmail. Total setup time: about 30 minutes.

Want to skip the build and get the ready-to-import template? Download the workflow + setup guides here.

What the Workflow Does

Here’s the full automation at a glance:

1. Invoice Upload Form: An n8n form page your team can bookmark. Vendors or staff submit invoice details (vendor, amount, dates, description).
2. Format Invoice Data: A Code node that normalizes the input, calculates days-until-due, and timestamps the submission.
3. AI Invoice Analyzer (Gemini): Sends the invoice to Gemini Flash with a structured prompt. Returns fraud risk level, spend category, payment priority, and a one-line summary, all as JSON.
4. Parse AI Response: Extracts the JSON from Gemini’s output with a safe fallback in case of model formatting errors.
5. Fraud Risk Check (IF node): Routes the flow: high-risk invoices go to Slack and Google Sheets; normal invoices go directly to Sheets.
6. Send Fraud Alert to Slack: Posts a formatted block message to #fraud-alerts with vendor, amount, and a list of the specific risk reasons Gemini identified.
7. Log to Financial Database: Appends a row to your Google Sheets invoice tracker (12 columns: date, vendor, amount, category, fraud risk, etc.).
8. Cash Flow Predictor (Gemini): A second Gemini chain that takes the logged invoice data and returns a cash flow assessment: impact direction, urgency score 1 to 10, recommended payment date, and three action items.
9. Email Cash Flow Report: Sends a formatted HTML email via Gmail with the full analysis: everything from fraud risk to recommended payment date.

Prerequisites

Before you import the workflow, make sure you have the following:

• n8n: self-hosted (v1.0+) or n8n Cloud. The workflow uses nodes available in both.
• Google Gemini API key: Free tier works for low volumes. Get yours at aistudio.google.com.
• Google Sheets: Create a spreadsheet called “Invoice Tracker” with a sheet tab named “Invoices”. Leave the first row for headers (the workflow will create them on first run).
• Slack workspace: Create a #fraud-alerts channel (or rename to match an existing one).
• Gmail account: Any Gmail or Google Workspace account for sending reports.

Step-by-Step Setup

1Import the Workflow into n8n

Download the .json file from the template package. In n8n, click + New Workflow → Import from File. Select the JSON and click Import. The canvas will load with all 16 nodes connected and labeled.

2Connect Your Credentials

Open each node that has a credential warning (indicated by a red dot) and connect the appropriate account:

The Credentials Guide PDF (included in the download) walks through each one with exact screenshots and scopes required.

3Update the Two Placeholders

Open the Log to Financial Database node. In the Document ID field, replace YOUR_SPREADSHEET_ID with your Google Sheets spreadsheet ID, the long alphanumeric string in the sheet’s URL between /d/ and /edit.

Open the Email Cash Flow Report node. In the To field, replace YOUR_FINANCE_EMAIL@company.com with the email address that should receive cash flow reports.

4Set Up Your Google Sheet Structure

The workflow will auto-append rows, but it expects the “Invoices” sheet to exist. Open your spreadsheet, rename Sheet1 to Invoices, and optionally add these headers in row 1 (the workflow will use them for column matching):

Submitted At | Vendor | Invoice Number | Invoice Date | Due Date | Amount | Currency | Category | Fraud Risk | Fraud Reasons | Payment Priority | Summary

5Configure the Slack Alert Channel

Open the Send Fraud Alert to Slack node. The default channel is #fraud-alerts. Change this to match your Slack channel name. Make sure the Slack app you connected has the chat:write permission scope.

6Test with a Sample Invoice

Before activating, run a manual test. Click the Invoice Upload Form node, then click Test Step → Open Test URL. A form page opens in your browser. Submit a test invoice:

• Vendor: Test Vendor Ltd
• Invoice #: INV-2024-001
• Amount: 9999 (high amount triggers fraud check)
• Due Date: tomorrow’s date (short due date = fraud indicator)
• Description: leave blank (missing description = another indicator)

This combination should produce a high fraud risk result, triggering the Slack alert path. Watch the n8n canvas. Green checkmarks confirm each node ran successfully.

7Activate and Share the Form URL

Once your test passes, toggle the workflow to Active. Go back to the Invoice Upload Form node and copy the production form URL. Share this with your team or embed it in your internal tools documentation. Anyone with the link can submit invoices, no n8n account needed.

Understanding the Gemini Prompts

The workflow uses two separate Gemini chains, each with a specific job. Understanding them helps you customize the AI behavior.

Invoice Analysis Prompt

The first chain asks Gemini to evaluate fraud risk based on five signals: unusually round amounts, very short due dates (under 3 days), missing service descriptions, high total amounts, and suspicious vendor name patterns. It returns a structured JSON object with fraudRisk (low/medium/high), fraudReasons (an array of specific red flags), category (spend type), and paymentPriority.

You can tune the sensitivity by editing the prompt in the AI Invoice Analyzer node. For example, adding your company’s typical invoice range (e.g., “invoices over $50,000 require extra scrutiny”) will make the fraud detection more context-aware.

Cash Flow Prediction Prompt

The second chain receives the analyzed invoice plus the days-until-due count and asks Gemini to assess impact on your 30-day cash position. It returns cashFlowImpact (positive/negative/neutral), an urgencyScore from 1 to 10, a recommendedPaymentDate, and three concrete actionItems.

The model used in both chains is Gemini 1.5 Flash, fast and affordable. For larger invoices or more complex categorization, you can switch the model name to models/gemini-1.5-pro in both Gemini nodes with no other changes required.

Customization Ideas

• Add a budget limit check: Insert an IF node after the Sheets log to check if amount > 10000 and route those to a separate “large purchase approval” Slack channel.
• Multi-approver flow: For high-priority invoices, add a Wait node + webhook to pause the workflow until a manager clicks an approval link in Slack or email before the report is sent.
• Recurring invoice detection: Add a Google Sheets read step to compare the vendor name against your existing database. Flag invoices from known vendors that arrive outside their normal billing cycle.
• Currency conversion: Insert an HTTP Request node before the Sheets log to call a live exchange rate API (e.g., Frankfurter) and normalize all amounts to your base currency.
• Airtable instead of Google Sheets: Replace the Google Sheets node with an Airtable “Create Record” action. The data structure maps 1:1.

Troubleshooting

Gemini returns text instead of JSON: The prompt explicitly says “no markdown, no code fences.” If Gemini occasionally wraps the JSON in triple backticks, the Parse AI Response Code node handles this with a regex fallback. No action needed.

Google Sheets “Resource not found” error: Double-check the spreadsheet ID in the Log to Financial Database node. The ID is the long string in your sheet URL: https://docs.google.com/spreadsheets/d/THIS_PART/edit.

Slack “channel_not_found” error: Make sure the Slack app is installed in the workspace and the channel name in the node matches exactly (including the # or without it, n8n accepts both).

Form not accessible after activation: The form URL only works when the workflow is active. Check the toggle in the top-right of the workflow editor.

The Complete Node Structure

If you’ve got funds in Aave V3, you’ve probably had the thought: “What if my health factor drops while I’m asleep and I get liquidated?” Checking manually every few hours isn’t realistic, and missing a warning can cost thousands of dollars. This guide shows you how to build a fully automated Aave portfolio monitor using n8n, the Moralis blockchain API, and GPT-4o-mini, delivering polished health reports straight to your Telegram and email on a fixed schedule. You’ll build it step by step, understand every node, and walk away with a system that protects your DeFi positions around the clock.

Prefer to skip the setup? Grab the ready-made template → and have it running in under 10 minutes.

What You’ll Build

1. A scheduled n8n workflow that fires every hour (or any interval you choose).
2. A Google Sheets wallet list: add or remove wallets without touching n8n at all.
3. An AI Agent powered by GPT-4o-mini that calls three Moralis endpoints to fetch your Aave V3 positions, health factors, and liquidation risk.
4. An automated Telegram message summarizing each wallet’s position in readable format.
5. A formatted HTML email delivered to your inbox with the same data, beautifully styled.

How It Works: The Big Picture

┌────────────────────────────────────────────────────────────────────────┐
│  AAVE PORTFOLIO AI AGENT — n8n Workflow                                │
│                                                                        │
│  [Schedule Trigger]                                                    │
│       │ (every hour)                                                   │
│       ▼                                                                │
│  [Google Sheets] ──── reads wallet_address rows                        │
│       │                                                                │
│       ▼                                                                │
│  [Set Variables] ──── Wallet_Address, current_date                     │
│       │                                                                │
│       ▼                                                                │
│  [AAVE Portfolio AI Agent]  ◄── GPT-4o-mini (OpenAI Chat Model)        │
│       │         ◄── [Fetch DeFi Protocol Summary]  (Moralis)           │
│       │         ◄── [Fetch DeFi Positions Summary] (Moralis)           │
│       │         ◄── [Fetch Aave V3 Positions]      (Moralis)           │
│       │                                                                │
│       ├──────────────────────────────────────┐                         │
│       ▼                                      ▼                         │
│  [Send Telegram Report]            [Format Email Report]               │
│  (instant Telegram message)               │                            │
│                                           ▼                            │
│                                  [Send Email Report]                   │
│                                  (Gmail HTML email)                    │
└────────────────────────────────────────────────────────────────────────┘

The workflow loops through every row in your Google Sheet, running the full AI analysis for each wallet address. You can monitor as many wallets as you want. Just add another row.

What You’ll Need

• n8n: self-hosted (free) or n8n Cloud (~$20/mo). If you don’t have it, install n8n first.
• Google account: for Google Sheets and Gmail (OAuth2).
• Moralis account: free tier available at moralis.io. Generous free limits for personal use.
• OpenAI account: pay-per-use, roughly $0.0002 per report generation.
• Telegram bot: free, created via @BotFather in under 2 minutes.
• Build time: ~45 to 60 minutes from scratch. Using the template: under 10 minutes.

Step 1: Set Up Your Google Sheets Wallet List

Before touching n8n, create your wallet tracker spreadsheet. This is where the workflow reads wallet addresses each time it runs, with no code changes needed to add or remove wallets.

| wallet_address                             |
|--------------------------------------------|
| 0xA221674eDB403A8F714F66Af74a2332c3CB5C0c3 |
| 0x742d35Cc6634C0532925a3b8D4C9E7A2B1234567 |

Step 2: Set Variables: Wallet Address + Current Date

The Set Wallet Variables node extracts the wallet address from the sheet row and generates today’s date. These values are referenced by every downstream node.

{
  "Wallet_Address": "0xA221674eDB403A8F714F66Af74a2332c3CB5C0c3",
  "current_date": "2026-04-10"
}

Step 3: The AI Agent + Three Moralis Tools

This is the engine of the workflow. An n8n AI Agent (powered by GPT-4o-mini) orchestrates three HTTP Request Tool nodes to pull live Aave data from Moralis, then writes a structured health report.

Step 3a: OpenAI Chat Model

The OpenAI Chat Model node connects to the AI Agent as its language model. Configure it with your OpenAI API key and set the model to gpt-4o-mini: fast, cheap, and more than capable for data formatting tasks.

{
  "protocols": [
    { "protocol_name": "aave-v3", "chain": "eth", "positions": 3 },
    { "protocol_name": "uniswap-v3", "chain": "eth", "positions": 1 }
  ]
}

{
  "active_protocols": 2,
  "total_usd_value": "22415.50",
  "protocol_breakdown": [
    {
      "protocol": "aave-v3",
      "supply_usd": "15000.00",
      "borrow_usd": "7500.00",
      "net_usd": "7500.00"
    }
  ]
}

{
  "positions": [
    {
      "pool_address": "0x87870...",
      "pool_name": "Aave Lending Pool",
      "supply_balance_usd": "15000.00",
      "borrow_balance_usd": "7500.00",
      "collateral_value_usd": "15000.00",
      "health_factor": "1.87",
      "liquidation_threshold": "0.85",
      "liquidation_risk": false,
      "underlying_assets": [
        { "name": "Wrapped Ether", "symbol": "WETH", "balance": "4.2500" },
        { "name": "USD Coin", "symbol": "USDC", "balance": "5000.00" }
      ]
    }
  ]
}

Step 3b: The AI Agent System Prompt

The AI Agent’s system prompt instructs GPT-4o-mini to call all three tools, collect the data, and format it into a structured Telegram-friendly report. Key formatting rules embedded in the prompt:

• Format large numbers with commas: 15,000 not 15000
• Display ETH values to 4 decimal places
• Flag health factors below 1.2 with a ⚠️ liquidation risk warning
• If no Aave V3 positions found, send: ❌ No Aave V3 positions found for this wallet.

Example Telegram output generated by the AI:

📊 Aave DeFi Health Report
Wallet: 0xA221674...CBf0c3
Date: 2026-04-10

▪️ Pool: Aave Lending Pool
• Supply: $15,000.00
• Borrowed: $7,500.00
• Collateral: $15,000.00
• Health Factor: 1.87
• Liquidation Threshold: 85%
• Liquidation Risk: No ✅

Underlying Assets:
- Wrapped Ether (WETH): 4.2500
- USD Coin (USDC): 5,000.00

Step 4: Format the Email Report

The Format Email Report Code node takes the AI Agent’s plain text output and wraps it in an HTML email template: clean, readable, and professional.

const aiOutput = $json.output || "No data available.";
const date = new Date().toISOString().split('T')[0];

const walletMatch = aiOutput.match(/Wallet:\s*(0x[a-fA-F0-9]{40})/);
const wallet = walletMatch ? walletMatch[1] : "Unknown Wallet";

const htmlFormatted = aiOutput
  .replace(/---/g, '<hr>')
  .replace(/\n{2,}/g, '<br><br>')
  .replace(/\n/g, '<br>');

const htmlBody = `
  <div style="font-family: Arial, sans-serif; font-size: 14px; line-height: 1.6;">
    <h2 style="color: #1a56db;">Aave DeFi Health Report — ${date}</h2>
    ${htmlFormatted}
  </div>
`;

return [{ json: { wallet, subject: \`🛡️ Aave DeFi Health Report – ${date}\`, htmlBody } }];

Step 5: Send Telegram + Email

The AI Agent’s output splits into two parallel branches, one for Telegram, one for email, so you get both notifications simultaneously.

The Data Structure: Google Sheets Schema

The Google Sheet that drives this workflow is intentionally minimal. Here’s the full schema:

Sample sheet layout:

Full System Flow

  Google Sheet (wallet addresses)
          │
          ▼
  Row: { wallet_address: "0xA221..." }
          │
          ▼
  Set Variables → { Wallet_Address, current_date }
          │
          ▼
  AI Agent ────► Moralis /defi/summary          → protocol list
             ├──► Moralis /defi/positions        → supply/borrow totals
             └──► Moralis /defi/aave-v3/positions → health factor, assets
          │
          ▼
  GPT-4o-mini formats report
          │
    ┌─────┴─────────────────────┐
    ▼                           ▼
Telegram: text message    Code Node: HTML wrap
                               │
                               ▼
                         Gmail: HTML email

Testing Your Workflow

Run through this sequence to confirm everything is wired correctly:

1. Add one known Aave V3 wallet to your Google Sheet (you can find examples on Etherscan by checking Aave V3 contract interactions).
2. Click Test workflow in n8n.
3. Watch the execution, each node should show a green checkmark.
4. Check your Telegram, you should receive a formatted report within 15 to 30 seconds.
5. Check your Gmail inbox, the HTML email should arrive within a minute.

Frequently Asked Questions

How much does this cost to run?

The Moralis free tier gives you 40,000 compute units per month. Each wallet scan uses roughly 15 to 30 CU (three API calls). For 5 wallets scanned every hour: ~1,080 wallet scans/month = ~32,400 CU, comfortably within the free limit. OpenAI GPT-4o-mini costs approximately $0.0002 per report. For 5 wallets × 24 hourly runs = ~$0.024/day. Well under a dollar per day.

Can I monitor wallets on other chains, not just Ethereum?

Yes. Moralis supports multiple chains including Polygon, Arbitrum, Base, Optimism, and more. You’d need to modify the API endpoint URLs to include the chain parameter (e.g., ?chain=polygon). The rest of the workflow stays the same. For a multi-chain setup, consider adding a chain column to your Google Sheet alongside wallet_address.

What happens if a wallet’s health factor drops below 1.2?

The AI Agent is instructed to flag this with a ⚠️ warning in the Telegram message and email. However, this workflow is a monitoring system: it doesn’t automatically add collateral or repay debt. If you want automated liquidation protection, you’d need to extend the workflow with an Aave protocol interaction node (which requires additional DeFi-specific tooling).

Can I add more wallets without restarting the workflow?

Yes, that’s the whole point of the Google Sheets design. Just add a new row to your sheet with the wallet address. The next scheduled run will pick it up automatically. No changes to n8n required.

Can I run this more frequently than every hour?

Absolutely. Open the Schedule Trigger node and change the interval to 30 minutes, 15 minutes, or even every 5 minutes. Just be mindful of your Moralis API usage at higher frequencies.

Is gpt-4o-mini accurate enough for DeFi data analysis?

GPT-4o-mini is not doing the math; it’s formatting pre-calculated data from Moralis. The health factor, supply/borrow values, and liquidation thresholds come directly from Moralis’s API (which sources from on-chain data). GPT-4o-mini just turns that structured data into readable text. Accuracy of the underlying numbers is entirely dependent on Moralis data quality, which is production-grade.

Get the Ready-Made Template

What’s Next

• Multi-chain support: Extend the Moralis calls to Polygon or Arbitrum by adding a ?chain=polygon parameter and a chain column in your Google Sheet.
• Slack alerts: Replace or add a Slack node alongside the Telegram node to notify your team’s DeFi channel.
• Notion dashboard: Store each report run in a Notion database for historical health factor tracking and trend analysis.
• Threshold alerts only: Add an IF node before the Telegram/email nodes so you only get notified when the health factor falls below a custom threshold (e.g., 1.3), reducing notification noise.

Every successful Stripe payment should trigger a professional invoice, but wiring that up manually is tedious and error-prone. Maybe you’re copying payment details into a Google Doc, exporting Stripe receipts one by one, or worse, forgetting to send invoices entirely. Your customers deserve better, and your bookkeeping shouldn’t depend on you remembering to open a spreadsheet at 11 PM.

In this guide, you’ll build an n8n workflow that listens for Stripe payments in real time, generates a polished HTML invoice, emails it to the customer through Gmail, and logs every transaction to Google Sheets, all without writing a single line of code outside the workflow editor. The whole thing runs on autopilot once you flip the switch.

Prefer to skip the setup? Grab the ready-made template → and be up and running in under 10 minutes.

What You’ll Build

1. A customer completes a payment on your Stripe-powered site or app.
2. Stripe fires a webhook to your n8n instance within seconds.
3. n8n validates the event, extracts the payment details, and generates a branded HTML invoice.
4. The invoice is emailed to the customer via your Gmail account: professional layout, correct amounts, zero manual effort.
5. Every payment is simultaneously logged to a Google Sheet so you have a running financial record.

How It Works: The Big Picture

The workflow is a single linear pipeline with one branch at the end. Stripe pushes the data in, n8n processes it, and two outputs happen in parallel: the customer gets their invoice, and your spreadsheet gets a new row.

┌───────────────────────────────────────────────────────────────────────────┐
│  AUTO-SEND INVOICES ON STRIPE PAYMENT                                     │
│                                                                           │
│  [Stripe Webhook] → [Validate Event] → [Extract Details] → [Build Email] │
│                                                              ↓         ↓  │
│                                                     [Send Gmail]  [Log to │
│                                                                   Sheets] │
└───────────────────────────────────────────────────────────────────────────┘
  

What You’ll Need

• A Stripe account with at least one product or payment link configured. Free to set up. You only need access to the Developers → Webhooks section.
• A Gmail account for sending invoices. Any Google Workspace or personal Gmail works.
• A Google Sheets spreadsheet to serve as your payment log. Create a blank sheet named “Payments” with the column headers listed in the Data Structure section below.
• An n8n instance, self-hosted or n8n Cloud. The webhook node needs to be publicly reachable so Stripe can POST to it.

Estimated build time: 25 to 35 minutes from scratch, or under 10 minutes with the template.

Building the Workflow Step by Step

1 Stripe Payment Webhook (Webhook)

This is your entry point. The Webhook node creates a unique URL that Stripe will POST to every time a payment event occurs. Once the workflow is active, n8n listens at this URL around the clock.

1. Add a Webhook node to the canvas.
2. Set HTTP Method to POST.
3. Set Path to stripe-invoice-webhook (or any slug you prefer).
4. Leave Response Mode as “When node receives data”. This immediately returns a 200 OK to Stripe so it doesn’t retry.
5. Save the workflow and copy the Production URL shown at the top of the node panel.

After completing this step, the webhook data structure will look like this when Stripe sends a payment_intent.succeeded event:

{
  "id": "evt_3PqR7sLk2xYaB9c0",
  "type": "payment_intent.succeeded",
  "data": {
    "object": {
      "id": "pi_1NrQ8fLk2xYaB9c0RvK4mT3z",
      "amount": 4999,
      "currency": "usd",
      "receipt_email": "james.carter@gmail.com",
      "billing_details": {
        "name": "James Carter",
        "email": "james.carter@gmail.com"
      },
      "description": "Pro Plan — Annual Subscription",
      "payment_method_types": ["card"]
    }
  }
}

2 Validate Payment Event (IF)

Stripe might send test events, retries, or events you didn’t filter at the dashboard level. This IF node acts as a gatekeeper. It only lets payment_intent.succeeded events through.

1. Add an IF node and connect it to the webhook output.
2. Set the condition: {{ $json.type }} equals payment_intent.succeeded.
3. The “true” branch continues to the next step. The “false” branch ends silently, no action needed for irrelevant events.

3 Extract Payment Details (Code)

Stripe’s webhook payloads are deeply nested. This Code node reaches into the payload, pulls out the fields you actually need, generates a unique invoice number, and packages everything into a flat, clean object that downstream nodes can reference easily.

1. Add a Code node and connect it to the “true” output of the IF node.
2. Paste the extraction script (included in the template). It does the following:
   • Extracts amount (converts from cents to dollars), currency, customer_email, customer_name, and description.
   • Generates an invoice number in the format INV-YYYYMMDD-HHMMSS.
   • Throws an error if no customer email is found, you can’t send an invoice without a recipient.

After extraction, the data looks like this:

{
  "invoice_number": "INV-20260409-143022",
  "payment_id": "pi_1NrQ8fLk2xYaB9c0RvK4mT3z",
  "amount": "49.99",
  "currency": "USD",
  "customer_email": "james.carter@gmail.com",
  "customer_name": "James Carter",
  "description": "Pro Plan — Annual Subscription",
  "payment_method": "card",
  "payment_date": "April 9, 2026",
  "status": "Paid"
}

4 Build Invoice Email (Code)

This is where the magic happens. A second Code node takes the clean payment data and assembles a fully styled HTML invoice that renders beautifully in every major email client: Gmail, Outlook, Apple Mail, and mobile.

1. Add another Code node after Extract Payment Details.
2. Paste the invoice template script (included in the template). Customize the company details at the top of the script:
   • company.name: your business name
   • company.address and company.city: your business address
   • company.email: your billing email
   • company.color: your brand’s primary hex color (default is #2563EB)

The template produces a clean invoice with a colored header bar, from/to addresses, a line-item table, a total amount callout, and a thank-you footer. It also generates a plain-text fallback for email clients that don’t render HTML.

5 Send Invoice to Customer (Gmail)

The Gmail node sends the HTML invoice as a rich email. No PDF attachment needed. The invoice renders directly in the email body, which is how most modern billing systems (Stripe, Paddle, Gumroad) handle it.

1. Add a Gmail node. Connect it to the Build Invoice Email output.
2. Select your Gmail OAuth2 credential (or create one, see the Credentials Guide).
3. Set To to the expression {{ $json.customer_email }}.
4. Set Subject to {{ $json.email_subject }}.
5. Set Message to {{ $json.invoice_html }}.
6. Under Options, turn off “Append n8n attribution” if you want a clean footer.

6 Log Payment to Google Sheets (Google Sheets)

Every invoice should leave a paper trail. This Google Sheets node appends a row to your payment log spreadsheet, giving you a live financial record that’s easy to search, filter, and export for accounting.

1. Add a Google Sheets node. Connect it to the same Build Invoice Email output (it runs in parallel with the Gmail node).
2. Select your Google Sheets OAuth2 credential.
3. Set Operation to “Append or Update Row”.
4. Choose your spreadsheet and select the “Payments” sheet.
5. Map each column to its corresponding expression: Invoice Number → {{ $json.invoice_number }}, and so on for all 10 columns.

The Data Structure

Create a Google Sheets spreadsheet with a sheet named Payments. Add these column headers in row 1:

Here’s what a few rows look like after the workflow runs:

Full System Flow

┌─────────────────────────────────────────────────────────────────────────────┐
│                                                                             │
│  STRIPE DASHBOARD                        n8n WORKFLOW                       │
│  ───────────────                         ────────────                       │
│                                                                             │
│  Customer pays $49.99                                                       │
│       │                                                                     │
│       ▼                                                                     │
│  payment_intent.succeeded ──POST──→ [Stripe Payment Webhook]               │
│                                           │                                 │
│                                           ▼                                 │
│                                    [Validate Payment Event]                 │
│                                      │ type == "payment_intent.succeeded"?  │
│                                      │                                      │
│                                  YES ▼           NO → (end)                 │
│                                    [Extract Payment Details]                │
│                                      │ invoice_number, amount, email...     │
│                                      │                                      │
│                                      ▼                                      │
│                                    [Build Invoice Email]                    │
│                                      │ HTML invoice + plain text            │
│                                      │                                      │
│                                 ┌────┴────┐                                │
│                                 ▼         ▼                                │
│                          [Send Gmail]  [Log to Sheets]                     │
│                              │              │                               │
│                              ▼              ▼                               │
│                     Customer receives   Row added to                        │
│                     invoice email       Payments sheet                      │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘
  

Testing Your Workflow

1. Activate the workflow in n8n (toggle the Active switch).
2. Send a test event from Stripe: Go to Stripe Dashboard → Developers → Webhooks → select your endpoint → click “Send test webhook” → choose payment_intent.succeeded.
3. Check your Gmail: you should receive the invoice email within a few seconds. Open it and verify the layout renders correctly.
4. Check your Google Sheet: a new row should appear in the Payments sheet with the test data.
5. Make a real test payment using Stripe’s test mode (card number 4242 4242 4242 4242) to verify the full end-to-end flow with real data.

Frequently Asked Questions

What’s Next?

• Add refund handling: Listen for charge.refunded events and send a credit note email using the same invoice template with a negative amount.
• Multi-currency formatting: Add a Code node that formats amounts with the correct currency symbol ($, €, £) and decimal conventions based on the currency field.
• Monthly revenue dashboard: Use a scheduled trigger to pull data from your Payments sheet weekly and send a summary report to your Slack or email.
• Overdue payment reminders: For invoices tied to subscriptions, build a companion workflow that checks for failed payments and sends polite reminder emails.

Every month, the same grind: open an email, download the PDF, squint at the invoice number, manually type the amount into a spreadsheet, and pray you didn’t transpose a digit. If your business processes more than a handful of invoices per week, that manual routine is silently eating hours you could spend on work that actually matters. What if every PDF invoice that landed in your inbox was automatically read, parsed, and filed into a clean database, without you touching it once?

That’s exactly what you’ll build in this guide. Using n8n, OpenAI’s GPT-4o mini, and Airtable, you’ll create a workflow that watches your Gmail inbox for invoice emails, extracts text from attached PDFs, sends that text to AI for structured parsing, and logs every field (vendor name, invoice number, amounts, line items, due dates) into an Airtable base. The whole thing runs on autopilot every 30 minutes.

Prefer to skip the setup? Grab the ready-made template → and be up and running in under 10 minutes.

What You’ll Build

1. A schedule trigger checks your Gmail inbox every 30 minutes for unread emails with PDF attachments matching invoice-related subjects.
2. The workflow downloads the PDF, extracts raw text, and sends it to OpenAI with a carefully tuned prompt that returns structured JSON: vendor name, invoice number, dates, amounts, line items, and payment status.
3. A Code node validates and formats the AI output, then pushes a clean record into your Airtable base with 13 fields covering every detail you’d normally type by hand.
4. The source email is marked as read so it won’t be processed twice.

How It Works: The Big Picture

The workflow runs as a single linear pipeline with one conditional branch. Emails without PDF attachments are silently skipped, while PDFs flow through extraction, AI parsing, and database logging.

┌──────────────────────────────────────────────────────────────────────────┐
│  INVOICE DATA EXTRACTOR — AI POWERED                                     │
│                                                                          │
│  [Schedule]  →  [Gmail: Fetch]  →  [IF: Has PDF?]                       │
│                                         │ Yes          │ No              │
│                                         ↓              ↓                │
│                                  [Extract PDF]    [Skip]                │
│                                         ↓                               │
│                                  [OpenAI: Parse]                        │
│                                         ↓                               │
│                                  [Code: Format]                         │
│                                         ↓                               │
│                                  [Airtable: Save]                       │
│                                         ↓                               │
│                                  [Gmail: Mark Read]                     │
└──────────────────────────────────────────────────────────────────────────┘
  

What You’ll Need

• n8n: self-hosted or cloud (version 1.0 or higher)
• Gmail account: with OAuth2 credentials configured in n8n
• OpenAI API key: with access to the gpt-4o-mini model (or gpt-4o for higher accuracy on complex invoices)
• Airtable account: free tier works fine; you’ll need one base with a table matching the schema below

Estimated build time: 30 to 45 minutes from scratch, or under 10 minutes with the template.

Building the Workflow

1 Check Inbox Every 30 Minutes (Schedule Trigger)

This node kicks off the workflow on a regular interval. Open n8n, create a new workflow, and add a Schedule Trigger node. Set it to run every 30 minutes. You can adjust this later, every 15 minutes if you process high volumes, or once per hour if invoices trickle in slowly.

2 Fetch Unread Invoice Emails (Gmail)

Add a Gmail node and set the operation to Get Many. This node searches your inbox for unread emails that have PDF attachments and match invoice-related subject lines. Configure it as follows:

• Limit: 10 (processes up to 10 emails per run)
• Search query: has:attachment filename:pdf is:unread subject:(invoice OR receipt OR bill)
• Download Attachments: Enabled, with prefix attachment_

The search query is the key here: it filters for only unread emails containing a PDF file whose subject mentions “invoice,” “receipt,” or “bill.” You can customize these keywords to match the vocabulary your vendors use.

{
  "id": "18e3a5b7c9d2f100",
  "subject": "Invoice #INV-2026-0847 from Acme Supplies",
  "from": { "emailAddress": "billing@acmesupplies.com" },
  "attachment_0": {
    "fileName": "INV-2026-0847.pdf",
    "mimeType": "application/pdf"
  }
}

3 Has PDF Attachment? (IF Node)

Add an IF node to verify that the attachment is actually a PDF. Check that attachment_0.mimeType equals application/pdf. Emails that pass go to the extraction step. Emails that fail (wrong attachment type, or the attachment was an image) are routed to a No Operation node and silently skipped.

4 Extract Text from PDF (Extract From File)

Add an Extract From File node. Set the operation to PDF and the binary property name to attachment_0 (matching the prefix you set in the Gmail node). This node converts the PDF binary data into raw text that the AI can read.

After this node runs, the output looks like this:

{
  "data": "INVOICE\nAcme Supplies Inc.\n742 Evergreen Terrace\nSpringfield, IL 62704\n\nBill To: Carter & Associates LLC\nInvoice #: INV-2026-0847\nDate: March 28, 2026\nDue Date: April 27, 2026\n\nDescription          Qty    Price     Amount\nConsulting Services    40   $150.00   $6,000.00\nSoftware License        1   $499.00     $499.00\n\nSubtotal: $6,499.00\nTax (8.25%): $536.17\nTotal: $7,035.17\n\nPayment Terms: Net 30"
}

5 Parse Invoice with AI (OpenAI)

This is where the magic happens. Add an OpenAI node configured for the Chat resource. Set the model to gpt-4o-mini (fast, cheap, and surprisingly accurate for structured extraction) and the temperature to 0.1 (low randomness = consistent output).

The prompt instructs the AI to return a strict JSON object with 12 fields covering every piece of data you’d want from an invoice. Here’s what the prompt asks for:

6 Format Extracted Data (Code Node)

The AI returns a JSON string inside its message content. This Code node does three things: extracts the JSON from the response (handling cases where the AI wraps it in markdown code blocks), validates each field with fallback defaults, and formats the line items array into a human-readable string for Airtable’s long text field.

The node also carries forward metadata from the original email (the subject line and sender address) so you always know where each invoice came from.

{
  "vendor_name": "Acme Supplies Inc.",
  "invoice_number": "INV-2026-0847",
  "invoice_date": "2026-03-28",
  "due_date": "2026-04-27",
  "subtotal": 6499.00,
  "tax_amount": 536.17,
  "total_amount": 7035.17,
  "currency": "USD",
  "payment_status": "unpaid",
  "line_items_text": "1. Consulting Services — Qty: 40 × $150 = $6000\n2. Software License — Qty: 1 × $499 = $499",
  "notes": "Payment Terms: Net 30",
  "source_email_from": "billing@acmesupplies.com",
  "processed_at": "2026-04-08T14:30:00.000Z"
}

7 Save to Airtable

Add an Airtable node set to the Create operation. Point it at your base and table, then map each field from the Code node output to the corresponding Airtable column. The mapping uses n8n expressions like ={{ $json.vendor_name }} to pull values dynamically.

Every processed invoice becomes a new row in your Airtable base, fully structured, searchable, and ready for reporting.

8 Mark Email as Read (Gmail)

The final node marks the original email as read so it won’t be picked up again on the next run. It references the email ID from the “Fetch Unread Invoice Emails” node using the expression ={{ $('Fetch Unread Invoice Emails').item.json.id }}.

The Data Structure

Before activating the workflow, create an Airtable base called “Invoice Tracker” with a single table named “Invoices” using this schema:

Full System Flow

┌──────────────────────────────────────────────────────────────────────────────┐
│                                                                              │
│   GMAIL INBOX                          AIRTABLE                             │
│   ┌──────────────┐                     ┌──────────────────┐                 │
│   │ Unread email  │                     │ Invoice Tracker   │                │
│   │ + PDF attach  │                     │ ┌──────────────┐ │                │
│   └──────┬───────┘                     │ │ Vendor: Acme │ │                │
│          ↓                             │ │ #INV-0847    │ │                │
│   [Schedule: 30 min]                   │ │ $7,035.17    │ │                │
│          ↓                             │ └──────────────┘ │                │
│   [Gmail: Fetch unread]                 └────────▲─────────┘                │
│          ↓                                       │                          │
│   [IF: Has PDF?]──No──→ [Skip]                   │                          │
│          │ Yes                                   │                          │
│          ↓                                      │                          │
│   [Extract PDF Text]                            │                          │
│          ↓                                      │                          │
│   [OpenAI: Parse JSON]                          │                          │
│          ↓                                      │                          │
│   [Code: Format Data]──────────────────────────→┘                          │
│          ↓                                                                 │
│   [Gmail: Mark Read]                                                       │
│                                                                              │
└──────────────────────────────────────────────────────────────────────────────┘
  

Testing Your Workflow

1. Send yourself a test email with a sample PDF invoice attached. Use a subject line like “Invoice #TEST-001 from Test Vendor” so it matches the search query.
2. In n8n, click Test Workflow (the play button) to trigger a manual run.
3. Watch the execution. Each node should show a green checkmark. Click any node to inspect its output data.
4. Check your Airtable base. You should see a new row with all 13 fields populated from the test invoice.
5. Verify the original email is now marked as read in Gmail.

Frequently Asked Questions

What’s Next?

• Add Slack notifications: send a message to your #accounting channel whenever a high-value invoice (over $5,000) is processed.
• Auto-flag overdue invoices: add a second scheduled workflow that checks Airtable daily and flags rows where the due date has passed and payment status is still “unpaid.”
• Build a payment approval flow: route invoices above a threshold to a manager via email for approval before marking them as “approved” in Airtable.
• Connect to accounting software: push the structured data into QuickBooks, Xero, or FreshBooks via their APIs to eliminate double entry entirely.

Missing a Bitcoin pump or getting wrecked by a sudden drop you didn’t see coming. That’s the hidden cost of watching charts manually. Most crypto traders either stare at their screen all day or miss the exact moment they needed to act. This tutorial shows you how to build an automated Telegram bot that watches your chosen coins every 15 minutes and pings you the instant prices break your personal alert thresholds, or when any coin moves more than 5% in 24 hours. No coding background required. Just n8n, a free CoinGecko API key, and a Telegram bot.

Prefer to skip the setup? Grab the ready-made template → and be up and running in under 10 minutes.

What You’ll Build

1. A scheduled n8n workflow that fires every 15 minutes and fetches live prices for Bitcoin, Ethereum, Solana, BNB, and XRP from CoinGecko’s free API.
2. A smart code node that checks each coin against your custom price thresholds (e.g., “alert me when BTC goes above $75,000 or below $55,000”) and flags any coin with a 24-hour move greater than 5%.
3. A conditional gate that only fires when something actually matters, with no noisy, irrelevant pings.
4. A clean, formatted Telegram message delivered straight to your phone listing current prices plus a highlighted alert block showing exactly what triggered.

How It Works: The Big Picture

The workflow is a simple five-node pipeline. A schedule wakes it up every 15 minutes, a single HTTP call fetches all prices at once, a JavaScript code node crunches the numbers against your thresholds, and an IF gate decides whether your phone needs to know about it.

┌──────────────────────────────────────────────────────────────────────────┐
│  TELEGRAM CRYPTO PRICE ALERT BOT                                         │
│                                                                          │
│  [Schedule Trigger]  →  [Get Crypto Prices]  →  [Check Alert Thresholds] │
│     every 15 min          CoinGecko API           Code node (JS)         │
│                                                          │               │
│                                              ┌───────────┴───────────┐   │
│                                         hasAlerts?               no alert│
│                                              │                       │   │
│                                    [Send Alert to Telegram]   [Skip]     │
│                                       Telegram bot                       │
└──────────────────────────────────────────────────────────────────────────┘

What You’ll Need

• n8n: self-hosted or n8n Cloud (free tier works fine for this workflow)
• CoinGecko account: free plan; no API key required for the public endpoint used here (rate limit: 10 to 30 calls/min, well within our 15-minute schedule)
• Telegram account: you’ll create a bot via BotFather (free, takes 2 minutes)
• Your Telegram chat ID: we’ll show you exactly how to find it below

Estimated build time: 25 to 35 minutes from scratch, or under 10 minutes with the ready-made template.

Part 1: Building the Workflow

1 Schedule Trigger (n8n-nodes-base.scheduleTrigger)

This is the heartbeat of the workflow. It wakes up n8n every 15 minutes and kicks off the entire pipeline. Add a Schedule Trigger node and configure it like this:

• Mode: Interval
• Every: 15 Minutes

The trigger produces a single output item with a timestamp. That’s all the next node needs. It just needs to know it’s time to fetch prices.

2 Get Crypto Prices (n8n-nodes-base.httpRequest)

Add an HTTP Request node. This single API call fetches prices and 24-hour change data for all five coins simultaneously, with no need for separate calls per coin.

• Method: GET
• URL: https://api.coingecko.com/api/v3/simple/price
• Query Parameters (add each as a separate row):

No authentication needed for this endpoint. The API returns a flat JSON object where each key is a coin ID:

{
  "bitcoin":     { "usd": 67543.21, "usd_24h_change": 2.45,  "usd_market_cap": 1330000000000 },
  "ethereum":    { "usd": 3421.56,  "usd_24h_change": -1.23, "usd_market_cap": 411000000000  },
  "solana":      { "usd": 178.92,   "usd_24h_change": 6.11,  "usd_market_cap": 83000000000   },
  "binancecoin": { "usd": 587.44,   "usd_24h_change": 0.87,  "usd_market_cap": 87000000000   },
  "ripple":      { "usd": 0.5821,   "usd_24h_change": -2.34, "usd_market_cap": 32000000000   }
}

3 Check Alert Thresholds (n8n-nodes-base.code)

This is where the logic lives. Add a Code node (JavaScript mode) and paste the script below. It loops through every coin, checks prices against your thresholds, flags large 24-hour moves, and assembles a formatted Telegram message ready to send.

Here’s the config block at the top of the script, the only section you need to customize:

// ─── USER CONFIG ─────────────────────────────────────────────
const thresholds = {
  bitcoin:     { low: 55000,  high: 75000 },
  ethereum:    { low: 2800,   high: 4000  },
  solana:      { low: 120,    high: 220   },
  binancecoin: { low: 400,    high: 700   },
  ripple:      { low: 0.40,   high: 0.80  },
};

// Alert if any coin moves more than this % in 24 hours
const CHANGE_ALERT_PCT = 5;
// ─────────────────────────────────────────────────────────────

After running, the node outputs a single item with this shape:

{
  "hasAlerts":   true,
  "alertCount":  1,
  "message":     "📊 *Crypto Price Update — Apr 7, 02:30 PM ET*\n\n🟢 *BTC*: $67,543.21 (+2.45%)\n🔴 *ETH*: $3,421.56 (-1.23%)\n🟢 *SOL*: $178.92 (+6.11%)\n...\n\n🔔 *ALERTS*\n⚡ *Solana (SOL)* surged +6.11% in 24h — now $178.92",
  "timestamp":   "2026-04-07T18:30:00.000Z"
}

4 Has Alerts? (n8n-nodes-base.if)

Add an IF node to act as the gate. Configure one condition:

• Value 1: {{ $json.hasAlerts }}
• Operator: is true

The true branch connects to the Telegram node. The false branch connects to a No-Op (do nothing) node, which prevents n8n from throwing an “unconnected branch” warning while keeping the workflow clean.

5 Send Alert to Telegram (n8n-nodes-base.telegram)

Add a Telegram node and connect it to the true output of the IF node. Before configuring it, you need a bot token and your chat ID.

Creating your Telegram bot:

1. Open Telegram and search for @BotFather
2. Send /newbot, give it a name (e.g., “My Crypto Alerts”) and a username ending in bot
3. BotFather sends you a token like 7123456789:AAHxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx, save it
4. Start a conversation with your new bot (click “Start” or send any message)
5. Visit https://api.telegram.org/bot<YOUR_TOKEN>/getUpdates in your browser, find your chat.id in the response (it’s a number like 123456789)

Configuring the Telegram node:

• Credential: Create a new Telegram API credential → paste your bot token
• Chat ID: YOUR_TELEGRAM_CHAT_ID (the number you found above)
• Text: ={{ $json.message }}
• Additional Fields → Parse Mode: Markdown

When an alert fires, the message delivered to your phone looks like this:

📊 Crypto Price Update — Apr 7, 02:30 PM ET

🟢 BTC: $67,543.21 (+2.45%)
🔴 ETH: $3,421.56 (-1.23%)
🟢 SOL: $178.92 (+6.11%)
🟢 BNB: $587.44 (+0.87%)
🔴 XRP: $0.58 (-2.34%)

🔔 ALERTS
⚡ Solana (SOL) surged +6.11% in 24h — now $178.92

Full System Flow

Every 15 minutes
      │
      ▼
[Schedule Trigger]
      │
      ▼
[HTTP Request → CoinGecko API]
  GET /simple/price
  ids=bitcoin,ethereum,solana,bnb,xrp
  include_24hr_change=true
      │
      ▼ (raw price JSON)
[Check Alert Thresholds — Code Node]
  ├── Loop each coin
  ├── Compare price vs. low/high thresholds
  ├── Flag if |24h change| ≥ 5%
  ├── Build formatted Telegram message
  └── Output: { hasAlerts, message, ... }
      │
      ▼
[Has Alerts? — IF Node]
  hasAlerts === true?
      │                     │
     YES                   NO
      │                     │
      ▼                     ▼
[Send Alert to Telegram]  [No-Op — Skip]
  Parse Mode: Markdown
  Delivered to your phone

Testing Your Workflow

Before enabling the schedule, run the workflow manually once to confirm everything is wired up correctly:

1. Open the workflow in the n8n editor and click Test Workflow (the play button).
2. Click on the Get Crypto Prices node, you should see live price data in the output panel on the right.
3. Click on Check Alert Thresholds: verify the message field contains a formatted price string and that hasAlerts shows the expected value.
4. To force an alert for testing, temporarily set a threshold your current price has already crossed, e.g., set BTC high to 1000 so it always triggers. Run again, and your Telegram should receive a message within seconds. Reset the threshold afterward.
5. Once confirmed, toggle the workflow Active switch. It will now run automatically every 15 minutes.

Frequently Asked Questions

What’s Next?

• Add a daily digest: Connect the false branch of the IF node to a second Telegram send that fires a clean price summary every morning at 9 AM, regardless of alerts, using a separate Schedule Trigger.
• Log alerts to Google Sheets: Add a Google Sheets node after the Telegram send to log every triggered alert with a timestamp. Track your alert history over time.
• Add portfolio tracking: Extend the Code node to calculate the current USD value of your holdings (e.g., “1.5 BTC × $67,543 = $101,315”) and include it in the Telegram message.
• Connect to a trading signal: Feed alert data into a webhook that triggers a paper trade or signals a human review, building toward a semi-automated trading assistant.

Every Stripe payment you receive can be automatically logged to Google Sheets in real time, no manual exports, no missed transactions, no more downloading CSVs at the end of the month. With this n8n workflow, the moment a payment succeeds in Stripe, a new row appears in your spreadsheet with the customer name, email, amount, description, and payment method already filled in. If the payment is above a threshold you set, you’ll get an email alert too.

Prefer to skip the setup? Grab the ready-made template → and be up and running in under 10 minutes.

What You’ll Build

1. A Stripe webhook listener that fires the moment a payment succeeds, no polling, no delays.
2. A data formatting step that converts Stripe’s raw event data (amounts in cents, Unix timestamps) into clean, human-readable fields.
3. An automatic Google Sheets append that logs every payment as a new row in a structured ledger.
4. A conditional check that sends you an email notification for any payment over $500 so you never miss a big order.

How It Works: The Big Picture

n8n listens for Stripe’s payment_intent.succeeded webhook event. Each time a payment completes, the workflow wakes up, reformats the data into tidy fields, writes a row to your Google Sheet, then checks whether the amount qualifies as high-value, sending an alert email if so.

+----------------------------------------------------------------+
|  AUTO-PROCESS STRIPE PAYMENTS to GOOGLE SHEETS                 |
|                                                                |
|  [Stripe Trigger]                                              |
|        |  payment_intent.succeeded fires                       |
|        v                                                       |
|  [Format Payment Data]                                         |
|        |  cents-to-dollars, Unix-to-date, map fields           |
|        v                                                       |
|  [Log to Google Sheets]                                        |
|        |  append row: ID, date, name, email, amount            |
|        v                                                       |
|  [Check High Value Payment]                                    |
|        | amount >= $500?                                       |
|       YES -------------------------------------------+         |
|        |                                             v         |
|       NO (end)                        [Send High Value Alert]  |
|                                          email notification    |
+----------------------------------------------------------------+
  

What You’ll Need

• An n8n instance: cloud or self-hosted (n8n.io; free tier works)
• A Stripe account with at least one product or payment link set up
• A Google account with Google Sheets access (free)
• An SMTP account for alert emails, Gmail App Password, SendGrid, or any SMTP provider (optional but recommended)
• A Google Sheet with the correct column headers (details in the Data Structure section below)

Estimated build time: 35 to 50 minutes from scratch, or under 10 minutes with the template.

Building the Workflow: Step by Step

1 Stripe Trigger (stripeTrigger)

This node creates a webhook endpoint in n8n that Stripe calls whenever a payment event fires. It’s the entry point for the entire workflow, everything else is downstream of this single trigger.

To configure it:

1. In n8n, add a new node and search for Stripe Trigger.
2. Connect your Stripe credential. If you don’t have one yet, click Create new, paste your Stripe Restricted API key (with webhook read permissions), and save.
3. Under Events, select payment_intent.succeeded. This fires every time a payment is fully authorized and captured.
4. Save the workflow. n8n will display a webhook URL, copy it.
5. In your Stripe dashboard, go to Developers → Webhooks → Add endpoint, paste the n8n URL, and select the payment_intent.succeeded event.

A typical Stripe payment_intent.succeeded payload looks like this:

{
  "id": "pi_3QxT4kABCDEFGHIJ12345678",
  "object": "payment_intent",
  "amount": 4999,
  "currency": "usd",
  "status": "succeeded",
  "description": "Order #1042 — Premium Plan",
  "receipt_email": "emily.rodriguez@gmail.com",
  "billing_details": {
    "name": "Emily Rodriguez",
    "email": "emily.rodriguez@gmail.com"
  },
  "created": 1743865200,
  "payment_method_types": ["card"]
}

Notice that amount is in cents (4999 = $49.99) and created is a Unix timestamp. The next node handles the conversion.

2 Format Payment Data (Set)

The raw Stripe payload is useful, but messy. This Set node maps the data into clean, consistently named fields that Google Sheets can receive directly, no JavaScript required inside the sheet.

Add a Set node connected to the Stripe Trigger, then add these fields in Manual mapping mode:

After this node, data looks like this:

{
  "payment_id": "pi_3QxT4kABCDEFGHIJ12345678",
  "customer_name": "Emily Rodriguez",
  "customer_email": "emily.rodriguez@gmail.com",
  "amount_usd": "49.99",
  "currency": "USD",
  "description": "Order #1042 — Premium Plan",
  "status": "succeeded",
  "payment_date": "4/5/2026",
  "payment_method": "card"
}

3 Log to Google Sheets (googleSheets)

This node appends a new row to your Payments sheet every time a payment is processed. It uses the Append or Update operation, if a payment ID already exists (e.g., a duplicate webhook retry), it updates the existing row instead of creating a duplicate.

1. Add a Google Sheets node and connect your Google OAuth2 credential.
2. Set Operation to Append or Update.
3. Paste your Spreadsheet ID (the long string in your Google Sheet’s URL).
4. Set Sheet Name to Payments.
5. Under Columns, switch to Define below and map each column header to its expression from the previous Set node (e.g., Payment ID → ={{ $json.payment_id }}).
6. Set Matching Columns to Payment ID so duplicate events update instead of duplicate.

4 Check High Value Payment (IF)

After logging, the workflow checks whether the payment amount is $500 or more. Payments that clear this threshold go down the true branch to trigger an email alert; all others exit quietly.

1. Add an IF node connected to the Google Sheets node.
2. Set the Value 1 expression to ={{ parseFloat($('Format Payment Data').item.json.amount_usd) }}.
3. Set Operation to Greater than or equal to.
4. Set Value 2 to 500.

5 Send High Value Alert (emailSend)

When a payment exceeds the threshold, this node fires off an email with all the relevant details so you can follow up personally, flag the account, or just celebrate a big win.

1. Add a Send Email node to the true output of the IF node.
2. Connect your SMTP credential (Gmail App Password works great; see the Credentials Guide).
3. Set From to your sender address and To to your notification email.
4. Set Subject to: =High-Value Payment: ${{ $('Format Payment Data').item.json.amount_usd }} from {{ $('Format Payment Data').item.json.customer_name }}
5. Add a plain-text or HTML body with all the payment fields from the Format node.

A sample alert email body:

High-Value Payment Received

Customer: James Carter
Email: james.carter@gmail.com
Amount: $1,250.00
Description: Order #2089 — Enterprise Annual License
Date: 4/5/2026
Payment ID: pi_3QxT4kABCDEFGHIJ12345678

The Data Structure

Your Google Sheet needs a tab named Payments with these column headers in row 1 (exact capitalization matters):

Here’s what a few rows look like once data starts flowing:

Full System Flow

  Customer Pays via Stripe
          |
          v
  Stripe fires payment_intent.succeeded
          |
          v
  +----------------------------+
  |   n8n Stripe Trigger       |  <-- webhook endpoint registered in Stripe dashboard
  +------------+---------------+
               | raw Stripe payload (cents, Unix timestamps)
               v
  +----------------------------+
  |  Format Payment Data       |  <-- Set node: converts & maps fields
  +------------+---------------+
               | clean fields: name, email, $amount, date
               v
  +----------------------------+
  |  Log to Google Sheets      |  <-- appends or updates row by Payment ID
  +------------+---------------+
               | row written OK
               v
  +----------------------------+
  | Check High Value Payment   |  <-- IF: amount_usd >= 500?
  +------+-------------+-------+
        YES            NO
         |              |
         v             end
  +-----------------+
  | Send Alert Email|  <-- SMTP: notify you of big payment
  +-----------------+
  

Testing Your Workflow

Before going live, test with Stripe’s built-in test mode:

1. In Stripe dashboard, switch to Test mode (toggle in the top-left).
2. Go to Developers → Webhooks → select your endpoint → click Send test webhook → choose payment_intent.succeeded.
3. Open n8n’s execution log, you should see the workflow trigger and all 5 nodes complete successfully.
4. Check your Google Sheet, a new row should appear with the test payment data.
5. To test the high-value alert, temporarily lower the threshold to $1 in the IF node, trigger another test, and check your inbox.

Frequently Asked Questions

What’s Next?

• Add a Slack notification for every payment (not just high-value), great for small teams who want a #payments channel in real time.
• Create a monthly revenue summary by adding a scheduled workflow that queries your Google Sheet, calculates MRR, and emails you a report on the 1st of each month.
• Sync to a CRM: add a HubSpot or Airtable node after the Google Sheets step to create or update a deal every time a payment lands.
• Handle subscriptions separately: listen for invoice.payment_succeeded to capture recurring Stripe subscription payments on their own sheet tab with subscriber lifetime value tracking.