Forem: Hackceleration

Building an AI Receipt Scanner with n8n, Gemini Vision API, and Google Sheets

Hackceleration — Tue, 14 Apr 2026 09:01:19 +0000

Building an AI Receipt Scanner with n8n, Gemini Vision API, and Google Sheets

You're building an expense tracking system and need to extract structured data from receipt images automatically. Every developer who's tried parsing receipts manually knows the pain: faded thermal paper, inconsistent formats, manual transcription errors that corrupt your financial data.

This n8n workflow integrates Google Drive, Google Gemini 2.5 Flash vision API, and Google Sheets to create a daily receipt processing pipeline. The architecture monitors a Drive folder, sends images to Gemini for OCR and extraction, then appends structured JSON to a spreadsheet. Here's how to architect this integration in n8n.

Architecture Overview

The workflow implements a scheduled batch processing pattern:

1. Schedule Trigger (midnight daily)
   ↓
2. Google Drive Search API (list unprocessed receipts)
   ↓
3. Loop iterator (process one receipt at a time)
   ↓
4. Google Drive Download API (fetch image binary)
   ↓
5. Gemini Vision API (extract structured data from image)
   ↓
6. JSON parser (clean AI response)
   ↓
7. Google Sheets Append API (write to spreadsheet)
   ↓
8. Google Drive Move API (archive processed file)

Why this architecture? Processing receipts individually prevents API rate limiting issues with Gemini, ensures clean data separation in Sheets, and provides atomic archiving so failed extractions don't corrupt your workflow state. The loop + move pattern creates idempotency — rerunning the workflow won't duplicate data because processed files are relocated.

Google Drive API Integration

The workflow uses three Google Drive API operations. Authentication uses OAuth2 with Drive API scope.

Searching for Receipt Files

// Google Drive Search node configuration
{
  "resource": "File/Folder",
  "operation": "Search",
  "searchMethod": "Search File/Folder Name",
  "returnAll": true,
  "filters": {
    "folderId": "1WpaNqUwm93jEntzmlMyFIrjdo-x5vRu4" // your inbox folder ID
  }
}

The API returns an array of file objects:

[
  {
    "id": "1ABC...xyz",
    "name": "receipt_2024_03_15.jpg",
    "mimeType": "image/jpeg"
  }
]

Downloading Binary Data

Downloading files requires the file ID from the search results. The binary data is stored in n8n's internal format for passing to Gemini:

// Dynamic file ID from loop context
{
  "fileId": "{{ $json.id }}", // references current item in loop
  "operation": "Download"
}

Moving Processed Files

After successful extraction and sheet append, move the file to prevent reprocessing:

{
  "operation": "Move",
  "fileId": "{{ $('Loop Over Items').item.json.id }}",
  "parentFolderId": "1XYZ...processed" // your archive folder ID
}

Gotcha: If the Sheets append fails, the file won't move. This fail-safe prevents data loss but means you'll need error handling or manual intervention for extraction failures.

Gemini Vision API Integration

Gemini 2.5 Flash handles document OCR and structured extraction. The API accepts binary image data and a text prompt defining the extraction schema.

Authentication

Get an API key from Google AI Studio. In n8n, configure a "Google Gemini API" credential with your key.

Extraction Request

// Gemini Analyze Image node configuration
{
  "model": "models/gemini-2.5-flash",
  "operation": "Analyze Image",
  "inputType": "Binary File(s)",
  "inputDataFieldName": "data", // n8n's binary field name
  "textInput": "Extract all data from this receipt and return as JSON..."
}

The prompt is critical. You're instructing the model exactly what schema to return:

Extract all data from this receipt and return as JSON with these fields:
{
  "company_name": "string",
  "company_address": "string",
  "transaction_date": "YYYY-MM-DD",
  "transaction_time": "HH:MM",
  "items": [
    {
      "name": "string",
      "quantity": number,
      "unit_price": number,
      "category": "food|hygiene|household|electronics|other"
    }
  ],
  "subtotal": number,
  "tax_rate": number,
  "tax_amount": number,
  "total": number,
  "currency": "string",
  "payment_method": "string"
}
Return ONLY valid JSON, no markdown formatting.

Response Handling

Gemini returns text, sometimes wrapped in markdown code fences:

// Response structure
{
  "content": {
    "parts": [{
      "text": "```

json\n{\"company_name\":\"Store Name\"}\n

```"
    }]
  }
}

Parse and clean this in a Code node:

const raw = $input.item.json.content.parts[0].text;
const cleaned = raw.replace(/```
{% endraw %}
json|
{% raw %}
```/g, '').trim();
const parsed = JSON.parse(cleaned);
return { json: parsed };

Rate limits: Free tier is 15 requests/minute. The one-at-a-time loop prevents hitting limits for typical daily receipt volumes.

Error codes:

400: Malformed request or unsupported image format
429: Rate limit exceeded
500: Model processing error (retry with exponential backoff)

Google Sheets API Integration

The Sheets node appends extracted data as new rows. Authentication uses OAuth2 with Sheets API scope.

Sheet Setup

Create a spreadsheet with column headers matching your Gemini extraction schema:

| company_name | transaction_date | total | payment_method | currency |

Append Configuration

{
  "operation": "Append Row",
  "documentId": "1ABC...spreadsheet_id",
  "sheetName": "Sheet1",
  "mappingMode": "Map Automatically" // matches JSON keys to column headers
}

The automatic mapping requires exact field name matches. If your Gemini extraction returns company_name but your column is Company Name, the mapping fails silently.

Handling nested data: The items array needs flattening. Options:

Stringify the array as JSON in a single cell
Use a Code node to create one row per item (better for analysis)
Summarize items into a single string: "3 items: coffee, muffin, water"

Implementation Gotchas

Missing data handling: Not all receipts contain all fields. Gemini returns null or omits fields when data isn't visible. Set default values in the Code node:

const parsed = JSON.parse(cleaned);
return {
  json: {
    company_name: parsed.company_name || "Unknown",
    total: parsed.total || 0,
    currency: parsed.currency || "USD",
    ...parsed
  }
};

Image format compatibility: Gemini handles JPEG, PNG, HEIC. If you're processing PDFs, add a conversion step using ImageMagick or similar.

Authentication token refresh: OAuth2 tokens expire. n8n handles refresh automatically, but if your workflow hasn't run in 6 months, you may need to re-authenticate manually.

Cost optimization: Gemini 2.5 Flash is free up to quota limits. For production at scale, consider:

Caching: Store file hashes and skip re-processing duplicates
Batching: Process receipts weekly instead of daily to reduce API calls
Monitoring: Track API usage in Google Cloud Console

Data validation: Add a Code node after parsing to validate critical fields:

if (!parsed.total || parsed.total <= 0) {
  throw new Error(`Invalid total: ${parsed.total}`);
}
if (!parsed.transaction_date) {
  throw new Error('Missing transaction date');
}
return { json: parsed };

This prevents garbage data from reaching your spreadsheet.

Prerequisites

Required accounts:

n8n instance (self-hosted or cloud)
Google Cloud Platform account (for Gemini API key)
Google account (for Drive and Sheets)

API credentials:

Google Drive OAuth2 credential in n8n
Google Sheets OAuth2 credential in n8n
Google Gemini API key from AI Studio

Folder setup:

Create "Receipts - Inbox" folder in Google Drive (note the folder ID from URL)
Create "Receipts - Processed" folder (note the folder ID)

Spreadsheet setup:

Create a new Google Sheet
Add column headers matching extraction schema
Note the spreadsheet ID from URL

Documentation:

Get the Complete n8n Workflow

This tutorial covers the API integration architecture and key implementation patterns. For the complete n8n workflow JSON with all node configurations, detailed field mappings, and a video walkthrough showing the entire setup process, check out the full implementation guide.

Building an AI News Curation Agent with n8n, Claude, and WordPress REST API

Hackceleration — Tue, 07 Apr 2026 09:01:20 +0000

Building an AI News Curation Agent with n8n, Claude, and WordPress REST API

You need fresh tech content daily, but manually curating RSS feeds, writing summaries, and publishing to WordPress eats up your mornings. Here's how to architect an AI-powered workflow in n8n that reads The Verge's RSS feed, uses Claude to select and summarize the top 5 stories, and publishes styled HTML directly to WordPress — all running on a schedule.

Architecture Overview

The workflow follows this data flow:

1. Schedule Trigger (8 AM daily)
   ↓
2. RSS Feed Reader (fetch articles)
   ↓
3. Claude AI Agent (curate + generate HTML)
   ↓
4. Structured Output Parser (enforce JSON schema)
   ↓
5. Code Node (prepare WordPress payload)
   ↓
6. HTTP Request (POST to WordPress REST API)

Why this architecture? Separating concerns keeps each node focused: RSS ingestion is isolated from AI processing, which is isolated from WordPress publishing. This modularity means you can swap The Verge for TechCrunch or Claude for GPT-4 without rebuilding the entire workflow.

The Schedule Trigger ensures consistency — the workflow runs whether you're working or sleeping. The Structured Output Parser is critical: it forces Claude to return machine-readable JSON instead of free-form text, preventing downstream failures when posting to WordPress.

API Integration Deep-Dive

The Verge RSS Feed

Authentication: None required (public RSS feed)

Request:

GET https://www.theverge.com/rss/index.xml

Response structure:

<rss version="2.0">
  <channel>
    <item>
      <title>Article Title</title>
      <link>https://www.theverge.com/...</link>
      <description>Article summary...</description>
      <pubDate>Mon, 16 Mar 2026 08:00:00 GMT</pubDate>
    </item>
  </channel>
</rss>

The RSS Feed node in n8n automatically parses this XML into JSON. Each <item> becomes a separate execution item flowing into the AI Agent. Typical response contains 20-50 recent articles.

Rate limits: None for RSS feeds (they're designed for polling)

Anthropic Claude API

Authentication: API key in request headers

n8n handles this via the Anthropic Chat Model node. You configure credentials once in n8n's credential manager, and the node injects the key automatically.

Critical configuration:

Model: claude-sonnet-4.5 (balances speed and content quality)
System Message: Defines curation rules (5 stories, topic diversity, HTML formatting)
Structured Output Parser: Forces JSON response matching this schema:

{
  "title": "Tech Daily Brief — March 16, 2026",
  "slug": "tech-daily-brief-march-16-2026",
  "html_content": "<div style=\"font-family:...\">...</div>"
}

Cost consideration: Claude Sonnet pricing is roughly $3 per million input tokens, $15 per million output tokens. A typical daily execution processes ~10,000 input tokens (RSS articles) and generates ~2,000 output tokens (the brief), costing about $0.06 per run or ~$1.80/month.

Error handling: If Claude returns malformed JSON, the Structured Output Parser's Auto-Fix attempts correction. If that fails, the workflow errors and you get no WordPress post that day (this is where error monitoring helps).

WordPress REST API

Authentication: Basic Auth with Application Password

Endpoint:

POST https://your-wordpress-site.com/wp-json/wp/v2/pages
Headers:
  Authorization: Basic <base64-encoded-credentials>
  Content-Type: application/json

Request body:

{
  "title": "Tech Daily Brief — March 16, 2026",
  "slug": "tech-daily-brief-march-16-2026",
  "content": "<div>...full HTML...</div>",
  "status": "draft",
  "lang": "en",
  "hide_title": true
}

Response (success):

{
  "id": 12345,
  "link": "https://your-site.com/tech-daily-brief-march-16-2026/",
  "status": "draft"
}

Common errors:

401 Unauthorized: Application Password is wrong or username is incorrect
403 Forbidden: User lacks permission to create pages
400 Bad Request: Malformed JSON or required fields missing

Rate limits: None for self-hosted WordPress (you control the server). WordPress.com hosted sites have rate limits (~200 requests/hour).

Implementation Gotchas

1. Application Passwords vs Regular Passwords

WordPress REST API requires Application Passwords (generated in WP Admin → Users → Your Profile), NOT your login password. If you use your login password, you'll get 401 Unauthorized every time.

2. RSS Feed Data Variations

Not all RSS feeds structure data identically. The Verge includes full article text in <description>, but some sites only include excerpts. If you swap RSS sources, test that you're getting enough content for Claude to curate meaningfully.

3. Claude Token Limits

Claude Sonnet has a 200k token context window, but costs scale with usage. If you feed it 50 full articles from RSS, you might hit $0.10+ per execution. Consider limiting input to the first 20 articles or using cheaper models like Claude Haiku for initial filtering.

4. Handling Missing Data

If The Verge's RSS feed is temporarily down, the RSS Feed node returns zero items. The AI Agent receives no data and errors out. Best practice: add an IF node after RSS to check {{ $json.items.length > 0 }} and send an error notification if the feed is empty.

5. WordPress Slug Conflicts

If you run this daily and Claude generates the same slug twice (e.g., "tech-daily-brief-march-16-2026"), WordPress returns 400 Bad Request because slugs must be unique. The Code node should append a timestamp or UUID to guarantee uniqueness:

const slug = $input.item.json.output.slug + "-" + Date.now();

6. Timezone Confusion

The Schedule Trigger uses your n8n instance's timezone. If you're in Europe but want to publish for a US audience, you'll need to adjust the trigger hour or configure n8n's timezone settings.

Prerequisites

Required accounts:

n8n instance (self-hosted or n8n Cloud)
Anthropic account with API key (console.anthropic.com)
WordPress site with REST API enabled (default in modern WordPress)

Credentials to configure in n8n:

Anthropic credential: Add your API key
Basic Auth credential: WordPress username + Application Password

API costs:

Anthropic Claude: ~$0.06 per execution, ~$1.80/month for daily runs
WordPress API: Free (self-hosted) or included in WordPress.com plans

Links to official docs:

Get the Complete n8n Workflow Configuration

This tutorial covers the API integration architecture and gotchas. For the complete n8n workflow JSON (ready to import), full node-by-node configuration screenshots, and a video walkthrough showing Claude's curation rules in action, check out the full implementation guide.

Building a YouTube Subscriber Email Scraper with n8n, Apify, and Gmail

Hackceleration — Tue, 31 Mar 2026 09:01:34 +0000

Architecture Overview

YouTube doesn't expose subscriber email addresses through their API — but many creators list their contact email publicly on their channel page. Here's how I architected an n8n workflow to extract those emails and automate outreach:

1. Daily Cron Trigger
   ↓
2. YouTube Data API → Fetch recent subscribers
   ↓
3. Split array → Process each subscriber individually
   ↓
4. Google Sheets lookup → Check for duplicates
   ↓
5. IF subscriber exists → Skip to next
   ↓ (new subscriber)
6. Apify YouTube Scraper → Extract email from channel page
   ↓
7. IF email found → Send Gmail welcome + log to Sheets
   ↓ (no email)
8. Log subscriber without email → Prevent re-scraping

This workflow processes subscribers in batches of 1 to avoid rate limits, uses conditional logic to handle missing data gracefully, and maintains a Google Sheet as the source of truth for processed subscribers.

YouTube Data API Integration

The core data source is the YouTube Data API v3 subscriptions endpoint. You'll need OAuth2 credentials with the youtube.readonly scope.

Authentication setup:

Create a project in Google Cloud Console
Enable YouTube Data API v3
Create OAuth2 credentials (Web application type)
Add authorized redirect URI: https://your-n8n-instance.com/rest/oauth2-credential/callback
Copy Client ID and Client Secret to n8n credential manager

API request structure:

GET https://www.googleapis.com/youtube/v3/subscriptions
  ?part=snippet
  &myRecentSubscribers=true
  &maxResults=50
Headers: {
  "Authorization": "Bearer {oauth_token}"
}

Response format:

{
  "items": [
    {
      "subscriberSnippet": {
        "title": "Channel Name",
        "channelId": "UCxxxxxxxxxxxxx",
        "description": "Channel description"
      }
    }
  ]
}

Critical parameters:

myRecentSubscribers=true filters to newest subscribers (important for daily processing)
maxResults=50 is the API limit per request
The response includes channelId which becomes your unique identifier

Rate limits: 10,000 quota units per day (each request costs 1 unit). With 50 subscribers per day, you'll use 1 unit daily.

Apify Web Scraping Integration

Apify's YouTube Email Scraper actor handles the complex part: navigating to a channel's About page and extracting contact information.

Authentication:

Sign up at apify.com
Navigate to Settings → Integrations → API Token
Copy token to n8n Apify credential

Actor configuration:

{
  "url": "https://www.youtube.com/channel/{channelId}",
  "maxConcurrency": 1
}

Response structure:

{
  "email": ["contact@example.com"],
  "channelName": "Creator Name",
  "subscriberCount": 1500
}

Cost considerations:

Each scrape consumes ~0.001 compute units
Free tier includes 5 compute units/month (~5,000 scrapes)
Paid plans start at $49/month for 100 compute units

Error handling:

Actor returns empty email array when no email found
Timeout set to 60 seconds per channel
Failed runs throw errors caught by n8n error workflow

Google Sheets Duplicate Detection

The workflow uses Google Sheets as a simple database to prevent processing the same subscriber twice.

Sheet structure:

| Subscriber name | Subscriber id          | Email                  |
|----------------|------------------------|------------------------|
| John Creator   | UCxxxxxxxxxxxxx        | john@example.com       |
| Jane Vlogger   | UCyyyyyyyyyyyyyyy      |                        |

Lookup query:

// n8n expression in Google Sheets node
{{ $('SplitInBatches').item.json.subscriberSnippet.channelId }}

This queries the "Subscriber id" column. If row_number exists in the response, the subscriber was already processed.

Why this approach:

Avoids re-scraping channels daily (saves Apify credits)
Prevents sending duplicate welcome emails
Provides a queryable database of all subscribers
No database setup required (Google Sheets is free and familiar)

Gmail API Configuration

Welcome emails send via Gmail's API using OAuth2 authentication.

OAuth2 setup:

Same Google Cloud project as YouTube API
Enable Gmail API
Scopes required: gmail.send
Use the same OAuth2 credential type in n8n

Email parameters:

{
  "to": "{{ $('Apify').item.json.email[0] }}",
  "subject": "Thanks for subscribing! 🎉",
  "message": "<html>...</html>"
}

Rate limits:

500 emails/day for standard Gmail accounts
2,000 emails/day for Google Workspace accounts
No per-minute limits, but bursts >100/min may trigger warnings

Implementation Gotchas

Missing subscriber data:
The YouTube API occasionally returns subscribers with incomplete subscriberSnippet data (deleted accounts, privacy settings). Always check for null:

{{ $json.subscriberSnippet?.channelId || 'unknown' }}

Apify timeout handling:
Some channels load slowly. Set actor timeout to 60-90 seconds and wrap in try/catch:

// In n8n error workflow
IF error.message includes "timeout" → Log to separate sheet

Email array indexing:
Apify returns emails as an array even for single results. Always use email[0] to grab the first:

{{ $json.email[0] }}

Google Sheets append performance:
Appending rows one at a time is slow. For high-volume channels (>100 subscribers/day), batch writes using the "Append/Update" operation with row ranges.

OAuth token expiration:
YouTube and Gmail OAuth tokens expire after 1 hour. n8n handles refresh automatically, but if the workflow fails after days of inactivity, manually re-authenticate credentials.

Duplicate detection edge case:
If someone unsubscribes then re-subscribes, they'll be logged twice. To prevent this, add a "Last checked" timestamp column and filter by date.

Prerequisites

Required accounts:

n8n instance (self-hosted or n8n Cloud)
Google Cloud Console account
Apify account (free tier works)
Gmail account

API credentials to configure:

YouTube Data API v3 OAuth2
Google Sheets OAuth2
Gmail OAuth2
Apify API key

Cost estimate:

n8n Cloud: $20/month starter plan
Apify free tier: 5,000 scrapes/month
YouTube/Gmail APIs: Free (within quotas)
Total: $0-20/month depending on n8n hosting

Documentation links:

Get the Complete n8n Workflow Configuration

This tutorial covers the API integration architecture and core concepts. For the complete n8n workflow JSON, detailed node configurations with all parameters, and a video walkthrough of the setup process, check out the full implementation guide.

Building an AI-Powered YouTube Publisher with n8n, OpenAI Whisper, and Google Drive

Hackceleration — Tue, 24 Mar 2026 10:01:01 +0000

Building an AI-Powered YouTube Publisher with n8n, OpenAI Whisper, and Google Drive

You've got audio files sitting in Google Drive. You need them transcribed, analyzed, and published to YouTube with SEO-optimized metadata. Here's how to architect an automation that handles the entire pipeline using n8n, OpenAI's Whisper API, and the YouTube Data API.

Architecture Overview

This integration chains five core APIs:

1. Google Drive API → Retrieve audio/video files
2. OpenAI Whisper API → Transcribe audio to text
3. OpenAI GPT-4.1-mini → Generate metadata from transcript
4. Google Drive API → Download video file
5. YouTube Data API v3 → Upload with generated metadata

Why this stack? Google Drive provides centralized file storage with robust search capabilities. Whisper offers high-accuracy transcription across languages. GPT-4.1-mini balances quality and cost for metadata generation. The YouTube API handles programmatic uploads with scheduling.

Alternative considered: Zapier's YouTube integration lacks structured output parsing for AI-generated content. n8n's JSON schema validation ensures consistent metadata formatting.

API Integration Deep-Dive

Google Drive API: File Search and Download

Authentication: OAuth2 via Google Cloud Console. Create credentials at console.cloud.google.com, enable Google Drive API, configure OAuth consent screen.

Search Request:

GET https://www.googleapis.com/drive/v3/files
Headers: { "Authorization": "Bearer {access_token}" }
Query Parameters: {
  "q": "'{folder_id}' in parents",
  "fields": "files(id, name, mimeType)"
}

Response Structure:

{
  "files": [
    {
      "id": "1AbC2DeF3GhI4JkL5MnO6PqR7StU8VwX9YzA",
      "name": "episode-42.mp3",
      "mimeType": "audio/mpeg"
    }
  ]
}

n8n Configuration:

Resource: File/Folder
Operation: Search
Filter by Folder ID (found in Drive URL)
Return All: Enabled

Download Request:

GET https://www.googleapis.com/drive/v3/files/{fileId}?alt=media
Headers: { "Authorization": "Bearer {access_token}" }

Returns binary data stream. n8n stores this in the data binary field.

Rate Limits: 1,000 queries per 100 seconds per user. Edge case: handle 403 userRateLimitExceeded with exponential backoff.

OpenAI Whisper API: Audio Transcription

Authentication: API key from platform.openai.com. Add to request header as Authorization: Bearer {api_key}.

Request Format:

POST https://api.openai.com/v1/audio/transcriptions
Headers: {
  "Authorization": "Bearer {api_key}",
  "Content-Type": "multipart/form-data"
}
Body (form-data): {
  "file": <binary_audio_data>,
  "model": "whisper-1"
}

Response:

{
  "text": "Welcome to episode 42 where we discuss API integration patterns..."
}

Critical Parameters:

File size limit: 25 MB
Supported formats: mp3, mp4, mpeg, mpga, m4a, wav, webm
Cost: $0.006 per minute

n8n Configuration:

Resource: Audio
Operation: Transcribe a Recording
Input Data Field Name: data

Error Handling: 413 Payload Too Large → compress audio or split files. Missing binary data → verify Google Drive download node output.

OpenAI GPT-4.1-mini: Structured Metadata Generation

Request Structure:

POST https://api.openai.com/v1/chat/completions
Headers: {
  "Authorization": "Bearer {api_key}",
  "Content-Type": "application/json"
}
Body: {
  "model": "gpt-4.1-mini",
  "messages": [
    {
      "role": "system",
      "content": "You are a YouTube SEO expert. Generate title, description, and tags."
    },
    {
      "role": "user",
      "content": "{transcript_text}"
    }
  ],
  "response_format": { "type": "json_schema", "json_schema": {...} }
}

JSON Schema for Structured Output:

{
  "type": "object",
  "properties": {
    "title": { "type": "string" },
    "description": { "type": "string" },
    "tags": { "type": "array", "items": { "type": "string" } }
  },
  "required": ["title", "description", "tags"]
}

Response:

{
  "choices": [
    {
      "message": {
        "content": "{\"title\":\"How to Integrate APIs with n8n\",\"description\":\"Learn API integration...\",\"tags\":[\"api\",\"n8n\",\"automation\"]}"
      }
    }
  ]
}

n8n AI Agent Setup:

Model: gpt-4.1-mini
Output Parser: JSON Schema
Auto-Fix Format: Enabled

Cost Optimization: GPT-4.1-mini costs ~$0.15 per 1M tokens. Typical metadata generation uses 500-1000 tokens per video.

YouTube Data API v3: Video Upload

Authentication: OAuth2 with youtube.upload scope. Create credentials in Google Cloud Console, enable YouTube Data API v3.

Upload Request (resumable upload):

POST https://www.googleapis.com/upload/youtube/v3/videos?uploadType=resumable&part=snippet,status
Headers: {
  "Authorization": "Bearer {access_token}",
  "Content-Type": "application/json"
}
Body: {
  "snippet": {
    "title": "{ai_generated_title}",
    "description": "{ai_generated_description}",
    "tags": ["{tag1}", "{tag2}"],
    "categoryId": "28"
  },
  "status": {
    "privacyStatus": "private",
    "publishAt": "2025-06-20T18:00:00Z"
  }
}

Response:

{
  "id": "dQw4w9WgXcQ",
  "snippet": {
    "title": "How to Integrate APIs with n8n",
    "publishedAt": "2025-06-20T18:00:00Z"
  }
}

n8n Configuration:

Resource: Video
Operation: Upload
Title: {{ $('AI Agent').item.json.output.title }}
Description: {{ $('AI Agent').item.json.output.description }}
Privacy Status: private
Publish At: ISO 8601 datetime string

Rate Limits: 10,000 quota units per day. One upload = 1,600 units. Handle 403 quotaExceeded by queueing uploads across days.

Implementation Gotchas

Missing Transcript Data: If Whisper returns empty text (silence detection), the AI agent receives no input. Add conditional logic: {{ $json.text ? $json.text : 'No audio detected' }}.

OAuth Token Expiration: Google OAuth tokens expire after 1 hour. n8n's credential system auto-refreshes, but manual API calls need refresh token handling.

YouTube Category IDs: Category 28 = Science & Technology. Wrong category causes upload rejection. Validate against YouTube's category list before deployment.

Binary Data Size: Large video files (>2GB) can timeout. Set n8n's EXECUTIONS_TIMEOUT environment variable to 3600 seconds for long uploads.

Scheduled Publish Failures: publishAt must be at least 6 hours in the future and use ISO 8601 format with timezone. JavaScript Date objects in n8n expressions need .toISO() conversion.

AI Hallucination: GPT-4.1-mini occasionally generates tags unrelated to content. Add validation: check if tags exist in transcript text before uploading.

Prerequisites

Required Accounts:

n8n instance (self-hosted or cloud)
OpenAI API account with credits
Google Cloud project with Drive + YouTube APIs enabled
YouTube channel with upload permissions

API Credentials Needed:

OpenAI API key: platform.openai.com/api-keys
Google OAuth2 credentials: console.cloud.google.com/apis/credentials
YouTube OAuth consent configured with youtube.upload scope

Estimated Costs:

Whisper: $0.006/minute audio
GPT-4.1-mini: $0.15/1M input tokens, $0.60/1M output tokens
Per video: ~$0.10-0.50 depending on audio length

Official Documentation:

Google Drive API: developers.google.com/drive/api/v3/reference
OpenAI Whisper: platform.openai.com/docs/guides/speech-to-text
YouTube Data API: developers.google.com/youtube/v3/docs

Get the Complete Workflow Configuration

This tutorial covers the API integration architecture and critical parameters. For the complete n8n workflow JSON file with all node configurations, system prompts, and error handling logic, check out the full implementation guide.

Building a Podcast-to-Newsletter Pipeline with n8n, OpenAI, and Postmark

Hackceleration — Tue, 17 Mar 2026 10:00:52 +0000

I built an n8n workflow that automatically converts podcast audio files into formatted newsletters and distributes them via email. Here's how I architected the integration between Google Drive, OpenAI's APIs, and Postmark.

Architecture Overview

The workflow follows this data flow:

Audio Source: Monitor Google Drive folder for new audio files
Transcription: Send audio to OpenAI Whisper API for speech-to-text
Content Generation: Pass transcript to GPT-4.1-mini for newsletter creation
Distribution: Retrieve subscriber list from Google Sheets and send via Postmark

I chose this architecture because it separates concerns cleanly—Google Drive handles storage, OpenAI handles AI processing, and Postmark handles reliable email delivery. Each service does what it does best.

[Google Drive] → [Download Audio] → [Whisper API] → [GPT-4.1-mini] → [Postmark API]
                                                           ↑
                                                    [Google Sheets]

API Integration Deep-Dive

OpenAI Whisper Transcription

Authentication: API key from OpenAI dashboard

Request format:

POST https://api.openai.com/v1/audio/transcriptions
Headers: {
  "Authorization": "Bearer YOUR_API_KEY",
  "Content-Type": "multipart/form-data"
}
Body: {
  "file": binary_audio_data,
  "model": "whisper-1"
}

Response structure:

{
  "text": "Full transcription of the audio file..."
}

Critical parameters:

File size limit: 25 MB maximum
Supported formats: MP3, M4A, WAV, WebM
Model: whisper-1 is the only available option

Rate limits: 50 requests per minute on free tier

What happens when expected data is missing: If the audio file is corrupted or unsupported, the API returns a 400 error with details. Always validate file format before uploading.

OpenAI GPT-4.1-mini Newsletter Generation

Authentication: Same API key as Whisper

Request format:

POST https://api.openai.com/v1/chat/completions
Headers: {
  "Authorization": "Bearer YOUR_API_KEY",
  "Content-Type": "application/json"
}
Body: {
  "model": "gpt-4.1-mini",
  "messages": [
    {
      "role": "system",
      "content": "Your response must contain ONLY a valid JSON object with two fields: 'subject' and 'html'."
    },
    {
      "role": "user",
      "content": "[transcription text]"
    }
  ],
  "response_format": { "type": "json_object" }
}

Response structure:

{
  "choices": [
    {
      "message": {
        "content": "{\"subject\": \"Episode Summary\", \"html\": \"<html>...</html>\"}"
      }
    }
  ]
}

n8n configuration snippet:

Enable "Require Specific Output Format" in AI Agent node
Set "Use Responses API" to ON in ChatGPT Model node
System message enforces JSON structure to prevent parsing errors

Handling missing/null data: If the transcript is empty, GPT returns a generic newsletter. Always validate transcript length before proceeding.

Postmark Email API

Authentication: Server token from Postmark account settings

Request format:

POST https://api.postmarkapp.com/email
Headers: {
  "X-Postmark-Server-Token": "YOUR_SERVER_TOKEN",
  "Content-Type": "application/json",
  "Accept": "application/json"
}
Body: {
  "From": "Your Name <verified@yourdomain.com>",
  "To": "subscriber@example.com",
  "Subject": "Newsletter subject line",
  "HtmlBody": "<html>...</html>",
  "MessageStream": "outbound",
  "TrackOpens": true,
  "TrackLinks": "HtmlOnly"
}

Response structure:

{
  "To": "subscriber@example.com",
  "SubmittedAt": "2025-01-15T10:30:00Z",
  "MessageID": "unique-message-id",
  "ErrorCode": 0,
  "Message": "OK"
}

Rate limits: 300 emails per hour on free tier, 10,000/hour on paid plans

Error codes:

406: Inactive recipient (bounced previously)
422: Invalid JSON or missing required fields
401: Invalid or missing server token

Cost optimization: Use batch processing (one subscriber per request) to avoid overwhelming the API and track failures individually.

Google Sheets Subscriber Management

Authentication: OAuth2 credentials in n8n

n8n configuration:

Operation: Get Row(s)
Return All: Enabled
No filters (retrieve all subscribers)

Data validation: Ensure the "Email" column header matches exactly in your sheet. Case-sensitive.

Implementation Gotchas

Audio file format issues: Whisper supports multiple formats, but some podcast exports use proprietary encoding. Convert to standard MP3 (CBR, 128kbps) before uploading to avoid transcription failures.

API rate limiting strategies: Process subscribers one at a time using n8n's SplitInBatches node with batch size 1. This respects Postmark's rate limits and provides granular error handling.

Data validation challenges: The AI sometimes adds markdown formatting despite instructions. The system message "Your response must contain ONLY a valid JSON object" helps, but always parse the response and handle JSON.parse() errors.

Authentication errors: Google OAuth tokens expire after 7 days of inactivity. n8n handles refresh automatically, but ensure your credentials have proper scopes (drive.readonly, spreadsheets.readonly).

Cost optimization: OpenAI Whisper costs $0.006 per minute of audio. A 30-minute podcast costs ~$0.18 to transcribe. GPT-4.1-mini is $0.15 per 1M input tokens—a typical newsletter generation costs $0.01.

Common failure modes: Missing Postmark server token, Google Sheets with no "Email" column, audio files exceeding 25 MB, expired OAuth credentials. Always test with a single subscriber first.

Prerequisites

Required accounts:

n8n instance (self-hosted or n8n Cloud)
OpenAI API account with credits
Google account (Drive + Sheets access)
Postmark account (free tier: 100 emails/month)

API keys needed:

OpenAI API key from platform.openai.com
Postmark server token from account.postmarkapp.com
Google OAuth2 credentials configured in n8n

Estimated costs:

Whisper: $0.006/minute of audio
GPT-4.1-mini: ~$0.01 per newsletter
Postmark: Free up to 100 emails/month, then $1.25 per 1000

Official documentation:

Get the Complete n8n Workflow Configuration

This tutorial covers the API integration architecture and data flow. For the complete n8n workflow JSON with all node configurations, detailed video walkthrough, and step-by-step setup guide with screenshots, check out the full implementation guide.

Building an AI-Powered Backlink Outreach System with n8n, Apify, and OpenAI

Hackceleration — Tue, 10 Mar 2026 10:01:11 +0000

Architecture Overview

This n8n workflow automates backlink outreach by chaining together Google Sheets data retrieval, Apify web scraping, and OpenAI's GPT-4 for email generation. Here's the data flow:

[Google Sheets] → [URL Cleaning] → [Apify Scraper] → [Email Validation] → [GPT-4 Generation] → [Gmail Send]
       ↓              ↓                   ↓                  ↓                    ↓                ↓
   Backlink      Normalize        Extract Contact      Check if Found      Generate Email    Deliver
   List          URLs             Emails               Emails Exist        with AI           Message

Why this architecture? Sequential processing prevents API rate limits and ensures each backlink gets proper attention. Batch size of 1 means if email scraping fails for one URL, the workflow continues with the next. The IF conditional acts as a quality gate—no emails found means skip to next backlink.

Alternative considered: Parallel processing would be faster but risks overwhelming Apify's scraper and makes debugging failures harder. For outreach campaigns, reliability > speed.

API Integration Deep-Dive

Google Sheets API

Authentication: OAuth 2.0 credential in n8n. Grant read access to your backlink tracking spreadsheet.

Request structure:

// n8n handles this internally, but equivalent REST call:
GET https://sheets.googleapis.com/v4/spreadsheets/{spreadsheetId}/values/{range}
Headers: { "Authorization": "Bearer {token}" }

Response format:

{
  "range": "Sheet1!A1:B100",
  "values": [
    ["URL Source", "Target URL"],
    ["https://example.com/article", "https://yoursite.com/page"]
  ]
}

n8n configuration:

Resource: Sheet Within Document
Operation: Get Row(s)
Document: Select from list
Sheet: Select target sheet
Returns: Array of objects with column headers as keys

Rate limits: 100 requests per 100 seconds per user. Workflow runs once per execution, so no concern.

Edge cases: Empty rows return null values—handle in downstream nodes. If spreadsheet structure changes, workflow breaks (column name dependencies).

Apify Website Emails Scraper API

Authentication: API key passed in header.

Request example:

POST https://api.apify.com/v2/acts/maximedupre~website-emails-scraper/runs
Headers: { "Authorization": "Bearer apify_api_xxx" }
Body: {
  "startUrls": [{"url": "https://example.com"}],
  "maxRequestsPerCrawl": 10,
  "maxCrawlingDepth": 2
}

Response structure:

{
  "data": {
    "items": [
      {
        "url": "https://example.com",
        "email": "contact@example.com",
        "foundOnPage": "https://example.com/contact"
      }
    ]
  }
}

n8n configuration:

Resource: Actor
Operation: Run an Actor and Get Dataset
Actor: Website Emails Scraper
Input JSON: {{ $json }} (passes cleaned URL array)
Memory: 1024 MB (balance cost/performance)

Rate limits: Based on compute units, not requests. 1 GB memory = ~0.1 compute units per minute. Free tier: 5 compute units/month.

Cost optimization: Reduce maxCrawlingDepth to 1 if emails are typically on homepage/contact page. Costs ~$0.02-0.05 per website scraped.

Common failures:

No emails found: Some sites hide contact info or use contact forms only
JavaScript-heavy sites: May need increased memory allocation
Cloudflare protection: Scraper may be blocked

Debugging: Check Apify run logs in dashboard. Error "ACTOR_RUN_FAILED" means insufficient memory or timeout.

OpenAI GPT-4 API

Authentication: Bearer token (API key from OpenAI dashboard).

Request format:

POST https://api.openai.com/v1/chat/completions
Headers: { 
  "Authorization": "Bearer sk-xxx",
  "Content-Type": "application/json"
}
Body: {
  "model": "gpt-4-1106-preview",
  "messages": [
    {"role": "system", "content": "You are an expert email outreach specialist..."},
    {"role": "user", "content": "Generate email for backlink from example.com to mysite.com"}
  ],
  "response_format": { "type": "json_object" }
}

Response structure:

{
  "id": "chatcmpl-xxx",
  "choices": [{
    "message": {
      "role": "assistant",
      "content": "{\"selected_email\":\"editor@example.com\",\"subject\":\"Quick request...\",\"html_body\":\"<p>Hi,</p>...\"}"
    }
  }],
  "usage": {
    "prompt_tokens": 450,
    "completion_tokens": 200,
    "total_tokens": 650
  }
}

n8n configuration:

Model: gpt-4-1106-preview (or gpt-4-1-mini for cost savings)
Use Responses API: Enabled
Output Parser: Structured Output with JSON schema
System Message: Detailed prompt with email generation guidelines

Rate limits (Tier 1):

500 requests per day
10,000 tokens per minute
For outreach: ~650 tokens/email = ~15 emails/minute max

Cost: GPT-4-1-mini: $0.15 per 1M input tokens, $0.60 per 1M output. Typical email: $0.01-0.02.

Edge cases:

AI refuses to generate: If scraped data looks like spam/sensitive info
Invalid JSON: Auto-fix in n8n or add validation prompt
Generic output: Improve system prompt with more context

Prompt engineering tips:

System message should include:
- Specific role/expertise
- Output format requirements (JSON structure)
- Tone guidelines (professional but friendly)
- What to include (backlink context, value proposition)
- What to avoid (aggressive sales language, false urgency)

Gmail API

Authentication: OAuth 2.0 credential. Requires enabling Gmail API in Google Cloud Console.

Request format:

POST https://gmail.googleapis.com/gmail/v1/users/me/messages/send
Headers: { "Authorization": "Bearer {token}" }
Body: {
  "raw": "{base64_encoded_email}"
}

n8n configuration:

Resource: Message
Operation: Send
To: {{ $json.output.selected_email }}
Subject: {{ $json.output.subject }}
Email Type: HTML
Message: {{ $json.output.html_body }}

Rate limits: 100-500 emails per day (varies by account age/reputation). For outreach, stay under 50/day to avoid spam flags.

Deliverability tips:

Warm up new accounts (start with 5-10 emails/day)
Set up SPF/DKIM records
Use professional signature
Avoid spam trigger words

Implementation Gotchas

1. Handling Missing Data

When Apify finds no emails, the IF node prevents downstream errors:

// Condition in IF node
{{ $json.email }} exists

Without this check, the AI Agent receives undefined data and fails.

2. URL Normalization

The Function node standardizes URLs because Apify expects clean input:

const urls = $input.first().json["URL Source"].split(",");
return urls.map(url => ({
  url: url.trim().startsWith("http") ? url.trim() : `https://${url.trim()}`
}));

Handles: missing protocols, extra spaces, comma-separated lists.

3. API Cost Management

Apify: ~$0.03 per site scraped
OpenAI: ~$0.015 per email generated
Gmail: Free
Total per backlink: ~$0.045

For 100 backlinks: ~$4.50 in API costs. Budget accordingly.

4. Gmail Sending Limits

Workflow processes sequentially but Gmail has daily quotas. For large lists:

// Add Wait node after Gmail Send
// Wait: 2 minutes between emails
// Spreads 100 emails over ~3.3 hours

5. Error Recovery

If workflow fails mid-execution:

n8n preserves state at last successful node
Re-run continues from failure point
Track sent emails in Google Sheets to prevent duplicates

Prerequisites

Required Accounts:

n8n Cloud or self-hosted instance
Google account with Sheets API enabled
Apify account (free tier: 5 compute units/month)
OpenAI account with API key and billing
Gmail account for sending (use dedicated outreach email)

API Credentials Needed:

Google OAuth 2.0 (Sheets + Gmail)
Apify API key (Settings → Integrations)
OpenAI API key (API Keys section)

Estimated Costs:

n8n Cloud: $20/month (Starter plan) or self-hosted (free)
Apify: $0.03/backlink or free tier
OpenAI: $0.015/email
Gmail: Free

Data Preparation:

Google Sheet structure:

| URL Source                  | Target URL                    | Status      | Date Contacted |
|-----------------------------|-------------------------------|-------------|----------------|
| https://example.com/article | https://yoursite.com/guide    | Pending     |                |

Documentation Links:

Get the Complete Workflow Configuration

This tutorial covers the API integration architecture and implementation details. For the complete n8n workflow JSON file, Google Sheets template, AI prompt configuration, and video walkthrough showing the workflow in action, check out the full implementation guide.

Building an SEO Position Tracker with Google Search Console API and n8n

Hackceleration — Tue, 03 Mar 2026 10:00:58 +0000

You're tracking keyword rankings manually in Google Search Console. Every morning: log in, filter by query, select date range, export to CSV, paste into a spreadsheet. Repeat for each keyword. By Friday, you've spent hours collecting data that should take minutes.

This n8n workflow connects directly to the Google Search Console API, fetches position and impression data for configured keywords, and updates a Google Sheets tracking spreadsheet automatically. Here's how to architect this integration in n8n.

Architecture Overview

The workflow follows this data flow:

1. Read keyword/country config from Google Sheets
2. Read date range from Google Sheets
3. Loop through dates (one at a time)
4. For each date:
   - Query Search Console API with keyword filters
   - Check if position data exists
   - Update tracking sheet with position + impressions
5. Move to next date

Why this architecture? Processing one date at a time prevents API rate limit issues. Google Search Console has quotas, and batch processing can trigger throttling. The IF node handles missing data gracefully—if a keyword has no impressions for a date, the workflow skips that update without crashing.

Alternative considered: Querying all dates in a single API call. Rejected because: (1) harder to handle partial failures, (2) less granular error tracking, (3) complicates the update logic when matching dates to spreadsheet rows.

Google Search Console API Integration

Authentication: OAuth2 Setup

The Search Console API requires OAuth2 credentials. You'll need:

A project in Google Cloud Console
Search Console API enabled
OAuth2 credentials with scope: https://www.googleapis.com/auth/webmasters.readonly
Credentials configured in n8n (Settings → Credentials → Google Search Console OAuth2 API)

API Request Structure

The core API call is an HTTP POST to the searchAnalytics endpoint:

POST https://www.googleapis.com/webmasters/v3/sites/https%3A%2F%2Fexample.com%2F/searchAnalytics/query

Headers:
  Authorization: Bearer {oauth_token}
  Content-Type: application/json

Body:
{
  "startDate": "2025-02-06",
  "endDate": "2025-02-06",
  "searchType": "web",
  "dimensions": ["query"],
  "dimensionFilterGroups": [{
    "filters": [
      {"dimension": "query", "expression": "exact keyword", "operator": "equals"},
      {"dimension": "country", "expression": "usa", "operator": "equals"}
    ]
  }]
}

Critical parameter: The site URL in the endpoint must be URL-encoded. For https://example.com/, use https%3A%2F%2Fexample.com%2F. Find your exact property URL in Search Console settings.

API Response Structure

When position data exists:

{
  "rows": [
    {
      "keys": ["your keyword"],
      "position": 12.5,
      "impressions": 847,
      "clicks": 23,
      "ctr": 0.027
    }
  ]
}

When no data exists (keyword had no impressions):

{}

Handling missing data: The workflow uses an IF node to check $json.rows[0].position. If this field doesn't exist, it skips the Google Sheets update and continues to the next date. This prevents errors when tracking new keywords or low-impression queries.

n8n Configuration Deep-Dive

Google Sheets Integration

Configuration sheet structure:

Sheet 1 ("keyword & country"): columns keyword, country
Sheet 2 ("dates"): column date in YYYY-MM-DD format
Sheet 3 ("position"): columns date, position, impressions

Reading configuration:

// Node: Google Sheets (Get Rows)
Resource: Sheet Within Document
Operation: Get Row(s)
Document: [Your spreadsheet]
Sheet: "keyword & country"
// Returns array of {keyword: "...", country: "..."}

Updating position data:

// Node: Google Sheets (Update Row)
Operation: Update Row
Column to match on: "date"
Values to update:
  - date: {{ $('Loop Through Dates').item.json.date }}
  - position: {{ $json.rows[0].position }}
  - impressions: {{ $json.rows[0].impressions }}

Why Update Row instead of Append? Update Row allows re-running the workflow for the same dates without creating duplicates. Pre-populate your position sheet with dates, and the workflow will fill in position/impression data as it runs.

Split In Batches Configuration

// Node: Split In Batches
Batch Size: 1
// Processes one date per iteration
// Loops back to HTTP Request node until all dates processed

Rate limiting strategy: With batch size 1, you're making ~1 API request per second. Search Console's quota is generous (thousands of queries per day), but processing one at a time keeps you safely under limits. For large backlogs (90+ days), add a Wait node with 1-second delay after each API call.

Implementation Gotchas

Search Console data delay: Search Console finalizes data 2-3 days after the date occurs. If you query yesterday's data, you'll get incomplete results. Always track dates that are at least 3 days old.

Credential scope errors: If you see "Insufficient authentication scopes", your OAuth credential is missing the webmasters scope. Recreate the credential in n8n with the correct scope, then re-authenticate.

Empty responses vs. API errors: The workflow differentiates between "no data for this keyword" (empty response, status 200) and "API error" (status 400/500). The IF node only handles empty responses. API errors will fail the workflow—check your property URL encoding and credential scopes.

Date format mismatches: The Search Console API requires YYYY-MM-DD format. Google Sheets might auto-format dates as MM/DD/YYYY. Use a Set node to transform dates before passing them to the API:

// Node: Set (Format Date)
Value: {{ $json.date_raw.split('/').reverse().join('-') }}
// Converts 02/09/2025 to 2025-02-09

Missing position field vs. null position: The API returns no rows array when a keyword has zero impressions. It returns rows[0].position: null when position data exists but is unavailable (rare). The IF node condition does not exist catches both cases.

Prerequisites

Required accounts:

n8n instance (self-hosted or n8n Cloud)
Google Search Console access with verified property
Google Sheets account
Google Cloud project with Search Console API enabled

API credentials:

OAuth2 client ID and secret from Google Cloud Console
Credential configured in n8n: Settings → Credentials → Google Search Console OAuth2 API
Scope: https://www.googleapis.com/auth/webmasters.readonly

Google Sheets template:

Sheet "keyword & country" with columns: keyword, country
Sheet "dates" with column: date (YYYY-MM-DD format)
Sheet "position" with columns: date, position, impressions

Pre-populate dates sheet with your tracking period (e.g., last 30 days). Pre-populate position sheet with matching dates (empty position/impressions columns).

Estimated API costs: Google Search Console API is free with generous quotas (thousands of queries per day). No usage fees.

Get the Complete n8n Workflow Configuration

This tutorial covers the API integration architecture and core concepts. For the complete n8n workflow JSON with all node configurations, Google Sheets template, and a video walkthrough of the setup process, check out the full implementation guide.

Building Real-Time Error Monitoring for n8n Workflows with Gmail and Slack APIs

Hackceleration — Tue, 24 Feb 2026 10:01:05 +0000

When you're running n8n workflows in production, silent failures are your worst enemy. An API timeout at 3 AM, an authentication error during a data sync, or a validation failure in your lead capture workflow—any of these can break your automation chain without you knowing. Here's how to architect a centralized error monitoring system using n8n's Error Trigger node, Gmail API, and Slack API.

Architecture Overview

This monitoring system follows a fan-out pattern:

[Failed Workflow] → [Error Trigger Node]
                          ├─→ [Gmail API] → HTML Email
                          └─→ [Slack API] → Channel Message

When any monitored workflow fails, n8n's Error Trigger captures the failure event and simultaneously fires two notification channels. This dual-channel approach ensures you're alerted whether you're checking email or active in Slack. The Error Trigger node acts as a global listener—it receives events from every workflow in your n8n instance that has error triggering enabled.

Why this architecture? Single points of failure. If your only notification channel is Slack and your team's workspace goes down, you're blind to errors. Email provides a reliable fallback and creates a permanent audit trail.

Error Trigger Node: Capturing Failure Events

The Error Trigger is n8n's built-in mechanism for workflow-level error handling. Unlike regular triggers that respond to external events, this node listens internally for execution failures.

Enabling Error Triggering on Monitored Workflows:

For each workflow you want to monitor:

Open workflow settings (gear icon)
Scroll to "Error Workflow" dropdown
Select your monitoring workflow
Save settings

Once configured, any failure in that workflow sends an event to your Error Trigger node.

Error Event Data Structure:

{
  "execution": {
    "id": "346020",
    "url": "https://your-n8n-instance.com/workflow/123/executions/346020",
    "mode": "trigger",
    "retryOf": null
  },
  "workflow": {
    "id": "123",
    "name": "Lead Capture to CRM Sync"
  },
  "error": {
    "message": "Connection timed out after 5000ms",
    "stack": "Error: Connection timed out\n    at makeRequest (node:12:34)..."
  },
  "lastNodeExecuted": "HTTP Request"
}

Critical fields:

execution.id: Unique identifier for the failed run
execution.url: Direct link to investigate in n8n UI
workflow.name: Human-readable workflow identifier
error.message: The actual error (API timeout, auth failure, etc.)
lastNodeExecuted: Which node caused the failure

Testing the Error Trigger:

Before a real failure occurs, use the "Fetch Test Event" button in the Error Trigger node to pull sample data. This lets you configure your Gmail and Slack notifications without waiting for an actual workflow to break.

Gmail API Integration: Formatted HTML Notifications

The Gmail node sends a professionally formatted HTML email using OAuth2 authentication. Raw error JSON is transformed into a readable notification with clear sections for workflow details, error information, and action links.

Authentication Setup:

You need a Gmail OAuth2 credential in n8n:

Create OAuth2 credentials in Google Cloud Console
Configure authorized redirect URI: https://your-n8n-instance.com/rest/oauth2-credential/callback
Add credential in n8n with required scopes: https://www.googleapis.com/auth/gmail.send

Request Structure (what n8n sends to Gmail API):

POST https://gmail.googleapis.com/gmail/v1/users/me/messages/send
Headers: {
  "Authorization": "Bearer [OAuth2_token]",
  "Content-Type": "application/json"
}
Body: {
  "raw": "[base64_encoded_email_content]"
}

Email Template Configuration:

// Dynamic subject line
"N8N - Workflow Error ({{ $json.workflow.name }})"

// HTML body structure
<!DOCTYPE html>
<html>
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
</head>
<body style="font-family: Arial, sans-serif; margin: 0; padding: 20px;">
  <div style="max-width: 600px; margin: 0 auto; background: #f8f9fa; padding: 20px;">
    <h2>⚠️ Workflow Error Detected</h2>
    <div style="background: white; padding: 15px; margin: 10px 0;">
      <strong>Workflow:</strong> {{ $json.workflow.name }}<br>
      <strong>Execution ID:</strong> {{ $json.execution.id }}<br>
      <strong>Time:</strong> {{ $now.toISO() }}
    </div>
    <div style="background: #ffe6e6; padding: 15px; margin: 10px 0;">
      <strong>Error Message:</strong><br>
      {{ $json.error.message }}
    </div>
    <a href="{{ $json.execution.url }}" style="display: inline-block; background: #007bff; color: white; padding: 10px 20px; text-decoration: none;">View Execution</a>
  </div>
</body>
</html>

Handling Missing Data:

Not all error events include stack traces or request IDs. Use n8n expressions with fallbacks:

{{ $json.error.stack || "No stack trace available" }}

Slack API Integration: Channel Notifications

The Slack node posts a formatted message to a dedicated error channel using a Bot Token. The message uses Slack's markdown syntax and emoji for visual hierarchy.

Slack App Setup:

Create a Slack app in your workspace
Add Bot Token Scopes: chat:write, channels:read
Install app to workspace
Copy Bot User OAuth Token
Configure credential in n8n with token

API Request Format:

POST https://slack.com/api/chat.postMessage
Headers: {
  "Authorization": "Bearer xoxb-your-bot-token",
  "Content-Type": "application/json"
}
Body: {
  "channel": "C1234567890",
  "text": "⚠️ *AUTOMATION ERROR DETECTED*\n..."
}

Message Template:

⚠️ *AUTOMATION ERROR DETECTED*
_____________________________
📋 *Workflow:* {{ $json.workflow.name }}
🔢 *Execution ID:* {{ $json.execution.id }}
🕐 *Time:* {{ $now.toLocaleString('en-US', { dateStyle: 'full', timeStyle: 'long' }) }}
_____________________________
❌ *Error:* {{ $json.error.message }}
🔗 <{{ $json.execution.url }}|View in n8n>

Slack Response Structure:

{
  "ok": true,
  "channel": "C1234567890",
  "ts": "1234567890.123456",
  "message": {
    "text": "⚠️ *AUTOMATION ERROR DETECTED*...",
    "bot_id": "B1234567890"
  }
}

Implementation Gotchas

Rate Limiting:

Gmail API: 250 quota units per user per second (sending one email = 100 units)
Slack API: Tier 3 rate limit (50+ requests per minute)
If you have high-frequency failing workflows, implement exponential backoff or batching

Error Workflow Loops:

Never set the monitoring workflow itself to trigger on its own errors
This creates an infinite loop: failure → notification → notification fails → triggers itself → repeat
The Error Trigger node should only be used in dedicated monitoring workflows

OAuth Token Expiry:

Gmail OAuth2 tokens expire after 1 hour
n8n handles refresh automatically, but initial setup requires manual authorization
If notifications stop working, check credential status in n8n settings

Slack Channel Selection:

The "From list" dropdown requires the Slack credential to have channels:read scope
If you can't see your channel, verify bot permissions and reinvite bot to channel
Alternative: Use channel ID directly instead of channel name

HTML Email Rendering:

Inline CSS only—no external stylesheets
Test across email clients (Gmail, Outlook, Apple Mail)
Keep HTML simple to avoid spam filters

Cost Optimization

Both Gmail and Slack APIs are free for typical error notification volumes:

Gmail API: Free tier includes 1 billion quota units per day
Slack API: Free for standard workspaces (unlimited messages)

If you're triggering thousands of errors per day, you have bigger problems than API costs—focus on fixing the failing workflows.

Prerequisites

Before implementing this monitoring system:

n8n instance (self-hosted or cloud) with admin access
Gmail account with OAuth2 credentials configured in n8n
Slack workspace with bot token and dedicated error channel
Error Trigger enabled on all workflows you want to monitor (Workflow Settings → Error Workflow → Select monitoring workflow)

Official documentation:

Get the Complete Workflow Configuration

This tutorial covers the API integration architecture and error handling patterns. For the complete n8n workflow JSON with pre-configured nodes, credential mappings, and a video walkthrough of the setup process, check out the full implementation guide.

Building AI-Powered RFP Evaluation with n8n and Google Gemini

Hackceleration — Tue, 17 Feb 2026 10:01:08 +0000

Integrating n8n, Google Gemini, and Google Sheets for Automated Tender Scoring

Procurement teams evaluating RFPs spend hours extracting data from vendor PDFs, cross-referencing requirements, and maintaining scoring consistency. Here's how to architect an n8n workflow that uses Google Gemini to evaluate tender proposals against RFP criteria and output structured scores to Google Sheets.

This integration combines n8n's webhook triggers, Google Drive's file retrieval, PDF text extraction, Google Gemini's AI analysis capabilities, and Google Sheets' data storage. Here's how to architect this integration in n8n.

Architecture Overview

The workflow follows this data flow:

Vendor submits proposal PDF via n8n Form Trigger → stores binary file data
Parallel branch: Google Drive API fetches RFP document by file ID
Extract text from both PDFs using Extract From File node
Merge streams to provide AI agent with both documents
Google Gemini API receives structured prompt with RFP + proposal text
AI returns JSON-formatted evaluation with weighted scores
Google Sheets API appends evaluation row to dashboard

This architecture separates document retrieval, text processing, AI analysis, and data storage into discrete nodes. Alternative approaches like using OpenAI's API or Anthropic's Claude would require different credential configuration but similar overall structure.

API Integration Deep-Dive

n8n Form Trigger Webhook

The Form Trigger creates a public endpoint that accepts file uploads:

// Form configuration
{
  "formTitle": "Tender Response Submission",
  "formFields": [
    {
      "fieldLabel": "Proposal Document (PDF only)",
      "fieldType": "file",
      "acceptedFileTypes": ".pdf"
    }
  ],
  "authentication": "none"
}

When triggered, returns:

{
  "Proposal_Document__PDF_only_": {
    "data": "[binary data]",
    "mimeType": "application/pdf",
    "fileName": "vendor-proposal.pdf"
  }
}

The binary field name matches the form label with special characters replaced by underscores. Critical for downstream PDF extraction.

Google Drive API Authentication

Requires OAuth2 credential with these scopes:

https://www.googleapis.com/auth/drive.readonly
https://www.googleapis.com/auth/drive.file

File download request structure:

GET https://www.googleapis.com/drive/v3/files/{fileId}?alt=media
Headers: {
  "Authorization": "Bearer {access_token}"
}

Returns binary file content. The alt=media parameter is essential—without it, you get file metadata instead of content.

Rate limits: 1000 queries per 100 seconds per user. For batch processing, implement exponential backoff on 403 responses.

PDF Text Extraction

The Extract From File node processes binary PDF data:

// Node configuration
{
  "operation": "extractFromPDF",
  "binaryPropertyName": "data"
}

Outputs:

{
  "text": "[extracted text content]",
  "pageCount": 15,
  "metadata": {...}
}

Gotcha: Text-based PDFs only. Scanned documents or image-heavy PDFs return empty strings. Validate text field length before proceeding to AI analysis.

Google Gemini API Integration

Authentication uses API key from Google Cloud Console:

POST https://generativelanguage.googleapis.com/v1/models/gemini-2.5-flash:generateContent
Headers: {
  "Content-Type": "application/json",
  "x-goog-api-key": "{API_KEY}"
}

Request body structure:

{
  "contents": [{
    "parts": [{
      "text": "System: You are a rigorous tender evaluation specialist.\n\nUser: Evaluate this proposal against the RFP requirements: [RFP_TEXT]\n\nProposal: [PROPOSAL_TEXT]"
    }]
  }],
  "generationConfig": {
    "response_mime_type": "application/json",
    "response_schema": {
      "type": "object",
      "properties": {
        "company_name": {"type": "string"},
        "score_price": {"type": "number"},
        "score_technical": {"type": "number"}
      }
    }
  }
}

Response:

{
  "candidates": [{
    "content": {
      "parts": [{
        "text": "{\"company_name\":\"Acme Corp\",\"score_price\":85,\"score_technical\":72}"
      }]
    },
    "finishReason": "STOP"
  }],
  "usageMetadata": {
    "promptTokenCount": 1250,
    "candidatesTokenCount": 180
  }
}

Critical parameters:

response_mime_type: "application/json" forces JSON output
response_schema defines exact structure expected
Temperature defaults to 1.0; reduce to 0.3 for more deterministic scoring

Rate limits:

Free tier: 15 requests/minute
Paid tier: 1000 requests/minute
Token limits: 32k input, 8k output for Flash model

Error handling: HTTP 429 on rate limit, 400 on malformed schema. Always validate finishReason === "STOP" before parsing response.

Google Sheets API Data Append

Append operation uses values.append method:

POST https://sheets.googleapis.com/v4/spreadsheets/{spreadsheetId}/values/{range}:append
Headers: {
  "Authorization": "Bearer {access_token}",
  "Content-Type": "application/json"
}
Body: {
  "values": [[
    "Acme Corp",
    "john@acme.com",
    85,
    72,
    "2026-01-29"
  ]]
}

With n8n's automatic column mapping enabled, field names must match spreadsheet headers exactly. Case-sensitive.

Quota limits: 500 requests per 100 seconds per project. Batch multiple evaluations if processing bulk proposals.

Implementation Gotchas

Missing PDF Text Content

PDF extraction returns empty string when:

Document is scanned image (no text layer)
PDF is password protected
File is corrupted

Implement validation:

{{ $json.text.length > 100 }}

If false, route to error handler or manual review queue.

Gemini JSON Parsing Failures

Even with structured output, AI occasionally returns malformed JSON:

Extra markdown code fences ( ```json) - Escaped characters in wrong places - Truncated responses on token limit

The Output Parser's "Auto-Fix Format" handles minor issues. For consistent failures, adjust response_schema complexity or increase output token limit.

Google Drive Permission Errors

HTTP 403 when:

Credential lacks drive.readonly scope
File sharing settings restrict access
File is in shared drive requiring domain-wide delegation

Test with publicly accessible file first, then adjust sharing settings.

Rate Limiting Strategy

For batch processing 50+ proposals:

Use n8n's "Split In Batches" node with batch size 10
Add "Wait" node with 60-second delay between batches
Implement retry logic with exponential backoff
Monitor Gemini API usage in Google Cloud Console

Data Validation Before Sheets

Missing fields cause append failures. Validate required fields:


javascript
{{
  $json.company_name &&
  $json.score_price !== undefined &&
  $json.score_technical !== undefined
}}

Route invalid data to separate error logging sheet.

Cost Optimization

Gemini API pricing:

Input: $0.00025 per 1k characters
Output: $0.0005 per 1k characters

Typical RFP (5000 chars) + proposal (8000 chars) = ~$0.007 per evaluation. For 100 proposals: ~$0.70.

Reduce costs by:

Extracting only relevant RFP sections
Limiting proposal text to first 5000 characters
Using cached RFP content across evaluations

Prerequisites

Required Accounts:

n8n instance (self-hosted or cloud)
Google Cloud project with APIs enabled:
- Google Drive API
- Google Sheets API
- Generative Language API (Gemini)

API Credentials:

Google OAuth2 credential for Drive/Sheets (setup guide)
Google Gemini API key (get key)

Data Setup:

RFP document uploaded to Google Drive (note file ID from URL)
Google Sheet with headers: company_name, contact_person, contact_email, total_cost_eur, score_price, score_technical, score_experience, score_timeline, score_warranty, score_innovation, weighted_total, gdpr_compliant, budget_compliant, mandatory_integrations_met, recommendation

Cost Estimates:

Gemini API: ~$0.007 per evaluation
Google Drive/Sheets API: Free (within quota limits)

Get the Complete Workflow Configuration

This tutorial covers the API integration architecture and key implementation patterns. For the complete n8n workflow JSON with all node configurations, credential setup instructions, and a video walkthrough, check out the full implementation guide.

Building an AI News Curator with n8n, Claude, and RSS Feeds

Hackceleration — Tue, 10 Feb 2026 10:00:54 +0000

Building an AI News Curator with n8n, Claude, and RSS Feeds

Configuring an n8n workflow to read RSS feeds, analyze content with Claude Sonnet, and send formatted HTML newsletters. This implementation uses scheduled triggers, AI agents, and email automation to create a daily tech digest.

Architecture Overview

The workflow follows this data flow:

Schedule Trigger (8 AM daily)
    ↓
RSS Feed Reader (pulls articles from The Verge)
    ↓
Claude Sonnet AI Agent (analyzes + curates top 5 stories)
    ↓
Gmail Send (delivers HTML newsletter)

Why this architecture: Separating RSS parsing from AI analysis allows you to add multiple news sources without modifying the Claude agent. The schedule trigger ensures consistent delivery regardless of when articles publish. Using HTML output from Claude eliminates post-processing—the AI generates email-ready content directly.

Alternatives considered: Could use Make.com or Zapier, but n8n provides better control over AI prompts and local execution options. Could use GPT-4 instead of Claude, but Sonnet 4.5 handles structured HTML output more reliably for this use case.

API Integration Deep-Dive

RSS Feed Integration

The RSS Feed node fetches structured XML data from any RSS-compliant source:

// RSS Feed Node Configuration
{
  "url": "https://www.theverge.com/rss/index.xml",
  "options": {}
}

What you get back:

[
  {
    "title": "Article headline",
    "description": "Article summary",
    "link": "https://...",
    "pubDate": "2025-01-29T14:30:00Z",
    "creator": "Author name"
  }
]

Edge cases:

Some RSS feeds include full article text in content:encoded field
pubDate format varies (ISO 8601, RFC 2822)—Claude handles this
Missing descriptions require fallback to title-only analysis

Rate limiting: RSS feeds typically don't enforce rate limits, but pulling every 5 minutes might trigger blocks. Daily fetches are safe.

Anthropic Claude API Integration

Claude Sonnet requires API key authentication and uses a messages-based format:

curl https://api.anthropic.com/v1/messages \
  -H "x-api-key: YOUR_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "content-type: application/json" \
  -d '{
    "model": "claude-sonnet-4.5",
    "max_tokens": 4096,
    "system": "You are a tech news curator...",
    "messages": [
      {"role": "user", "content": "Newsletter data..."}
    ]
  }'

Critical n8n configuration:

System Message: Contains instructions for HTML output format, topic selection rules, and tone
User Message: Newsletter {{ $json.timestamp }} dynamically inserts context
Model Selection: claude-sonnet-4.5 balances speed and quality

Response structure:

{
  "id": "msg_abc123",
  "content": [
    {
      "type": "text",
      "text": "<!DOCTYPE html><html>...</html>"
    }
  ],
  "stop_reason": "end_turn"
}

Cost optimization: Each newsletter run consumes ~2,000-3,000 tokens (input + output). At $3 per million tokens for Sonnet, daily newsletters cost ~$0.01 per run or $3.65/year.

Common failures:

Token limit exceeded: Happens if RSS feed returns 50+ articles. Solution: Add a filter node before Claude to limit to 30 most recent items.
Invalid HTML output: Claude occasionally forgets closing tags. Solution: Add validation in system message: "Critical: Validate HTML syntax before responding."

Gmail API Integration

Gmail sending uses OAuth2 authentication with specific scopes:

// Gmail OAuth2 Scopes Required
[
  "https://www.googleapis.com/auth/gmail.send",
  "https://www.googleapis.com/auth/gmail.compose"
]

n8n Gmail node configuration:

{
  "resource": "message",
  "operation": "send",
  "to": "recipient@example.com",
  "subject": "Daily Newsletter",
  "emailType": "html",
  "message": "{{ $json.output }}"
}

Authentication debugging:

Credential error: Re-authenticate in n8n credentials manager
"Insufficient permissions": Check OAuth scope includes gmail.send
Rate limit: Gmail allows 500 emails/day for free accounts

Expression syntax: {{ $json.output }} pulls the AI-generated HTML from the previous node. If your Claude node outputs to a different field, adjust accordingly.

Implementation Gotchas

Handling missing RSS data:
Some feeds omit descriptions. Add this to your Claude system message:

If article description is missing, use the title to infer topic relevance.

Timezone configuration:
The schedule trigger uses your n8n instance timezone. If you want 8 AM EST but n8n runs on UTC, calculate the offset (8 AM EST = 1 PM UTC).

AI prompt engineering:
Claude's output quality depends heavily on system message specificity. Key instructions:

"Select 5 stories across DIVERSE topics" (prevents 5 Apple articles)
"Output ONLY complete HTML" (prevents markdown or text output)
"Start with <!DOCTYPE html>" (ensures valid HTML5)

Email deliverability:
HTML emails without proper headers can land in spam. The Gmail node handles this automatically, but if you switch to SMTP:

Headers:
  Content-Type: text/html; charset=UTF-8
  MIME-Version: 1.0

Data validation:
Add an IF node after RSS to filter out:

Articles older than 24 hours
Duplicate URLs (use Set node to deduplicate)
Invalid dates (some feeds use non-standard formats)

Prerequisites

Required accounts and credentials:

n8n instance (self-hosted or cloud)
Anthropic API key ($5 free credit for testing)
Gmail account with OAuth2 configured in n8n
RSS feed URL (The Verge included by default)

Estimated API costs:

Claude Sonnet: ~$0.01 per newsletter
Gmail: Free (up to 500 emails/day)
RSS feeds: Free

Setup time: 15-20 minutes for initial configuration, 5 minutes for additional RSS sources.

Get the Complete Workflow Configuration

This tutorial covers the n8n architecture and API integration patterns. For the complete workflow JSON file with all node configurations, the detailed system prompt for Claude, and a video walkthrough showing the execution, check out the full implementation guide.

Building an Automated Broken Link Checker with n8n and Google Sheets

Hackceleration — Tue, 03 Feb 2026 10:01:11 +0000

Dead links damage SEO rankings and frustrate users, but manually checking hundreds of pages is impractical. This n8n workflow automatically scans your entire website daily, tests every internal link using HTTP HEAD requests, and logs broken URLs to Google Sheets with their source pages. Here's how to architect this integration in n8n.

Architecture Overview

The workflow operates in two connected parts:

Main Workflow (Orchestration)

1. Schedule Trigger (daily midnight)
2. Fetch XML sitemap
3. Parse XML to JSON
4. Extract page URLs
5. For each page:
   - Download HTML content
   - Extract all internal links (regex filtering)
6. Send aggregated links to sub-workflow webhook
7. Create dated Google Sheets report
8. Move report to dedicated Drive folder

Sub-Workflow (Link Testing)

1. Receive links via webhook
2. For each link:
   - Send HTTP HEAD request
   - Check status code
   - If ≠ 200: Log to Google Sheets
3. Return results to main workflow

Why this architecture? Separating orchestration from testing prevents timeout issues on large sites. The main workflow completes quickly after delegating link testing to the webhook-triggered sub-workflow, which processes links asynchronously. Using HTTP HEAD requests instead of GET requests reduces bandwidth by ~95% since we only need response headers, not full page content.

API Integration Deep-Dive

XML Sitemap Fetching

The workflow starts by downloading your sitemap—a structured list of all pages you want indexed:

// HTTP Request node configuration
GET https://yourdomain.com/sitemap.xml
Headers: {}
Authentication: None

Response structure (XML):

<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
  <url>
    <loc>https://yourdomain.com/page1</loc>
    <lastmod>2025-01-15</lastmod>
  </url>
  <url>
    <loc>https://yourdomain.com/page2</loc>
  </url>
</urlset>

The XML to JSON node converts this to:

{
  "urlset": {
    "url": [
      {"loc": "https://yourdomain.com/page1"},
      {"loc": "https://yourdomain.com/page2"}
    ]
  }
}

What happens when sitemap is missing? The HTTP Request node returns a 404 error and the workflow fails. Always verify your sitemap URL before first run—common paths include /sitemap.xml, /sitemap_index.xml, or /page-sitemap.xml for WordPress sites with SEO plugins.

Link Extraction with Smart Filtering

The Code node extracts URLs from HTML using regex, then filters aggressively:

// Extract all URLs from HTML
const html = $input.item.json.data;
const urlRegex = /href=["']([^"']+)["']|src=["']([^"']+)["']/gi;
const matches = [...html.matchAll(urlRegex)];

// Deduplicate
const uniqueUrls = [...new Set(matches.map(m => m[1] || m[2]))];

// Filter CDN and static assets
const cdnPatterns = [
  /cloudflare\.com/,
  /cloudfront\.net/,
  /googleapis\.com/,
  /gstatic\.com/
];

const staticExtensions = /\.(jpg|jpeg|png|gif|css|js|woff|woff2|ttf)$/i;

const filteredUrls = uniqueUrls.filter(url => 
  !cdnPatterns.some(pattern => pattern.test(url)) &&
  !staticExtensions.test(url)
);

Why filter CDN resources? CDN URLs rarely break (they're managed by providers like Cloudflare), and testing them wastes execution time. Static assets like images or fonts breaking won't affect SEO as critically as page-level 404s. This filtering reduces checks by 60-80% on typical sites.

HTTP HEAD Requests for Link Testing

Instead of downloading full pages, the workflow sends HEAD requests:

// HTTP Request node (sub-workflow)
HEAD {{ $json.url }}
Headers: {}
Ignore SSL Issues: true

Response example (200 OK):

{
  "statusCode": 200,
  "headers": {
    "content-type": "text/html",
    "content-length": "15234"
  }
}

Response example (404 Not Found):

{
  "statusCode": 404,
  "headers": {
    "content-type": "text/html"
  }
}

HEAD vs GET performance: A typical page GET request transfers 500KB-2MB. A HEAD request for the same URL transfers <1KB (just headers). For 1000 links, that's 500MB vs 500KB—a 1000x bandwidth reduction.

Google Sheets Logging

Broken links get written to Google Sheets using the Append Row operation:

// Google Sheets API call (abstracted by n8n node)
POST https://sheets.googleapis.com/v4/spreadsheets/{spreadsheetId}/values/Sheet1!A1:append
Authorization: Bearer {oauth_token}
Body: {
  "values": [[
    "https://yourdomain.com/source-page",
    "https://yourdomain.com/broken-link"
  ]]
}

Authentication: The node uses OAuth2 credentials configured in n8n. You'll need to authorize n8n to access your Google account once—the refresh token handles subsequent authentications automatically.

Rate limits: Google Sheets API allows 100 requests per 100 seconds per user. With one append per broken link, you can log ~6000 broken links per hour before hitting limits. For most sites, this is excessive headroom.

Implementation Gotchas

Handling Missing or Malformed Sitemaps

If your sitemap URL returns 404, the workflow fails immediately. Add error handling by setting "Continue On Fail" in the HTTP Request node, then add an IF node checking for statusCode === 200 before proceeding.

Webhook URL Configuration

The sub-workflow webhook must be accessible from your main workflow. If running n8n locally, use a tunneling service like ngrok for testing. In production, ensure your n8n instance has a public URL or internal network routing configured.

Dealing with Rate Limiting

Some sites implement aggressive rate limiting. If testing 1000+ links triggers IP blocks, add a Wait node between HTTP HEAD requests (50-100ms delay). This increases execution time but prevents false positives from rate limit 429 errors.

SSL Certificate Errors

The workflow enables "Ignore SSL Issues" to handle sites with expired certificates. This means you'll flag links as broken based on HTTP status codes, not SSL validity. If you need to exclude SSL errors, disable this option—but be prepared for false positives.

Authentication Errors

Google API credentials can expire or revoke. If the workflow suddenly fails with 401 errors, re-authenticate your Google Sheets credential in n8n's credential manager. The OAuth2 flow will refresh your access token.

Cost Optimization

n8n cloud pricing is based on workflow executions and data processed. To minimize costs:

Run the workflow during off-peak hours (midnight reduces server load competition)
Increase the Schedule Trigger interval to weekly instead of daily for smaller sites
Use the batch size parameter to process multiple links per execution rather than one-by-one

Common Failure Modes

Memory exhaustion: Sites with 10,000+ pages can exhaust n8n's memory during HTML parsing. Solution: Add pagination to the Split In Batches node (process 100 pages per batch, loop until complete).

Webhook timeout: If link testing takes >60 seconds, the webhook times out. Solution: Return an immediate 202 Accepted response, then continue processing asynchronously without waiting for completion.

Duplicate logging: If the workflow re-runs while still processing, you'll get duplicate Google Sheets rows. Solution: Add a Set node at the start that checks for existing executions using n8n's workflow API before proceeding.

Prerequisites

Required accounts and tools:

n8n instance (self-hosted or cloud) with active workflow execution
Google account with Sheets and Drive access
XML sitemap accessible at public URL
Google Drive folder for storing reports

API credentials needed:

Google Sheets OAuth2 credential in n8n
Google Drive OAuth2 credential in n8n

Estimated API costs:

Google Sheets API: Free (within 100 requests/100 seconds quota)
Google Drive API: Free (within 1000 requests/100 seconds quota)
n8n cloud: ~$20/month for 5000 workflow executions (if using hosted version)

Links to official documentation:

Get the Complete Workflow Configuration

This tutorial covers the API integration architecture and core logic for building a broken link checker in n8n. For the complete workflow JSON with all node configurations, visual workflow canvas screenshots, and a video walkthrough of the setup process, check out the full implementation guide.

Building an AI Meeting Scheduler with n8n, Gmail, and Google Calendar

Hackceleration — Tue, 27 Jan 2026 10:00:51 +0000

When someone emails you asking for a meeting, your AI agent needs to check your calendar, propose available times, and create the event once confirmed. Here's how to architect this integration using n8n, Gmail API, Google Calendar API, and Google Gemini.

Architecture Overview

The workflow follows this data flow:

Gmail (new message) → AI Agent → Calendar API (check availability) → AI Agent (compose reply) → Gmail API (send reply) → Calendar API (create event)

Why this architecture? Gmail's trigger provides the entry point, but the AI agent needs tools to query your calendar and send responses. Rather than hardcoding logic, the agent orchestrates API calls dynamically based on email content.

Alternatives considered: Calendly-style booking pages work but lack context awareness. This AI approach reads natural language requests and adapts to different communication styles.

Gmail API Integration

Authentication: OAuth2 flow with Gmail API scope https://www.googleapis.com/auth/gmail.modify

Polling for new messages:

// Gmail Trigger polls every 60 seconds
GET https://gmail.googleapis.com/gmail/v1/users/me/messages?q=is:unread
Headers: { "Authorization": "Bearer <access_token>" }

Response structure:

{
  "messages": [
    {
      "id": "18d4f2c8a9b3e7f1",
      "threadId": "18d4f2c8a9b3e7f1"
    }
  ]
}

Sending threaded replies:

POST https://gmail.googleapis.com/gmail/v1/users/me/messages/send
Headers: { "Authorization": "Bearer <access_token>" }
Body: {
  "threadId": "18d4f2c8a9b3e7f1",
  "raw": "<base64-encoded-email>"
}

Rate limits: 250 quota units per user per second. Each message send costs 100 units, so max 2.5 sends/second.

Error handling: 429 Too Many Requests requires exponential backoff. Invalid threadId returns 404 but message still sends (creates new thread).

Google Calendar API Integration

Authentication: OAuth2 with scope https://www.googleapis.com/auth/calendar

Fetching availability:

GET https://www.googleapis.com/calendar/v3/calendars/primary/events?timeMin=2025-01-20T00:00:00Z&timeMax=2025-02-03T23:59:59Z
Headers: { "Authorization": "Bearer <access_token>" }

Response structure:

{
  "items": [
    {
      "id": "event123",
      "start": { "dateTime": "2025-01-22T14:00:00Z" },
      "end": { "dateTime": "2025-01-22T15:00:00Z" },
      "summary": "Existing meeting"
    }
  ]
}

Creating events with Meet links:

POST https://www.googleapis.com/calendar/v3/calendars/primary/events?conferenceDataVersion=1
Headers: { "Authorization": "Bearer <access_token>" }
Body: {
  "summary": "Meeting with John",
  "start": { "dateTime": "2025-01-25T10:00:00Z" },
  "end": { "dateTime": "2025-01-25T11:00:00Z" },
  "attendees": [{"email": "john@example.com"}],
  "conferenceData": {
    "createRequest": { "requestId": "random-string-123" }
  }
}

Gotcha: conferenceDataVersion=1 query parameter is required for Meet link generation. Without it, conferenceData is ignored.

Rate limits: 500 requests per 100 seconds per user. Calendar reads cost 1 unit, writes cost 10 units.

Google Gemini API Configuration

Authentication: API key from Google AI Studio

Model request format:

POST https://generativelanguage.googleapis.com/v1beta/models/gemini-3-flash-preview:generateContent
Headers: { "x-goog-api-key": "<api-key>" }
Body: {
  "contents": [{
    "role": "user",
    "parts": [{ "text": "Check calendar and propose meeting times" }]
  }],
  "tools": [{
    "function_declarations": [
      { "name": "get_calendar_events", "parameters": {...} },
      { "name": "send_email", "parameters": {...} }
    ]
  }]
}

Response with tool calls:

{
  "candidates": [{
    "content": {
      "parts": [{
        "functionCall": {
          "name": "get_calendar_events",
          "args": { "timeMin": "2025-01-20", "timeMax": "2025-02-03" }
        }
      }]
    }
  }]
}

Cost: Gemini Flash charges $0.075 per 1M input tokens, $0.30 per 1M output tokens. Typical scheduling conversation: ~2,000 tokens total = $0.0006.

Implementation Gotchas

Missing email data: Gmail API sometimes returns messages without body content if they're still syncing. Add a 5-second delay after trigger fires.

Timezone handling: Calendar API returns times in UTC. Your AI agent prompt must specify your working hours in your local timezone:

"Working hours: 9:00-18:00 Europe/Paris. Convert all times to this timezone when proposing slots."

Duplicate event creation: If the agent receives the same meeting request twice (forwarded email, CC'd message), it might create duplicate events. Add a check for existing events with matching summary and attendee before creating.

AI hallucination on availability: The agent might propose times that appear free but ignore buffer time between meetings. Explicitly instruct: "Require 15-minute buffer before and after each event."

Email threading errors: When replying, if the original message's threadId is malformed, Gmail creates a new thread instead of replying inline. Always validate threadId format before using it.

Prerequisites

Required accounts:

n8n instance (self-hosted or cloud)
Google Cloud project with Gmail API and Calendar API enabled
Google AI Studio account for Gemini API key

API credentials needed:

Gmail OAuth2 client (client_id and client_secret from Google Cloud Console)
Google Calendar OAuth2 (same credentials work for both)
Gemini API key (from Google AI Studio)

Links to official docs:

Estimated costs:

n8n Cloud: Free tier supports 5,000 workflow executions/month
Gmail/Calendar API: Free (quota limits sufficient for personal use)
Gemini API: ~$0.02 per 100 scheduling conversations

Get the Complete n8n Workflow Configuration

This tutorial covers the API integration architecture and key implementation patterns. For the complete n8n workflow file with all node configurations, AI agent system prompt, and a video walkthrough of the setup process, check out the full implementation guide.