DEV Community: AgoraIntelligence

One Piece of Content, Four Platforms, One Webhook Call — Content Repurposing with n8n and GPT-4o-mini

AgoraIntelligence — Sun, 26 Jul 2026 17:33:02 +0000

One Piece of Content, Four Platforms, One Webhook Call — Content Repurposing with n8n and GPT-4o-mini

The biggest bottleneck in content marketing isn't ideas. It's adaptation.

You write a good LinkedIn post. Then you need to turn it into a Twitter thread. Then a Telegram message for your channel. Then a newsletter intro. Each platform has different tone, format, and length requirements. By the time you've adapted the same idea four times, you've spent an hour on distribution instead of creation.

This workflow collapses that hour into a single webhook call.

What It Does

Send a topic or article URL to an n8n webhook. Get back:

LinkedIn post — professional tone, 150-300 words, hook + insight + CTA
Twitter/X thread — 3 tweets, punchy, ready to paste
Telegram message — casual, with emojis, for your channel
Newsletter intro — subject line + opening paragraph, 100-150 words

LinkedIn and Telegram publish automatically. Twitter and newsletter content are returned ready-to-paste (X API requires a paid subscription — we skip that dependency).

Optionally: a DALL-E 3 image matching the content, 1024x1024.

Everything gets logged to Google Sheets.

Why One Webhook Call

The naive approach uses four separate OpenAI calls — one per platform. This costs 4× more tokens and introduces 4× more failure points.

The better approach: one structured JSON output call that returns all four variants simultaneously.

const prompt = `
You are a content strategist. Generate platform-optimized content for this topic.

Topic: ${topic}
Brand voice: ${CONFIG.brand_voice}
Language: ${CONFIG.language}
Industry: ${CONFIG.industry}

Return a JSON object with exactly these keys:
{
  "linkedin": "full LinkedIn post text",
  "twitter_thread": ["tweet 1", "tweet 2", "tweet 3"],
  "telegram": "Telegram message with emojis",
  "newsletter_subject": "Email subject line",
  "newsletter_intro": "Opening paragraph for newsletter"
}

Rules:
- LinkedIn: professional, add 3 relevant hashtags at the end
- Twitter: each tweet max 280 chars, thread format with numbering
- Telegram: conversational, 2-4 emojis, max 300 chars
- Newsletter: subject under 50 chars, intro under 150 words
`;

With response_format: { type: "json_object" } in the API call, you get clean structured output every time — no regex parsing, no format failures.

Workflow Architecture

Webhook (POST) → Parse input (topic/URL)
  → [Optional] Fetch URL → Extract article text
  → Code: Build structured prompt
  → OpenAI: Generate all 4 variants (JSON mode)
  → [Optional] DALL-E 3: Generate image
  → Parallel branches:
      → LinkedIn: Publish post via API
      → Telegram: Send via bot
      → Sheets: Log everything
  → Respond: Return JSON with all content + publish URLs

The parallel branches mean LinkedIn and Telegram publish simultaneously — no sequential wait.

Triggering It

The webhook accepts a simple POST:

curl -X POST https://your-n8n.com/webhook/repurpose \
  -H "Content-Type: application/json" \
  -d '{
    "topic": "Why most automation projects fail in the first 90 days",
    "url": null,
    "generate_image": false
  }'

Or with an article URL to repurpose:

curl -X POST https://your-n8n.com/webhook/repurpose \
  -H "Content-Type: application/json" \
  -d '{
    "topic": null,
    "url": "https://example.com/article-to-repurpose",
    "generate_image": true
  }'

Response includes all generated content plus publication status:

{
  "linkedin": "The #1 reason automation projects fail...",
  "twitter_thread": ["1/ Most companies start automating the wrong things...", "2/..."],
  "telegram": "🤖 Hot take: most automation projects die in month 2...",
  "newsletter_subject": "Why your automation will fail",
  "newsletter_intro": "Last quarter we analyzed...",
  "image_url": "https://oaidalleapiprodscus.blob.core.windows.net/...",
  "linkedin_post_id": "urn:li:share:123456",
  "telegram_message_id": 42,
  "logged_at": "2026-07-26T14:32:00Z"
}

The CONFIG Node

const CONFIG = {
  openai_credential: "your-openai-credential-id",

  // LinkedIn
  linkedin_access_token: "YOUR_LINKEDIN_TOKEN",
  linkedin_person_urn: "urn:li:person:YOUR_ID",

  // Telegram
  telegram_token: "YOUR_BOT_TOKEN",
  telegram_chat_id: "@yourchannel",

  // Google Sheets
  sheet_id: "YOUR_SPREADSHEET_ID",
  gcp_credential: "your-service-account-credential-id",

  // Content settings
  brand_voice: "professional but direct, no corporate jargon",
  language: "English",
  industry: "B2B SaaS / automation",
  default_hashtags: ["#automation", "#n8n", "#AI"],

  // Image generation (costs ~$0.04 per image with DALL-E 3)
  generate_images_by_default: false
};

LinkedIn API Setup

LinkedIn's API requires OAuth with w_member_social scope. The flow:

Create a LinkedIn App at linkedin.com/developers
Add w_member_social and r_liteprofile permissions
Generate an access token (valid 60 days — set a reminder to refresh)
Get your Person URN: GET https://api.linkedin.com/v2/userinfo

Publishing a post:

POST https://api.linkedin.com/v2/ugcPosts
Authorization: Bearer YOUR_TOKEN
Content-Type: application/json

{
  "author": "urn:li:person:YOUR_ID",
  "lifecycleState": "PUBLISHED",
  "specificContent": {
    "com.linkedin.ugc.ShareContent": {
      "shareCommentary": { "text": "{{linkedin_content}}" },
      "shareMediaCategory": "NONE"
    }
  },
  "visibility": { "com.linkedin.ugc.MemberNetworkVisibility": "PUBLIC" }
}

LinkedIn token expiry gotcha: tokens expire after 60 days. Either implement the OAuth refresh flow in n8n (complex) or set a calendar reminder to regenerate it. Most people do the calendar reminder.

Cost Per Run

Component	Cost
GPT-4o-mini (all 4 variants)	~$0.003
DALL-E 3 image (optional)	~$0.040
n8n execution	$0 (self-hosted)
Total without image	~$0.003
Total with image	~$0.043

At $0.003 per run, you'd need 333 daily repurposing runs to spend $1/day. For most content creators publishing 1-3 times per day, the monthly cost is under $0.30.

What This Is Good For (and What It Isn't)

Good for:

Repurposing blog posts and articles across channels
Consistent weekly content without the copy-paste grind
Teams where one person creates and others distribute

Not good for:

Content requiring deep research or original reporting
Platforms requiring native video/carousel formats
Situations where brand voice is extremely specific — AI needs calibration time

The quality improves dramatically when you fill in the brand_voice and industry fields with specifics. "Professional B2B SaaS company that sells to CTOs, writes like Paul Graham, no buzzwords" produces noticeably better output than "professional."

Get the Workflow

The complete 14-node workflow is available at n8nmarkets.com. Search "Social Media Content Repurposer".

Includes: workflow JSON, Sheets logging template, LinkedIn OAuth setup guide, and curl commands to test every branch before connecting real social accounts.

What's your current content distribution process? Curious whether people are using schedulers like Buffer/Hootsuite alongside this kind of automation, or replacing them entirely.

Stop Copying Meeting Details from Email to Calendar — Automate It with n8n and GPT-4o-mini

AgoraIntelligence — Sun, 26 Jul 2026 16:51:27 +0000

Stop Copying Meeting Details from Email to Calendar — Automate It with n8n and GPT-4o-mini

You receive a Calendly confirmation. Or a Zoom invite. Or an email that says "let's meet Tuesday at 3pm."

Every time, you open your calendar, create an event, copy the link, paste the details. Then you spend 5 minutes skimming the email thread trying to remember what the meeting is actually about before it starts.

This workflow eliminates both steps: it reads your Gmail every 15 minutes, detects meeting-related emails, creates the calendar event automatically, and sends you an AI-generated prep brief to Slack before you even open your inbox.

What It Detects

The workflow uses GPT-4o-mini to classify incoming emails. It catches:

Zoom / Google Meet / Teams confirmations — the standard automated confirmations from each platform
Calendly booking confirmations — "Your meeting with X has been confirmed"
Informal meeting requests — "Let's catch up Wednesday at 2pm" in a regular email
Flight and hotel reservations — date + time + location = calendar event
Restaurant reservations — same pattern
Calendar invitations forwarded via email

It ignores newsletters, marketing emails, no-reply senders, and promotional content. You configure the filter list once in the CONFIG node.

The Output

For each detected meeting, the workflow:

Creates a Google Calendar event with title, date, time, duration, location, and video link pre-filled
Generates a meeting brief via AI — context summary, 3-4 talking points, 2-3 questions to prepare
Sends the brief to Slack with a direct link to the calendar event
Logs the entry to Google Sheets — date, email subject, event created, AI brief status

The Slack message looks like this:

📅 Meeting Created: Discovery Call with Acme Corp
📍 Tuesday 29 Jul, 15:00 — 16:00 (Google Meet)
🔗 meet.google.com/abc-defg-hij

📋 Context: Acme Corp is exploring automation solutions for their sales team. 
They mentioned a current Zapier setup they want to move off of.

💡 Talking points:
• Their current Zapier spend and what's breaking
• Which workflows they need first
• Their technical setup (CRM, email tool, data sources)

❓ Questions to prepare:
• Who makes the final decision on tools?
• What's the timeline for implementation?

Workflow Architecture

Schedule (every 15 min)
  → Gmail: Read unread emails (last 30 min)
  → Filter: Remove newsletters/no-reply
  → OpenAI: Classify — is this a meeting? (YES/NO + extracted details)
  → IF YES:
      → Google Calendar: Create event
      → OpenAI: Generate prep brief
      → Slack: Send brief + calendar link
      → Gmail: Mark as read + label "calendar-added"
      → Sheets: Log entry
  → IF NO: Skip

The AI Extraction Prompt

This is the most important node — the quality of the calendar event depends on how well you extract from the email:

You are a scheduling assistant. Extract meeting details from this email.

Email subject: {{subject}}
Email body: {{body}}
Sender: {{from}}
Today's date: {{today}}

Return a JSON object with:
{
  "is_meeting": true/false,
  "title": "Meeting title (descriptive, not the email subject)",
  "date": "YYYY-MM-DD",
  "time": "HH:MM",
  "duration_minutes": 60,
  "timezone": "Europe/Madrid",
  "video_link": "https://... or null",
  "location": "physical address or null",
  "attendees": ["email1", "email2"],
  "context": "2-3 sentence summary of what this meeting is about",
  "confidence": 0.0-1.0
}

If is_meeting is false, return only {"is_meeting": false}.
Only return the JSON object, no other text.

Set a confidence threshold (e.g. 0.7) — below that, skip the event creation and log it for manual review instead.

Gmail Deduplication

The biggest practical problem with email-to-calendar workflows: you don't want the same meeting created twice if you receive multiple confirmation emails (original invite + reminder + updated time).

Two solutions:

Option A — Label-based: After processing an email, add a Gmail label calendar-added. The next run filters out emails with this label.

Option B — Sheets-based: Log the email Message-ID to a Sheets column and check for duplicates before creating the event.

Label-based is simpler and more reliable. Add a Gmail node at the end of the success branch:

Gmail → Modify Message → Add Label: calendar-added

On the read step, filter: is:unread -label:calendar-added newer_than:1h

Handling Timezone Ambiguity

"Meet Tuesday at 3pm" — 3pm where?

The prep brief prompt includes your configured timezone. If the email doesn't specify, the workflow defaults to your timezone. Add a note to the Slack message when timezone was assumed rather than explicit:

const timezoneNote = detectedTimezone 
  ? `🌍 Timezone: ${detectedTimezone}` 
  : `⚠️ Timezone assumed: ${CONFIG.default_timezone}`;

Cost

At 50 emails/day processed through GPT-4o-mini:

Classification call: ~200 tokens per email → $0.003/day
Brief generation (meetings only, ~20% of emails): ~500 tokens → $0.0015/day
Total: ~$0.0045/day → ~$1.35/month

For a professional who books 5-10 meetings per week, the time saved (5+ minutes per meeting) pays back the cost in the first hour of the first day.

The CONFIG Node

One node controls everything:

const CONFIG = {
  gmail_credential: "your-gmail-oauth-credential-id",
  calendar_id: "primary",  // or specific calendar ID
  slack_webhook: "https://hooks.slack.com/services/...",
  sheets_id: "your-spreadsheet-id",
  openai_credential: "your-openai-credential-id",

  // Your profile (personalizes the brief)
  your_name: "Igor",
  your_role: "Automation consultant",
  your_company: "Agora Intelligence",

  // Filter: emails from these domains are always skipped
  skip_domains: ["mailchimp.com", "klaviyo.com", "newsletter"],
  skip_senders: ["noreply", "no-reply", "donotreply"],

  // Minimum confidence to create a calendar event (0-1)
  confidence_threshold: 0.7,

  // Default timezone when not specified in email
  default_timezone: "Europe/Madrid"
};

Get the Complete Workflow

The full 18-node workflow — with Gmail deduplication, confidence thresholds, timezone handling, Slack formatting, and Sheets logging — is available at n8nmarkets.com. Search "Email to Calendar AI Meeting Prep".

Includes the workflow JSON, Google Sheets template, and setup guide for Gmail OAuth (the most common friction point).

What meeting-related emails do you receive most often? The workflow handles standard confirmations well, but I'm curious what edge cases people run into — forwarded invites, multi-timezone teams, recurring meetings with agenda updates.

Extract Business Leads from Google Maps with Emails — Automated Pipeline with n8n and Apify

AgoraIntelligence — Sun, 26 Jul 2026 16:50:27 +0000

Extract Business Leads from Google Maps with Emails — Automated Pipeline with n8n and Apify

Cold outreach only works if you have good data. Most lead lists are outdated, incomplete, or scraped from directories that haven't been maintained in years.

Google Maps is the opposite: it's the most maintained business directory on the planet, updated in real-time by business owners and users. This tutorial shows how to build an automated pipeline that extracts business leads from Google Maps — complete with contact emails scraped from their websites — and delivers them as a clean spreadsheet.

What the Pipeline Extracts

For each business in your search results:

Business name, category, address
Phone number
Website URL
Google rating and review count
Opening hours
Contact emails (scraped from the business website)
Direct Google Maps URL

A search for "dentistas Madrid" returns 20-50 businesses in one run. A search for "plumbers London" or "restaurants Barcelona" works identically.

Architecture: Two-Phase Extraction

The extraction runs in two phases to handle Google Maps' dynamic JavaScript rendering:

Phase 1 — Search results scraping
Navigate to google.com/maps/search/[query], scroll the results feed to load all listings, collect the URL of each place page.

Phase 2 — Detail page extraction

Visit each place URL individually to extract the structured data (phone, address, website, rating). Then fetch the business website to find contact emails.

This two-phase approach avoids the timeout issues that come from trying to extract everything in one pass on a dynamic-loading page.

The Email Extraction Logic

Emails are scraped from these pages on each business website (in order):

Homepage
/contact or /contacto
/about or /sobre-nosotros

The scraper stops after finding 3 valid emails per domain. It filters out:

Generic/no-reply addresses (noreply@, postmaster@, etc.)
System emails (@sentry.io, @amazonaws.com, etc.)
Placeholder addresses (@example.com, @yourdomain.com)
False positives from CSS/JS files (e.g. background.png@)

const SKIP_DOMAINS = [
  'example.com', 'sentry.io', 'google.com', 'googleapis.com',
  'wixpress.com', 'shopify.com', 'amazonaws.com', 'cloudflare.com',
];

function isValidEmail(email) {
  const lower = email.toLowerCase();
  if (SKIP_DOMAINS.some(d => lower.endsWith('@' + d))) return false;
  if (/\.(png|jpg|svg|css|js)$/i.test(lower)) return false;
  if (/^(noreply|no-reply|donotreply|postmaster)/i.test(lower.split('@')[0])) return false;
  return true;
}

Typical email hit rate: 40-60% of businesses have a public email on their website.

Option A: Build It Yourself (n8n + Playwright)

If you're self-hosting n8n on a VPS, you can run the full pipeline yourself.

Node structure:

Manual Trigger / Schedule
  → Code: Build search URL
  → Playwright: Scrape Maps search results
  → Split In Batches (1 at a time)
  → Playwright: Extract place details
  → HTTP Request: Fetch business website
  → Code: Extract emails with regex
  → Google Sheets: Append row

The key Playwright snippet for collecting place links:

async function collectPlaceLinks(page, maxResults) {
  const collected = new Set();
  let noGrowthRounds = 0;

  while (collected.size < maxResults) {
    const links = await page.$$eval(
      'a[href*="/maps/place/"]',
      els => els.map(el => el.href)
    );
    links.forEach(l => collected.add(l));

    // Scroll to load more
    await page.evaluate(() => {
      const feed = document.querySelector('div[role="feed"]');
      if (feed) feed.scrollBy(0, 1200);
    });
    await page.waitForTimeout(1800);

    // Stop if no new results after 3 scrolls
    if (collected.size === prevSize) noGrowthRounds++;
    if (noGrowthRounds >= 3) break;
  }
  return [...collected].slice(0, maxResults);
}

Memory warning: Don't run more than 1 concurrent browser instance. Google Maps detail pages are heavy. Process one place at a time (maxConcurrency: 1).

Option B: Use the Apify Actor (No Infrastructure Needed)

If you don't want to manage Playwright on your own infrastructure, the same pipeline is available as an Apify actor.

Apify handles the browser infrastructure, proxies, and scaling. You provide the search parameters and get back a structured dataset.

Input:

{
  "query": "dentistas",
  "location": "Madrid",
  "maxResults": 50,
  "extractEmails": true,
  "language": "es"
}

Output (per business):

{
  "name": "Clínica Dental López",
  "address": "Calle Gran Vía 28, Madrid",
  "phone": "+34 91 123 4567",
  "website": "https://clinicadentallopez.es",
  "rating": 4.7,
  "reviewCount": 183,
  "category": "Dentist",
  "hours": "Mon-Fri 9:00-20:00",
  "emails": ["info@clinicadentallopez.es"],
  "mapsUrl": "https://www.google.com/maps/place/..."
}

Pricing: $0.002 per result (pay-per-use, no subscription). 50 leads = $0.10.

The actor is Google Maps Business Enricher on Apify Store.

The Google Sheets Output

The pipeline writes directly to a Google Sheet with these columns:

Name | Address | Phone | Website | Rating | Reviews | Category | Hours | Emails | Maps URL | Extracted At

From there you can:

Filter by rating to only target well-reviewed businesses
Filter by email presence for immediate outreach
Sort by review count to find established businesses (not fly-by-night)
Export to CSV for your email tool

Use Cases

Agency prospecting: "Marketing agencies" + city → cold email pitch

B2B sales: "Clinics" + region → pitch your SaaS

Market research: Count how many businesses in a category exist in a city

Competitor mapping: Find all competitors in your area with their ratings

Supplier discovery: Find local suppliers in a specific category

Legal Considerations

This scrapes publicly available information from Google Maps and business websites — the same data you'd see if you searched manually. Treat the output like any other public directory data:

Don't use it for spam
Respect GDPR/CAN-SPAM — include unsubscribe options in any outreach
Only contact businesses that are relevant to your offer

Get the Ready-Made Workflow

The n8n workflow version (for self-hosted setups) is available at n8nmarkets.com. Search "Google Maps Local Service Leads".

The Apify actor (no infrastructure needed, pay-per-result) is at apify.com/agoradelmediterraneo/google-maps-business-enricher.

What niche are you targeting for outreach? Curious to hear what verticals people are using this type of data for.

Never Miss a Stripe Payment Again — Real-Time Alerts on Slack, Discord and Telegram with n8n

AgoraIntelligence — Sun, 26 Jul 2026 16:21:33 +0000

Never Miss a Stripe Payment Again — Real-Time Alerts on Slack, Discord and Telegram with n8n

Stripe processes the payment. You find out 3 hours later when you check your dashboard.

For solo founders and small teams, missing real-time payment events isn't just inconvenient — it means slower fulfillment, delayed onboarding, and missed opportunities to catch failed payments before customers churn.

This tutorial shows how to build a Stripe → multi-channel alert system with n8n that notifies your whole team instantly, in whichever app you actually use.

What Gets Alerted

The workflow listens to five Stripe webhook events:

Event	What it means	Who cares
`payment_intent.succeeded`	Customer paid	Everyone 🎉
`payment_intent.payment_failed`	Card declined	Support team
`charge.refunded`	Refund issued	Finance
`customer.subscription.deleted`	Subscription cancelled	Sales/CS
`invoice.payment_failed`	Recurring payment failed	Finance

Each event generates a formatted message delivered simultaneously to Slack, Discord, Telegram, and/or email — your choice.

The Slack Message Format

Instead of raw JSON, the alerts are formatted for humans:

💰 New Payment
Amount: €149.00
Customer: Acme Corp (billing@acme.com)
Product: Professional Plan
Payment ID: pi_3abc...
Time: 26 Jul 2026, 14:32

For failed payments:

⚠️ Payment Failed
Amount: €149.00
Customer: john@example.com
Reason: insufficient_funds
Retry: Stripe will retry in 3 days
Payment ID: pi_3xyz...

n8n Setup

1. Stripe Webhook

In your Stripe Dashboard → Developers → Webhooks → Add endpoint:

Endpoint URL: https://your-n8n.com/webhook/stripe-alerts
Events to send: Select the 5 events listed above

Copy the Signing Secret — you'll need it to verify webhook authenticity.

2. Webhook Verification (Security)

Always verify Stripe webhooks. n8n's built-in Stripe Trigger node handles this automatically. If you're using a plain Webhook node, add this verification in a Code node:

const stripe = require('stripe'); // not available in n8n — use the Stripe Trigger node instead

Use the Stripe Trigger node — it handles signature verification out of the box. Don't use a plain Webhook node for Stripe.

3. The Event Router

After the Stripe Trigger, add a Switch node that routes on {{$json.type}}:

payment_intent.succeeded → Branch 1
payment_intent.payment_failed → Branch 2
charge.refunded → Branch 3
customer.subscription.deleted → Branch 4
invoice.payment_failed → Branch 5

Each branch formats the message and sends to your channels.

4. Message Formatting (Code Node)

const event = $input.first().json;
const type = event.type;
const obj = event.data.object;

let emoji, title, details;

if (type === 'payment_intent.succeeded') {
  emoji = '💰';
  title = 'New Payment';
  const amount = (obj.amount / 100).toFixed(2);
  const currency = obj.currency.toUpperCase();
  details = `Amount: ${currency} ${amount}\nCustomer: ${obj.customer || 'Guest'}\nID: ${obj.id}`;

} else if (type === 'payment_intent.payment_failed') {
  emoji = '⚠️';
  title = 'Payment Failed';
  const amount = (obj.amount / 100).toFixed(2);
  const reason = obj.last_payment_error?.message || 'Unknown reason';
  details = `Amount: ${obj.currency.toUpperCase()} ${amount}\nReason: ${reason}\nID: ${obj.id}`;

} else if (type === 'charge.refunded') {
  emoji = '↩️';
  title = 'Refund Issued';
  const amount = (obj.amount_refunded / 100).toFixed(2);
  details = `Amount refunded: ${obj.currency.toUpperCase()} ${amount}\nCustomer: ${obj.customer || 'Guest'}`;
}

const message = `${emoji} *${title}*\n${details}\n_${new Date().toLocaleString('en-GB')}_`;
return [{ json: { message, type, raw: obj } }];

5. Multi-Channel Delivery

Connect the formatted message to all your channels in parallel (use Merge node if you want a single execution path):

Slack — HTTP Request:

POST https://hooks.slack.com/services/YOUR/WEBHOOK/URL
Body: { "text": "{{$json.message}}" }

Discord — HTTP Request:

POST https://discord.com/api/webhooks/YOUR_WEBHOOK_URL
Body: { "content": "{{$json.message}}" }

Telegram — HTTP Request:

POST https://api.telegram.org/botYOUR_TOKEN/sendMessage
Body: { "chat_id": "YOUR_CHAT_ID", "text": "{{$json.message}}", "parse_mode": "Markdown" }

6. Google Sheets Logging

Every event also appends a row to your Sheets log:

Timestamp | Event Type | Amount | Currency | Customer Email | Payment ID | Status

This gives you a complete audit trail outside Stripe — useful for reconciliation, and for team members who don't have Stripe access.

Filtering by Amount (Optional)

Don't want a Slack notification for every $1 microtransaction? Add an IF node before the Slack branch:

// Only alert Slack for payments over €50
return $json.raw.amount > 5000; // Stripe amounts in cents

Discord can still log everything, Slack only gets the significant ones.

Estimated Setup Time

Stripe webhook: 5 minutes
n8n workflow import and configure: 10 minutes
Slack/Discord/Telegram webhook URLs: 5 minutes each
Test with Stripe's webhook simulator: 5 minutes

Total: ~30 minutes to first real-time alert.

Get the Pre-Built Workflow

The complete workflow with all 5 event types, formatting logic, and multi-channel delivery configured is available at n8nmarkets.com. Search "Stripe Payment Alerts Slack Discord SMS Email Sheets".

Includes the workflow JSON ready to import, plus setup guide for each notification channel.

Which Stripe events do you find most useful to monitor in real-time? For most SaaS teams it's failed payments — catching those within minutes instead of hours dramatically improves recovery rates.

Stop Chasing Unpaid Invoices Manually — Automate It with n8n

AgoraIntelligence — Sun, 26 Jul 2026 16:20:54 +0000

Stop Chasing Unpaid Invoices Manually — Automate It with n8n

If you're a freelancer or small business owner, you know the drill: invoice sent, due date passes, silence. You draft a polite reminder, send it, wait. Draft a firmer one. Hate yourself a little. Repeat.

This tutorial shows how to build a fully automated invoice follow-up system with n8n that sends escalating reminders on its own — and stops the moment someone pays.

The Problem with Manual Follow-Up

Manual invoice chasing fails in predictable ways:

You forget (you're busy running the actual business)
You remember at 11pm and decide to send it "tomorrow"
Tomorrow you forget again
45 days overdue you finally send a strongly-worded email that damages the relationship

Automation solves all three failure modes. The system doesn't forget, doesn't feel awkward, and stops exactly when it should.

How the Workflow Works

The system reads a Google Sheets invoice list every morning and applies simple date logic:

For each invoice where status = "unpaid":
  - 3 days overdue → send reminder_1 (friendly)
  - 7 days overdue → send reminder_2 (firmer)
  - 14+ days overdue → send reminder_3 (urgent) + Slack alert to you
  - Already sent today → skip

When you mark an invoice as paid in the sheet, the system automatically stops. No code needed.

The Google Sheets Structure

Create a sheet with these exact headers:

client_name	client_email	amount	currency	invoice_date	due_date	status	last_email_sent	notes
Acme Corp	billing@acme.com	2500	EUR	2026-07-01	2026-07-15	unpaid

status: unpaid / paid / disputed / skip
last_email_sent: filled automatically by the workflow
notes: optional context for the AI-generated emails

The Three Email Tiers

Tier 1 — Friendly Reminder (3 days overdue)

Subject: Invoice {{invoice_number}} — Just a quick reminder

Hi {{client_name}},

I hope all is well. I wanted to send a friendly reminder that invoice 
{{invoice_number}} for {{amount}} {{currency}} was due on {{due_date}}.

If payment has already been sent, please disregard this message. 
If you have any questions, I'm happy to help.

Best regards,
{{your_name}}

Tier 2 — Direct Follow-Up (7 days overdue)

Subject: Invoice {{invoice_number}} — Payment overdue

Hi {{client_name}},

I'm following up on invoice {{invoice_number}} for {{amount}} {{currency}}, 
which was due on {{due_date}} and remains outstanding.

Could you confirm when we can expect payment? 
If there's an issue I can help resolve, please let me know.

{{your_name}}

Tier 3 — Escalation (14+ days overdue)

Subject: Urgent: Invoice {{invoice_number}} — 14 days overdue

Hi {{client_name}},

Invoice {{invoice_number}} for {{amount}} {{currency}} is now 14 days overdue.
This is my final reminder before I escalate this matter further.

Please arrange payment by {{date_5_days_from_now}} or contact me to discuss.

{{your_name}}

At Tier 3, the workflow also sends a Slack message to alert you that this invoice needs your personal attention.

Key n8n Nodes

1. Schedule Trigger — runs every day at 8am

2. Google Sheets Read — reads all rows where status = unpaid

Uses HTTP Request to Sheets API v4 (not the native node — it's unreliable for filtered reads):

GET https://sheets.googleapis.com/v4/spreadsheets/{{SHEET_ID}}/values/Sheet1!A:I

3. Code Node — Calculate Days Overdue

const today = new Date();
return items.map(item => {
  const dueDate = new Date(item.json.due_date);
  const daysOverdue = Math.floor((today - dueDate) / (1000 * 60 * 60 * 24));
  const lastSent = item.json.last_email_sent 
    ? new Date(item.json.last_email_sent) 
    : null;
  const sentToday = lastSent && lastSent.toDateString() === today.toDateString();

  return {
    json: {
      ...item.json,
      daysOverdue,
      sentToday,
      tier: daysOverdue >= 14 ? 3 : daysOverdue >= 7 ? 2 : daysOverdue >= 3 ? 1 : 0
    }
  };
});

4. IF Node — filters to tier > 0 AND NOT sentToday

5. Switch Node — routes to the correct email template based on tier

6. Gmail/SMTP Send — sends the email

7. Google Sheets Update — marks last_email_sent with today's date

8. IF Node (Tier 3 only) — sends Slack alert

The Stop Logic

This is the most important part: the system never emails a paid client.

The workflow reads the status column first. If status is paid, disputed, or skip, the row is filtered out before any date calculation. Change the status in the sheet → emails stop immediately, no workflow restart needed.

Results: What to Expect

From building this for several service businesses:

Average days-to-payment drops from 28 to 11 when automated reminders are active
Fewer awkward conversations — clients treat automated reminders differently than personal ones
Zero maintenance once set up — it just runs every morning

The psychological trick: clients know automated systems don't hold grudges. They pay the automated reminder without the social friction of ignoring a personal message.

Costs

n8n: $0 self-hosted
Gmail API: Free (standard Gmail limits apply)
Google Sheets: Free
Slack: Free for basic webhooks

Total: $0/month if you're already using these tools.

Get the Ready-to-Import Workflow

The complete workflow JSON — with all nodes configured, the Sheets template, and Gmail/SMTP setup guide — is available at n8nmarkets.com. Search "Invoice Chaser Auto Follow-Up".

Includes: workflow JSON, Google Sheets template with exact headers, 3 email templates in English and Spanish, and a troubleshooting guide for common Gmail OAuth issues.

What's your current average days-to-payment? And has automated follow-up changed that number for you? Curious to see real data in the comments.

Build an AI WhatsApp Customer Service Bot with n8n (No Code, 30 Minutes)

AgoraIntelligence — Sun, 26 Jul 2026 16:19:17 +0000

Your WhatsApp Business account receives a message at 11pm. It's a potential client asking about your services. By the time you see it tomorrow morning, they've already bought from a competitor.

This tutorial shows you how to build a 24/7 AI-powered WhatsApp customer service bot using n8n that:

Classifies every incoming message (urgent complaint, booking request, general info)
Replies automatically with AI-generated responses personalized to your business
Escalates to your phone via Telegram when something actually needs your attention
Logs everything to Google Sheets for review

No coding required. Setup time: ~30 minutes.

How It Works

The workflow has 9 nodes and follows a simple decision tree:

WhatsApp webhook → Parse message → Classify intent (GPT-4o-mini)
       ↓
   URGENT? → Yes → Telegram alert + log
       ↓ No
   Generate AI reply → Send via WhatsApp API → Log to Sheets → Respond 200

The Intent Classification

The OpenAI node classifies each message into one of four intents:

URGENT — complaints, cancellation threats, problems ("the product arrived broken")
INFO — general questions ("what are your hours?", "do you deliver to Madrid?")
BOOKING — appointment requests ("I'd like to book for Friday at 5pm")
OTHER — anything else

This is the key logic that decides whether you get woken up or the bot handles it silently.

Step-by-Step Setup

1. WhatsApp Cloud API (Meta)

Go to developers.facebook.com, create an app, add WhatsApp product, and get:

Phone Number ID
Access Token (temporary → convert to permanent)
Verify Token (you invent this, e.g. my_verify_token_2026)

Set up the webhook to point to your n8n instance:

Webhook URL: https://your-n8n.com/webhook/whatsapp-bot
Subscribed fields: messages

2. The n8n Webhook Node

Configure as POST, path: whatsapp-bot. The webhook also needs to handle GET requests for Meta's verification challenge — add a second route or use an IF node to detect the hub.challenge parameter.

3. The CONFIG Node (the only node you edit)

All settings live in one Code node at the top:

const CONFIG = {
  // WhatsApp
  wa_phone_id: "YOUR_PHONE_NUMBER_ID",
  wa_token: "YOUR_WHATSAPP_ACCESS_TOKEN",

  // Telegram escalation  
  telegram_token: "YOUR_BOT_TOKEN",
  telegram_chat_id: "YOUR_CHAT_ID",

  // Google Sheets
  sheet_id: "YOUR_SPREADSHEET_ID",
  gcp_service_account: "vcWuMisYV6Kfx8Vv", // your n8n credential ID

  // AI context — this is what makes replies feel personalized
  business_name: "Clínica Dental Sánchez",
  business_description: "Clínica dental en Madrid, servicios: limpiezas, ortodoncia, implantes. Horario L-V 9-20h, S 9-14h.",
  escalation_keywords: ["urgente", "problema", "queja", "cancelar", "devolver"],
  openai_credential_id: "bC16OOi5YkUp5C10",

  // Fallback if OpenAI fails
  fallback_reply: "Gracias por tu mensaje. Te responderemos lo antes posible en horario laboral."
};

return [{ json: CONFIG }];

4. The AI Reply Generation

The OpenAI node that generates replies uses this prompt structure:

You are a customer service assistant for {{business_name}}.

Business context: {{business_description}}

Customer message: {{message_text}}
Message intent: {{classified_intent}}

Reply professionally in the same language as the customer's message. 
Keep it under 3 sentences. Don't make up information not in the business context.

This is what makes the bot sound like it actually knows your business — not a generic chatbot.

5. Send the WhatsApp Reply

The HTTP Request node sends back via the Cloud API:

POST https://graph.facebook.com/v19.0/{{wa_phone_id}}/messages
Authorization: Bearer {{wa_token}}
Content-Type: application/json

{
  "messaging_product": "whatsapp",
  "to": "{{sender_phone}}",
  "type": "text",
  "text": { "body": "{{ai_reply}}" }
}

6. The Critical Last Node: Respond 200

This is the most important node that most tutorials miss.

WhatsApp requires your webhook to respond with HTTP 200 within 20 seconds. If it doesn't, Meta marks your webhook as unhealthy and stops sending events.

Add a Respond to Webhook node at the very end of every branch (urgent AND non-urgent) that returns {"status": "ok"} with status 200.

Costs

n8n: $0 if self-hosted, $20/month on n8n Cloud
WhatsApp Cloud API: Free for the first 1,000 conversations/month (Meta's pricing)
OpenAI GPT-4o-mini: ~$0.00015 per message. At 100 messages/day: ~$0.46/month
Telegram bot: Free

Total for a small business with 100 messages/day: ~$0.46/month in AI costs.

What It Handles (and What It Doesn't)

Handles well:

Repeated FAQ questions (hours, pricing, location, delivery)
Booking confirmations
First contact from new customers
After-hours messages

Needs human review:

Complaints about specific orders (bot can acknowledge, but you close the ticket)
Anything requiring account access or personal data lookup
Complex negotiations

The Telegram escalation handles the "needs human review" bucket automatically.

Demo: What a Conversation Looks Like

Customer sends: "Hola, ¿tenéis cita disponible para limpieza este sábado por la mañana?"

Bot replies (in ~3 seconds): "¡Hola! Sí, tenemos citas disponibles los sábados de 9 a 14h. Para reservar, díganos su nombre y el horario preferido y lo gestionamos enseguida."

Customer sends: "El producto que compré llegó roto, exijo una solución AHORA"

Bot triggers Telegram alert to you: 🚨 URGENTE | +34612345678 | "El producto que compré llegó roto, exijo una solución AHORA"

You reply personally. The customer feels heard.

Get the Ready-Made Workflow

If you want to skip the manual setup, the complete workflow with all nodes pre-configured is available on n8nmarkets.com — search "WhatsApp Telegram AI Customer Service Agent".

It includes the workflow JSON, README with screenshots, and curl commands to test every node before going live.

Built something similar? Share your setup in the comments — especially if you've handled the webhook verification challenge in a clever way.

Querying EU Company Registries from Python — No Dun & Bradstreet Required

AgoraIntelligence — Tue, 21 Jul 2026 10:01:02 +0000

Querying EU Company Registries from Python — No Dun & Bradstreet Required

I was doing due diligence on a Spanish startup last month. Needed to verify they were registered with the tax authority, check their filing status, and see if there were any red flags in their recent updates. The usual approach would be to pay Dun & Bradstreet or similar. Instead, I built a Python wrapper around BORME (Spain's official business registry) and figured if it saved me time, it might save someone else time too.

The problem: BORME exists, it's free, it's official government data — 2.8M Spanish companies. But accessing it requires navigating redirects, session handling, and understanding their archaic query format. Same story with SIRENE in France or Companies House in the UK. Each one is public, but each one is a different puzzle.

The quick version

import requests

# Query the BORME registry for a Spanish company
response = requests.get(
    "https://api.rapidapi.com/v1/spain/borme/company",
    params={"name": "Telefonica", "limit": 5},
    headers={"X-RapidAPI-Key": "YOUR_KEY"}
)

companies = response.json()
for company in companies:
    print(f"{company['name']} — VAT: {company['tax_id']} — Active: {company['active']}")

That's it. Three lines to pull official data from Spain's registry, no scraping, no session cookies to manage.

Why I built this

When I need to check a European company, I want:

Official data only — not aggregators, not guesses. The Spanish government maintains BORME, I want BORME.
Unified interface — BORME, SIRENE, Companies House all use different query models. I want one Python pattern that works for all three.
No licensing costs — The data is public. Why should I pay $50/month to access something governments publish for free?

The workflow I ended up with:

Query BORME for Spanish companies (2.8M records)
Query SIRENE for French companies (25M records) — same pattern, different country
Query Companies House for UK companies (5M records)
Cross-reference the results, flag any discrepancies

For the startup I was checking, it took 30 seconds to confirm they were registered since 2019, had filed their 2024 statements, and had no liquidation notices. That's due diligence done.

What's available now

I packaged this into a set of APIs so I don't have to rebuild it each time:

Spain BORME: 2.8M companies, updated daily
France SIRENE: 25M companies, official INSEE data
UK Companies House: 5M companies, Companies House direct feed
EU Public Tenders TED: 300K+ procurement notices, searchable by keyword and date
Spain AEMPS: 50K medicines and their approval status

All exposed as REST endpoints. No auth required for the free tier, just pass your API key. Query any of them from Python, Node, Go, whatever — it's just HTTP.

The limitation you should know about

This works great for structured queries: "Give me all companies matching X in country Y." It doesn't do fuzzy matching on company names — garbage in, garbage out. If you search for "Telefonica" it'll find exact matches or close variants in the registry, but if you search for "tele fonica" with a space, it'll miss them. You need to clean your input.

Also, BORME updates daily but with a lag — if a company filed something this morning, it might not show for 24 hours. SIRENE can be slower. Know your latency tolerance before you build something that expects real-time data.

Next steps

If you're doing KYC, compliance, or just need to verify a European company without a subscription service, grab a key and give it a try. Happy to answer questions about the data sources or the setup in the comments.

Happy to answer questions about the data sources or the setup.

Test pub

AgoraIntelligence — Tue, 21 Jul 2026 09:23:16 +0000

test body

Draft test 2

AgoraIntelligence — Tue, 21 Jul 2026 09:22:58 +0000

test body

I built MCP servers so Claude can query official EU company registries directly

AgoraIntelligence — Sun, 12 Jul 2026 11:45:17 +0000

I was doing compliance work for a client — verifying that a list of Spanish suppliers were actually active companies with no recent insolvencies. The standard approach is to go to BORME (Spain's official business registry), search each company manually, and copy the relevant fields into a spreadsheet. For 40 companies that's an afternoon.

It occurred to me that Claude could do most of this if it had access to the actual registry data. So I built an MCP server for it.

The BORME API returns real-time data — company status, directors, capital, corporate acts history. Once it's connected via MCP, you can just ask: "Check these 40 company names against the Spanish registry and flag any that are dissolved or in insolvency proceedings." Claude handles the lookup and summarization.

I ended up building 7 servers total:

Spain BORME (2.8M companies, updated daily from the official BOE feed)
France SIRENE (25M companies via api.gouv.fr)
UK Companies House (official CH API)
Spain BDNS (500K+ government grants and subsidies)
Spain AEMPS (pharmaceutical registry — useful for verifying authorized medicines)
LATAM (Brazil CNPJ lookups, tax ID validation for MX/AR/PE)
SEC EDGAR (US public company filings)

All of them use the official government APIs directly, so the data is as fresh as the source. No intermediary databases that might be weeks behind.

They're live on Smithery under the fzth-ia-it namespace if you want to try them. Free tier covers most use cases — higher volume plans available if you're running it in production.

A few things I learned building these:

Government APIs are surprisingly inconsistent. The French SIRENE API is excellent — well-documented, reliable, good rate limits. BORME required more work to parse because the official format is designed for lawyers, not developers. Companies House is solid but goes down for maintenance on Tuesday mornings UK time.

The MCP transport layer (Streamable HTTP) was simpler to implement than I expected. The main complexity was handling pagination and rate limits gracefully so Claude doesn't get stuck waiting on slow responses.

Happy to answer questions about any of the specific data sources or the MCP implementation.