Ready-to-use integrations & nodes

Run the workflow manually by clicking Run in the editor.

Fires automatically when ANOTHER workflow in the tenant fails — the entry point for enterprise error-handling workflows (a supercharged n8n Error Trigger). Two binding levels: per-workflow via the watched workflow settings, or tenant-wide catch-all. The payload carries the failed run details for alerting, retry or escalation.

Run the workflow on a schedule (cron). Use the visual builder: pick the frequency, tweak hour/minute, and see the human-readable preview of the generated cron expression.

Trigger the workflow when an HTTP request reaches the webhook URL. The URL is generated automatically and shown in the "Webhook URL" panel below once the node is selected. Supports multiple auth methods, CORS, raw body and custom paths. To return a custom response (HTML, JSON, redirect, binary file, etc.) add a "Webhook: Respond" node at the end of the workflow.

Trigger the workflow when a customer messages your WhatsApp Business number (official Meta Cloud API). One run per incoming message with a fully normalized payload: E.164 sender, profile name, message type (text, interactive button/list reply, image, document, audio, video, sticker, location, reaction), text or caption, media references for Graph API download, and reply context. Fail-closed security on both protocol flows: the GET verification handshake echoes hub.challenge only when the verify token matches (timing-safe), and every POST event is accepted only with a valid X-Hub-Signature-256 HMAC signature. Automatic per-message-id dedup (Meta re-delivers unacknowledged events). Pair with the WhatsApp send node for a full conversational bot: replies fall inside the 24-hour customer-service window, so free-form text needs no pre-approved template.

Trigger the workflow when someone messages your Telegram bot (official Bot API). One run per update with a fully normalized payload: chatId and userId, username and name, text or caption, media file_id references (photo at max resolution, document, voice, video, sticker), location, reply context, and inline-button clicks (callback_query) extracted as interactive {id, title}. Create the bot in 2 minutes with @BotFather — no business verification, no cost, no pre-approved templates: the fastest channel for a conversational bot or a live demo. Fail-closed security: every POST is accepted only when the X-Telegram-Bot-Api-Secret-Token header matches your configured secret (timing-safe). Automatic per-update_id dedup. Pair with the Telegram send node for a full bot: reply to the received chatId.

Run the workflow in real time whenever a message arrives on a WebSocket connection. Unlike the Webhook trigger (an HTTP endpoint that waits for calls), this node actively CONNECTS to a remote ws:// or wss:// stream and stays listening — ideal for live feeds where data is pushed, not polled.

Run the workflow whenever a message arrives on a RabbitMQ queue. The runtime opens a persistent AMQP 0-9-1 consumer and stays listening — ideal for work-queue architectures where a producer drops jobs (orders, emails to send, processing tasks) and the workflow processes them one by one. Reliable at-least-once delivery by default: the message is ACKed only after the run starts successfully, otherwise it is requeued (NACK) and redelivered — no work lost on a crash. Prefetch controls backpressure; automatic reconnection with exponential backoff on broker/network failure.

Run the workflow whenever a message arrives on an Apache Kafka topic. The runtime opens a consumer with a consumer group and offset commit: ideal for high-throughput event-driven pipelines where several services publish events to a distributed log. Consumer groups scale consumption horizontally across partitions; at-least-once delivery commits the offset only after the run succeeds, so a failed run re-consumes the message (nothing lost). Supports TLS and SASL (PLAIN / SCRAM-SHA-256/512) for managed clusters (Confluent Cloud, AWS MSK, Aiven, Redpanda) — use {{secrets.X}} to keep credentials out of the node.

Auto-generate a public HTML form. Submissions trigger the workflow.

Watch an IMAP mailbox and trigger ONLY on bounces (Delivery Status Notifications, RFC 3464) — the "undeliverable" notices from MAILER-DAEMON. Regular emails in the same mailbox are ignored; the payload is structured (bounced recipient, reason, original message id) for list-hygiene workflows.

Run the workflow when a file is created/modified/deleted in a watched directory.

Poll an IMAP inbox; trigger on new email matching filters. Select a System Email Account or fill the fields inline.

Run the workflow whenever rows in a FlowForge DB table are inserted, updated, or deleted.

Make an HTTP request to an external API. Supports auth (Basic/Bearer/API Key/Custom), structured body (JSON/Form/Multipart/Raw/Binary), dedicated query parameters, automatic pagination (page/offset/cursor/link-header), retry with backoff, selectable response format (auto/json/text/binary), follow redirects and timeout.

Universal connector: call ANY REST API described by an OpenAPI 3.0 (Swagger) spec. Paste the provider spec (Stripe, Slack, Notion, GitHub, your own ERP…), pick the operation, and one node covers thousands of endpoints — no dedicated node needed per service.

Read a file from the local filesystem within an allowlisted directory.

Write content to a file in an allowlisted directory.

Read an Excel (.xlsx) file and return rows as an array of objects, using the first row as headers. Accepts input from disk (path) or from base64 (e.g. IMAP email attachment).

Generate an Excel (.xlsx) file from an array of objects. Pipe from DB Query / Loop output, or pass an explicit list. Returns base64 (ready for email attachment) or saves to disk.

Extract text from a PDF. First try pdf-parse (free, fast); if the result is low quality (scanned PDF, poor OCR), fall back to Claude Sonnet vision (requires an Anthropic API key in Settings → AI Providers).

Respond to the Webhook trigger HTTP request with a custom body/status/headers. Use it AT THE END of the workflow when the caller is waiting for a response. Modes: JSON, Text, HTML, Redirect, Binary file, 204 No Content, or Custom.

Send an email via SMTP. Compatible with Gmail, SendGrid, Mailgun, Postmark, IONOS, Aruba SMTP. Pick a preconfigured account from Settings → Email Accounts, or fill the SMTP fields below. Supports CC, BCC, reply-to, threading (In-Reply-To), priority, custom headers and inline images (CID).

Compose a string from a template with {{var}} placeholders. Typical: personalized subject/body emails, notification messages, LLM prompts. Substitutions with nested paths ({{customer.address.city}}) and fallback ({{name|default Anonymous}}).

Extract a value or list of values from a JSON object using JSONPath expressions. Standard syntax: $.path.to.field, $.items[0].name, $..price (wildcard), $.items[?(@.qty>0)] (filter).

Format a date as a string in your locale. Input: ISO timestamp ("2026-05-23T..."), Date object, "23/05/2026" string. Output: formatted string + split components (day, month, year, weekday).

Add the "sub-description" (the second line below the article code in the PDF) to each order line ONLY when the code matches a configured rule. Excludes generic notes like "On balance Vs. order". Output: same lines with enriched product_description.

Download a web page and extract ONLY the readable text (strip script, style, nav, footer). Output optimized for LLM prompt or storage. Max 100KB, 10s timeout, SSRF-guarded (blocks localhost/LAN).

Search the web via Brave Search API (preferred, free tier 2k/month — requires env BRAVE_SEARCH_API_KEY) or DuckDuckGo HTML scraping as always-on free fallback. 5min cache per identical query. Output: unified array {title, url, snippet}.

Extract all emails from an HTML web page using 5 parallel strategies: mailto links, Cloudflare anti-spam decoder, HTML entities (@), plain regex, textual obfuscation ([at]/[dot]). Filter noise (noreply, example.com). Output: primary email + full list with confidence score.

Verify email deliverability via DNS MX lookup (RFC 5321 A record fallback included). Detect disposable domains (mailinator, tempmail, etc. — 250+ blacklist). Detect role-based vs person email (info@ vs name.surname@). Output: confidence 0-100. 5min × 5000 domain LRU cache → negligible in batch.

Compute a deterministic 0-100 score (no LLM) to qualify a lead. Pre-set profiles per industry vertical (marine-thrusters default for Arifin/HYSY). Weight positive keywords + penalize off-topic negative keywords (pizzeria, hotel) + bonus for EU tier countries. Same input → ALWAYS same score (audit-friendly, no LLM drift).

Generate 1-2 personalized sentences to inject in cold outreach email. The LLM cites a REAL feature of the shipyard (extracted from their site content) — anti-hallucination check: the evidence_quote MUST be a substring of the content. Multi-language (14 supported). 1h cache per content_hash. Graceful fallback if LLM fails.

Mini crawling agent: start from a homepage URL and NAVIGATE the site (homepage → /contact → /about → /team → /impressum → sitemap.xml → DDG fallback) until it finds a valid business email. Vocabulary in 14 languages (IT/EN/DE/FR/ES/PT/NL/EL + Nordic SE/NO/DK/FI/IS + HR). Respects robots.txt, rate-limit 2 req/s per host, 7-day LRU cache. Zero LLM dependency. Output: primary email + all emails + page where found + paths tried.

Find URLs of REAL companies (not directories or blogs) for B2B cold outreach. Pipeline: LLM query expansion → multi-source search (Exa/Tavily/Brave/DDG) → anti-directory blocklist → HEAD validation → dedup. Output: array of {url, domain, title, boost_factors}. LLM-agnostic: works with Liara, Anthropic, OpenAI, Gemini.

Run a Data Health (Janitor) rule as a workflow step. Works on ANY system database (SQLite/Postgres/MySQL/MSSQL/DuckDB). Single mode to apply a specific rule, loop mode to run all enabled rules.

Enterprise-grade HTTP retrieval for legitimate web scraping (monitoring your own sites, news aggregation, price comparison on your products). Versus the standard HTTP Request: one-click browser-like header presets, auto-derived Referer/Origin, persistent cookie jar and smart retries.

Declarative HTML parser using standard CSS selectors: define a simple "fieldName → CSS selector" mapping and get a structured object out — no imperative code, no cheerio in a Code node.

Extract inline JavaScript variables embedded in <script> blocks of server-rendered HTML WITHOUT executing any JS — the key pattern for reading the structured data that SSR frameworks (Next.js, Nuxt, SvelteKit) and CMSs ship inside the page.

Structured-data extractor with regex FALLBACK CHAINS — robust parsing for HTML/JSON/logs/PDF text that drifts slightly over time (quote style, spacing, attribute order). When the first pattern stops matching, the next ones keep the workflow alive.

Build dynamic URLs from ${var} templates plus query params and conditional flags — the enterprise pattern for assembling final URLs (HLS playlists, API endpoints, signed links) after extracting tokens/ids from HTML pages.

Render a page with headless Chrome for scraping SPAs and JavaScript-heavy sites (React/Vue/Angular). Waits for a selector to appear, then returns the full HTML plus cookies and an optional screenshot. Use it when a plain fetch returns an empty SPA shell.

INTERACTIVE multi-step browser automation on a bring-your-own Playwright endpoint: run a SEQUENCE of steps (click, type, wait, navigate, extract) in the same stateful browser session — for flows that need real interaction, unlike the one-shot render nodes.

Solve Cloudflare/DDoS-Guard JavaScript challenges via a self-hosted FlareSolverr endpoint (bring your own container). Returns the cf_clearance cookie and User-Agent to reuse in subsequent fetches to the protected site.

Pick User-Agent strings from a curated pool organised in 5 semantic categories — for testing your own site under different browser/device contexts, A/B-testing server responses by UA, and monitoring your own bot-detection behaviour.

Inspector/parser for HLS (HTTP Live Streaming) playlists — the Apple adaptive-streaming standard. Reads master and media playlists, listing variants, resolutions, bandwidths, codecs and segments for diagnostics and monitoring of your own streams.

Inspector/parser for MPEG-DASH manifests — the other big adaptive-streaming standard next to HLS. Extracts representations, bitrates, codecs and segment templates for diagnostics of your own DASH streams.

Extract metadata from video files via ffprobe (the ffmpeg companion, the de-facto industry standard). Duration, codecs, resolution, bitrate, streams and container info for any of the 300+ supported formats.

Polling trigger that runs the workflow for every new item detected in an RSS/Atom feed — continuous publisher monitoring. Smart format auto-detect (RSS 2.0 vs Atom 1.0) from the XML root namespace, with per-item dedup so each entry fires exactly once.

Specialised crawler for sitemap.xml (the sitemaps.org standard every serious site exposes): downloads the sitemap, follows sitemap-index nesting, and returns the full URL universe with freshness/priority metadata — the fastest way to enumerate a site.

Headless browser with enterprise anti-detection (Puppeteer-stealth, ~20 countermeasures: webdriver hide, canvas/WebGL fingerprint spoofing, plugin/language consistency). For auditing how your own properties behave behind bot protection.

Distributed spider for massive site indexing: N parallel workers over a shared Redis queue, with professional guardrails — configurable depth limit, bloom-filter dedup, per-host rate limits and robots.txt respect.

Extract structured JSON from a page SCREENSHOT using a vision LLM: resilient to redesigns because it uses no CSS selectors — it "sees" the page like a human and pulls the data you describe in natural language.

Intelligent scraping orchestrator combining fetch + browser + stealth + vision + LLM extraction in ONE node, with an adaptive 4-stage pipeline that escalates only when needed — saving 5-10 manual workflow nodes.

In-process recursive crawler for URL discovery and site mirroring WITHOUT hosting an external service: bounded BFS with dedup, depth limit, hard page cap, worker pool, per-host token-bucket rate limiting and robots.txt caching.

Download an array of binary URLs (images, PDF, video, CSS, JS) in parallel and save them preserving the site path tree. SHA-256 dedup with resume, atomic tmp+rename writes, bounded worker pool — the companion of the Recursive Spider for offline mirrors.

Rewrite an HTML page for offline navigation like wget --mirror: absolute asset URLs (img/css/js/video/iframe, srcset included) become local relative paths based on the asset map produced by Asset Batch Download.

Complete SEO meta parser: title, description, canonical, lang, robots, viewport, full Open Graph and Twitter Card sets, structured JSON-LD (Article/Product/Organization/FAQ/HowTo/Recipe), favicons and heading structure — in one pass.

Full on-page SEO audit with a deterministic 0-100 score and A-F grade: title/description lengths, H1 count and heading hierarchy jumps, canonical, lang, robots directives, image alts, internal/external link counts and more, with actionable findings.

HTTP redirect-chain tracer: follows every hop manually and returns the full chain with status codes, Location headers and latency per hop. Detects circular loops, cross-protocol and cross-domain redirects, and flags chains longer than 3 hops.

Audit every link on an HTML page: classify internal/external/anchor/mailto/tel with canonical-URL dedup, and optionally probe them in parallel to find broken links (4xx/5xx, DNS failures, timeouts) with severity classification.

Keyword-density analyser for text or HTML: extracts clean content (dropping nav/footer/scripts so density reflects the actual copy), Unicode-aware tokenisation, built-in stopword lists (IT/EN/DE/FR/ES) and n-gram frequency output.

Enterprise connector for Odoo Community and Enterprise (v14-18) via native XML-RPC. Five atomic operations cover the full CRUD cycle: search_read with Odoo-style domain filters, create, write, unlink and fields_get for model introspection.

Send WhatsApp Business messages via the official Meta Cloud API (Graph v18+): free-form text inside the 24-hour customer-service window, or pre-approved templates (UTILITY/MARKETING/AUTHENTICATION) any time, with media headers, positional placeholders and quick-reply/url buttons. E.164 validation and Meta rate limits handled with backoff.

Classifier for Italian certified email (PEC) compliant with the AgID standard: inspects the technical MIME envelope headers and routes the workflow to one of 4 branches — ordinary message, acceptance receipt, delivery receipt or error.

Pre-LLM email normaliser: turns a raw email (subject, body, headers, attachments) into a dense, token-efficient payload for a downstream classifier or agent — normalised sender, domain for allowlist matching, cleaned body and attachment digest.

Deterministic sanitiser for email bodies headed to an LLM: strips multilingual quoted replies ("On …, X wrote:"), signatures, legal disclaimers and tracking pixels — noise that inflates tokens without adding meaning.

Confidence router implementing the Human-in-the-Loop pattern: compares a numeric confidence score produced upstream (LLM classifier, vision model) against your threshold and routes to auto-processed vs human-review branches.

Archive PEC (Italian certified email) messages in compliance with the Italian long-term legal preservation rules (DPR 445/2000, DM 17/06/2014, AgID Guidelines): normalised bundle with hashes and metadata ready for conservazione a norma.

Specialised wrapper over the Odoo connector that finds a res.partner with a deterministic multi-field strategy mirroring Italian registry reliability: VAT number first (checksum-validated), then tax code, then exact email, then fuzzy name — with optional create-if-missing.

Create an opportunity in the Odoo CRM pipeline (crm.lead) hiding the XML-RPC many2many "command tuples" complexity: tags, salesperson, team and partner wired correctly in one node.

Schedule a mail.activity in Odoo — the native task-with-deadline mechanism feeding the "My Activities" panel and automatic notifications — attached to any record via the res_model + res_id polymorphic pattern.

Rule-based classifier specialised for Italian accounting firms, with embedded knowledge of the 2025-2026 tax lexicon (F24, electronic invoicing SDI, CU, VAT settlements). Tags email into 9 domain categories with confidence scores for routing.

Extends SMTP send with GDPR-safe behavioural tracking: a per-message 1x1 open pixel served by the tenant (no cookies) and click-tracked link rewriting — feeding open/click analytics back into the workflow.

Batch variant of tracked email sending, designed for volume-controlled commercial outreach that respects provider anti-spam policies: per-recipient leadId tracking, paced dispatch and per-message customisation.

Classifier for B2B cold-outreach replies: buckets incoming responses into the 8 predictable archetypes (interested, not now, unsubscribe, out-of-office, wrong person, objection…) each requiring a different follow-up action.

Polling trigger that starts a run whenever a new record appears in a given Odoo model — replacing the missing native webhooks of Odoo Community. Cursor-based incremental detection keeps every poll cheap and each record fires exactly once.

Execute Python in an isolated Docker sandbox (512MB RAM, 1 CPU core, no privileges, read-only FS) with matplotlib/numpy/pandas/scipy/plotly/pillow/sympy/openpyxl available, plus requests/httpx when network is explicitly allowed. Output: stdout, stderr, exit code and generated files (charts, CSVs).

Execute custom JavaScript in the in-process isolated-vm sandbox (the battle-tested V8 isolation used by Cloudflare Workers): no filesystem, no network, no modules — the escape hatch for any business-logic transformation the specific nodes do not cover.

Execute TypeScript code in the in-process isolated-vm sandbox (the same battle-tested engine as Run JavaScript: V8-level isolation, no filesystem/network/module access, memory cap and wall-clock timeout enforced by the isolate). TypeScript is transpiled with type-stripping only (no runtime type-check → <50ms compile latency even on 50KB scripts), so type annotations, interfaces, type aliases, enums and "as" casts are supported and simply vanish at runtime. Script globals: `input` (previous node JSON output), `vars` (persistent workflow variables), `ctx` (tenantId, runId, nodeId). The value you `return` becomes the node output (must be JSON-serializable). Use case: typed data transformations, typed business logic (tiered commissions, multi-field validation), input reshaping before an API call, proprietary customer algorithms written in TS. For CPU-heavy or scientific work use Run Python; for HTTP calls use HTTP Request.

Dedicated Gmail node via the official Google API (OAuth). Unlike the generic IMAP Email node it uses the tenant Google connection (Settings → Integrations) with automatic, transparent access-token refresh — no re-login on each run. Three operations: send (to/cc/bcc recipients, subject, text and/or HTML body, optional attachments), list (search messages with Gmail query syntax, e.g. "from:[email protected] is:unread newer_than:7d"), get (read one message by id: headers, text + HTML body, attachment list). Credentials live in the tenant encrypted vault, never inside the workflow; all calls go through the runtime anti-SSRF/exfiltration guard. Use case: automatic customer notifications straight from the workflow, sending reports or PDF invoices generated upstream, inbox triage (read unread, classify with an AI node, reply or route), extracting orders from incoming email, scheduled sales follow-ups.

Read-only security-posture auditor for a web domain: a battery of deterministic checks across DNS, TLS certificates, security headers and redirect hygiene per CIS/OWASP best practices, returning a normalised 0-100 score with prioritised findings.

Multimodal video-to-summary pipeline: turns a raw video (upload, public URL, meeting recording) into a structured hierarchical summary — executive TL;DR plus timestamped chapters — combining speech transcription and vision scene analysis.

AI agent specialised in legal compliance of Italian and EU documents: analyses contracts, privacy policies, ToS, DPAs and cookie banners against GDPR, eIDAS and AI Act requirements, returning findings with severity and article references.

Enterprise connector for Google Sheets via the official Sheets API v4 (OAuth2): read ranges, append rows, update cells and clear ranges — the four operations covering the standard spreadsheet automation cycle.

Discord Bot API v2.0 — 37 actions: Messages, Channels, Threads, Reactions, Roles, Members, Bans, Webhooks.

Enterprise connector for Airtable, the low-code database/spreadsheet hybrid: list/create/update/delete records with field mapping and view filters via the official REST API.

Enterprise connector for Trello (Atlassian kanban) via REST API v1: five atomic operations covering cards, lists and comments for visual project automation.

Enterprise connector for Calendly, the leading appointment-booking SaaS: read scheduled events, invitees and event types to feed CRM sync, reminders and no-show follow-ups.

Enterprise connector for Typeform, the conversational-form platform: fetch form definitions and responses to route submissions into CRM, sheets or notification workflows.

Enterprise connector for Shopify via the official Admin REST API: orders, products, customers and inventory operations covering the standard e-commerce automation cycle.

Enterprise connector for Mailchimp email marketing: manage audience members, tags and campaigns via the official API — subscribe/unsubscribe flows, segmentation updates and campaign triggers.

Enterprise connector for Twilio programmable communications via the official REST API: send SMS, send WhatsApp messages and look up message status — the three operations covering the main messaging use cases.

Enterprise connector for SendGrid (Twilio) transactional email via Mail Send API v3: direct sends with to/from/subject/body and template sends with dynamic data.

Enterprise connector for Asana project management via the official REST API: tasks, projects and sections — create, update, complete and comment for cross-functional workflow visibility.

Enterprise connector for Dropbox via API v2: upload, download, list, move and share files — five operations covering the standard cloud file-management cycle.

Enterprise connector for Box.com, the enterprise content-management cloud: file and folder operations with the governance-friendly API used by regulated industries.

Enterprise connector for Google Cloud Storage: upload, download, list and delete objects in GCS buckets — the object-storage primitive for GCP-based pipelines.

AI agent for post-mortem debugging of failed workflow runs: analyses the errored run (step outputs, error stacks, node configs) and produces actionable fix recommendations with confidence scores — cutting mean-time-to-resolution dramatically.

Generate print-ready PDF documents from structured components — title, multi-paragraph sections, optional data table, branded header/footer, logo images — the primitive for every workflow that produces customer-facing paperwork.

Generate an SVG chart (line, bar, pie, area) from a data array — the primitive for any workflow that VISUALIZES numbers: email reports with trends, periodic summaries, historical comparisons. Pure server-side SVG rendering (zero native deps: no canvas/chart.js/sharp) → lightweight, sandbox-safe, and embeddable DIRECTLY in HTML email as a base64 data-URI (a ready-made <img> tag in the imgTag field). Fully configurable from the visual editor with sensible defaults: chart type, data expression, label/value field, title, size, colour palette. Enterprise robustness: empty/non-array data → "No data" placeholder instead of crash; non-numeric/NaN → treated as 0; negative values → zero-baseline scale; every user-supplied text is XSS-escaped (the SVG ends up in an HTML email). Output: { svg, dataUri, imgTag, width, height, pointCount }. Use case: weekly SEO report with a historical error trend vs last week (data from an upstream db_query), monthly sales pie by product category, support-ticket trend bars for management.

CROSS-TENANT collaboration: securely send data to another tenant's FlowForge workspace — the official bridge for two companies to cooperate without sharing databases or credentials (each tenant stays in its own isolated container, GDPR by design). It works as an API contract between workflows: the RECIPIENT tenant exposes a Webhook trigger and hands you the collaboration URL + connection token (the token IS the consent — rotate it and the collaboration stops). The node POSTs the JSON payload with an HMAC-SHA256 signature (x-ff-collab-signature header over "timestamp.body", ±5 min anti-replay) that the recipient verifies by setting authMode "hmac-signature" on its Webhook trigger. Enterprise security: allowed URLs are ONLY FlowForge webhooks (*.app.automazionezeli.com/api/v1/webhooks/…) — this is NOT a generic HTTP node; the signature is computed once and reused across retries, so the recipient never processes the same delivery twice (at-most-once). Reliability: exponential-backoff retries on transient errors only (5xx/network, never 4xx), configurable timeout, Idempotency-Key and correlation-id propagated for recipient-side dedup. Compliance: EVERY delivery is a cross-tenant data transfer recorded in the immutable audit log (hash-chain) with recipient, correlation-id and the payload's sha256 fingerprint — NEVER the content (GDPR data minimization). Output: { delivered, status, response, correlationId, idempotencyKey, attempts, signed, targetHost, durationMs }. Use case: a supplier notifies its customer about a shipment; a holding collects daily KPIs from subsidiaries; an accounting firm receives invoices from clients; two partners exchange qualified leads; supply-chain reorders triggered across companies.

Generic LLM node for open-ended text or structured-JSON generation from any prompt with your configured provider (default: self-hosted Liara; Anthropic/OpenAI/Gemini/Mistral/Groq and more via BYOK) — the atomic primitive the specialised agents are built on.

Fetch current conditions and a 7-day forecast for any location worldwide via the public Open-Meteo API (free European service, no API key, commercial use allowed) — temperature, precipitation, wind and weather codes ready for alerts and reports.

RSS/Atom feed reader: downloads a feed URL and returns the parsed items (title, link, date, summary) — the pull-style companion to the RSS trigger for digest and monitoring workflows.

Persistent key-value storage scoped per workflow — the primitive for stateful workflows that must remember data across runs: pagination cursors for incremental syncs, retry counters, "already processed" idempotency flags, KPI baselines.

Generate canonical deep-link URLs to the Run History view of the FlowForge editor — ready to embed in notifications and reports so a click lands directly on the filtered run list of the right workflow.

GitHub REST + GraphQL v2.0 — 58 actions: Issues, Pull Requests full lifecycle, Reviews, Files, Repos, Branches, Releases, Workflows, Search, GraphQL escape-hatch.

Enterprise connector for HubSpot CRM via API v3: seven atomic operations across contacts, deals and companies covering the standard funnel — lead capture, deal stage updates, association and search.

Notion API v2.0 — 32 actions: Pages, Databases, Blocks helpers, Search, Users, Comments, auto-paginate, duplicate_page.

Enterprise connector for Salesforce via the official REST API: run SOQL queries plus CRUD on any sObject — six operations covering the full enterprise CRM cycle.

Slack Web API v2.0 — 57 actions across Messages, Conversations, Files, Reactions, Users, Reminders, Search, DND, UserGroups. Auth via Bot User OAuth token (xoxb-...).

Telegram Bot API v2.0 — 75 actions: Messages, Media, Polls, Forum Topics, Bot Identity, Payments, Webhooks, plus FlowForge-exclusive batch & retry helpers.

Linear GraphQL v2.0 — 28 actions: Issues, Projects, Cycles, Teams, Labels, Comments, Users, Attachments, GraphQL escape-hatch.

Canonical Slack connector via the official chat.postMessage Web API: post to any authorised channel with full support for blocks, threads and mentions.

Canonical Telegram connector via the official Bot API (sendMessage + sendPhoto): send text or photos to any chat the bot can reach, with parse modes and notification controls. Pair with the Telegram In trigger for a full bot.

Canonical Linear connector via the official GraphQL API (issueCreate): open issues with team, priority, labels and description — the primitive for engineering-workflow automation.

Run the "true" branch if the condition is true, otherwise "false". Use the visual builder (multi-rule with AND/OR and per-type operators) or a free JavaScript expression (back-compat).

Route the workflow to one of many branches based on the value of an expression. Supports a fallback branch when no case matches.

Iterate a collection through the "body" branch. Choose serial / batched / bulk / queued / aggregated strategy per workload size.

Combine the outputs of N parallel upstream nodes into 1 single output. 4 strategies + concat-arrays option for multi-search patterns.

Pause workflow execution for a configurable duration.

Invoke another workflow as a step. Pass the current step output as input.

Convert input data between formats: JSON, CSV, plain text. XML and YAML coming (v2).

Pause workflow execution. Resume via timer OR external webhook callback.

Reshape input JSON using a JSONata expression.

Call a paginated REST API and aggregate all pages into a single array.

Group an array by a field. Output: { groups: { [value]: [item...] }, count: N }.

Reduce an array to a single value: sum / count / average / min / max / concatenation. Optional group-by for per-group reduction.

Remove duplicates from an array. With the optional field: items with the same field value only the first one is kept.

Group items in fixed time windows (e.g. every hour, every day). Useful for time-series analytics.

Cryptographic Swiss-army knife built solely on node:crypto (zero external dependencies): hash, HMAC, encrypt/decrypt, random bytes and base64 — five dropdown operations for data integrity, authentication and encoding.

Unique-identifier generator with five formats — UUID v4, UUID v7 (time-sortable), NanoID, ULID and short codes — because using the right ID type avoids subtle bugs and slow database indexes.

Complete JSON Web Token node — sign, verify and decode — built on node:crypto HMAC (HS256/384/512) with CONSTANT-TIME signature verification and automatic exp checking. Zero external dependencies.

Bidirectional RFC 4180-compliant CSV node in pure JavaScript: PARSE from CSV text to object arrays (quoted fields, embedded separators and newlines handled correctly) and BUILD back, with delimiter and header controls.

Collection Swiss-army knife: eight array operations in pure JavaScript, all dot-path aware for nested fields — unique, sort, slice, flatten, chunk, shuffle, sample and reverse. Replaces the n8n Item Lists node and most Code-node manipulations.

JSON object manipulator via dot-paths in pure JavaScript — what n8n needs Set/Edit Fields or a Code node for. Eight dropdown operations on nested paths: get, set, delete, merge, pick, omit, stringify and parse.

String Swiss-army knife: nine text operations in pure JavaScript — case transforms, trim, replace, split, extract, pad and slugify — so you stop writing Code nodes for small transformations.

Text templating engine in pure JavaScript for composing dynamic strings — emails, messages, URLs, request bodies — interpolating workflow data with {{ path }} placeholders, dot-path aware for nested fields.

Complete date/time node in pure JavaScript (Date + Intl) with NATIVE timezone and Italian-locale support: now, format, parse, add/subtract and diff — solving automation pain #1: dates without timezone mistakes.

Numeric Swiss-army knife (Math + Intl) with native Italian/European currency and number formatting: round, format, parse, clamp, percentage and more — so invoice totals and prices never come out wrong.

Aggregate statistics over a numeric array (or a numeric field of an object array) in pure JavaScript: count, sum, mean, min, max, MEDIAN and STANDARD DEVIATION in one pass — what n8n needs Code or Summarize for.

Format validator with REAL CHECKSUMS — not naive regexes that accept mathematically invalid values. Seven types with correct logic each: email, URL, IBAN, Italian VAT number, Italian tax code, EAN barcode and phone.

Build, parse and modify URLs and query strings SAFELY on the native URL object — no fragile string concatenation that breaks encoding. Six operations: parse, build, get/set params, join paths and normalise.

Shape an object by setting, renaming and removing MULTIPLE fields in one node — the n8n Set/Edit Fields equivalent, in pure JavaScript with dot-path support for nested fields.

Return the FIRST present value among multiple sources with a final default — the SQL COALESCE / chained ?? pattern as a foolproof node: list dot-paths in order, get the first non-empty one.

Filter an item array by one or more AND/OR-combined conditions with a visual rule builder and fifteen operators — and TWO outputs (kept and removed) so both groups can be routed without duplicating logic.

Extract structured data from an HTML page/fragment in pure JavaScript — the n8n HTML Extract without a cheerio Code node. Six modes including clean text (scripts/styles stripped, line breaks preserved), links, images, tables and meta.

Convert Markdown to SAFE HTML in pure JavaScript — ideal for turning AI-node output (usually Markdown) into email-ready HTML. Every text node is XSS-escaped before formatting is applied.

Compare two values and detect EXACTLY what changed: deep object diff returning added/removed/modified fields (with from/to values), or line-based text diff — without writing recursive Code-node logic.

Generate realistic test data with an ITALIAN dataset (plausible names, cities, companies): define a schema of field→type pairs and get N rows — develop and test workflows without production data.

Turn your workflow into a real REST API with a STRUCTURED, consistent response envelope: placed after a Webhook trigger (respond-node mode), it builds the status/body/headers of the HTTP reply in standard REST shape.

Pause the workflow until an external signal arrives (POST /signals/:name). Survives restarts — pause can last weeks. Perfect for approvals & long-running flows.

Query rows from a FlowForge-managed database with filters, sort, limit.

Insert a row into a table. Pass row data via config or pipe from previous step.

ATOMICALLY insert a header (e.g. order) + N child rows (e.g. order_lines), all in a single transaction. If inserting the lines fails, the header is rolled back too — no phantom orders in DB. Typical for: orders+order_lines, invoices+invoice_lines, deliveries+delivery_items.

Update rows in a table matching a where clause.

Delete rows matching a where clause. Destructive — confirmation required.

Run the workflow whenever a row is inserted/updated/deleted in a table.

Run a custom SELECT (with JOIN, GROUP BY, CTE) and return rows. Read-only — use db_insert/db_update for mutations.

Read from an EXTERNAL Postgres through a secure SSH tunnel (DBeaver-style). READ-ONLY (SELECT/EXPLAIN only), mandatory host-key pinning against MITM, SSRF and DNS-rebinding guards, credentials from the per-tenant vault.

Semantic retrieval over the TENANT vector knowledge base: embeds the query (OpenAI/Voyage/Ollama, BYOK) and runs cosine KNN on the selected vector DB, returning the top-k most similar chunks as grounding context for an agent/LLM node. Strict tenant isolation.

Index content into the TENANT vector knowledge base: embeds the text (BYOK provider) and upserts into the vector DB, creating the collection on first use. Idempotent — without an explicit id a deterministic one is derived from content, so re-runs never duplicate.

Send a PEC message via an Aruba account. Default: standard SMTP (smtps.pec.aruba.it:465) with attachment support. Legacy SOAP mode available for existing workflows.

Trigger the workflow when a new PEC arrives on an Aruba account (IMAP polling imaps.pec.aruba.it).

Create a new invoice on Fatture in Cloud.

Look up a client by VAT or tax code; create it if it doesn’t exist.

Transmit an electronic invoice to the Italian Exchange System (SDI) of the Revenue Agency.

Retrieve the status of an invoice sent to SDI (RC = recipient receipt, NS = rejection notice, MC = delivery failure, NE = outcome notice, DT = expired terms).

Extract the payload from a CAdES `.p7m` signed envelope (PKCS#7/CMS SignedData) — the format signed electronic invoices travel in to and from the Italian SdI and arrive via PEC. Minimal, defensive ASN.1 DER parser with zero external dependencies. Accepts base64 (as produced by PEC/IMAP attachment nodes), recognises re-encoded envelopes, and passes plain XML through with wasSigned:false. It does NOT verify the signature (legal verification belongs to the preservation system): it makes the content READABLE so parsers, databases and AI nodes downstream can automate it.

Deterministic parser for Italian electronic invoices (FatturaPA FPR12/FPA12) from XML to typed JSON: supplier and customer (name, VAT, tax code), document type, number, date, total, ALL line items with prices and VAT rates, per-rate VAT summaries and payment due dates. Namespace-agnostic XPath on the libxml2 engine, optional validation against the official v1.2.2 schema (offline). Unlike an LLM re-reading the XML, extracted amounts are EXACT and repeatable — feed the clean JSON to AI, databases or your ERP.

Start a payroll processing job on Zucchetti HR Go.

Update DNS records on a Register.it domain.

Universal CRUD on any Odoo model (res.partner, sale.order, account.move, ...) + custom module method invocation. JSON-RPC on /jsonrpc (Odoo 12+). Polish-notation domain syntax. Authenticate cached 30min per connection. UI with progressive disclosure: see only the fields needed for the chosen action.

Universal CRUD on WordPress REST API v2. Posts, pages, media, users, categories, tags, comments. Auth via Application Password (Users → Profile → Application Passwords, WordPress 5.6+). 43% of the web runs WP — ideal for customers with a brochure site, blog, magazine, landing pages.

Universal CRUD on WooCommerce REST API v3. Products, orders, customers, coupons, refunds, taxes, shipping zones, batch endpoint (100 ops/req). 30% e-commerce market share — most customers with an online shop have one. Auth: consumer_key + consumer_secret from WooCommerce → Settings → Advanced → REST API.

Call AI: Anthropic Claude with your API key. Opus = maximum power (expensive). Sonnet = balanced (default). Haiku = cheap, fast.

Call AI: OpenAI GPT with your API key. gpt-4o = top quality. gpt-4o-mini = fast/cheap (default). gpt-3.5-turbo = legacy.

Call AI: Google Gemini with your API key. gemini-2.0-flash = new, fast (default). 1.5-pro = higher quality.

Call AI: OpenRouter (100+ models) with your API key. OpenRouter gives access to 100+ models with a single key. Format: vendor/model.

Call AI: Ollama (local) with your API key. Models must be pulled locally with `ollama pull <name>` first.

OWASP-grade security audit of code or config. Returns vulnerabilities + remediation.

Senior code review: bugs, smells, perf, idiomatic style. JSON output with file:line refs.

Analyze tabular data (JSON/CSV) and extract patterns, anomalies, summary stats.

Produce a faithful, structured summary preserving named entities.

Faithful translation between languages, preserving formatting + entities.

Classify input text into user-defined labels with confidence scores.

Extract structured entities from unstructured text. Output JSON object schema-driven.

Classify user intent and route to a downstream branch. Outputs branch name.

Extract structured data from HTML by describing what you want in natural language — no CSS selectors. The AI reads the DOM plus your instruction and returns schema-conformant JSON that survives site redesigns.

Generate robust CSS/XPath selectors automatically from 1-2 label-value examples: provide HTML plus {"price": "€42.50"} and get selectors ready for HTML Select — self-healing scraping that regenerates when the site changes.

Validate structured input against a JSON Schema plus business rules: returns valid/errors/normalized with error paths, strict mode and normalise-on-fix.

Agent with native Anthropic Claude tool-calling. Loops until the model responds without requesting more tools. Available tools: http_request, flowforge_invoke, get_time, rag_search.

Leggi e invia email via Gmail con OAuth 2.0. Filtra per query Gmail (label, sender, unread), supporta allegati fino a 25MB, MIME parsing automatico, auto-refresh dei token entro 5 minuti dalla scadenza.

Invia messaggi via WhatsApp Business Cloud API (Meta Graph v19+). Template approvati per outbound, free-form solo entro la finestra 24h dalla risposta utente. Media supportati (image, document, audio, video).

Crea checkout sessions, fatture, retrieve payment intent, lista subscriptions via Stripe API. Idempotency keys derivate da runId:nodeId:action per safe retry. Listener webhook eventi separato (in arrivo).

Upload, download, list file con OAuth Google. Scope drive.file (solo file creati dall'app — privacy-friendly). Crea cartelle, condividi file, multipart upload fino a 5MB. Resumable upload per file più grandi in arrivo.

Estrae testo da immagini e PDF scansionati usando Tesseract.js (pure JS, no native binary, no API key). Lingue: italiano + inglese di default, configurabile. Output con bounding boxes, confidence score per blocco, threshold filter.