Fire a chain of steps from an incoming webhook or a schedule, wire together 34 node types, and pass data between them with a simple template syntax. No separate runtime to deploy.

Last updated: August 2026 · 12 min read

Quick Answer

A Requex workflow is a chain of nodes that runs when a trigger fires — either an incoming API/webhook request or a schedule. Each node reads the payload, does one thing (filter, transform, call an API, notify, run AI, and more), and passes its result to the next node using {{path}} templates. Build it visually in the Simple (guided) or Graph (canvas) editor — both edit the same workflow.

Simple mode vs. Graph mode

Every workflow has one trigger and any number of downstream nodes — the two modes are just different views onto the same graph, and you can switch between them any time.

Simple (rail)

A vertical, linear list: trigger at the top, one step after another. Best when your workflow doesn't branch — a straight line from event to outcome.

Graph (canvas)

A drag-and-wire node canvas. Needed once you branch, merge parallel paths, loop over an array, or wire an error-handling path.

Starting a workflow

Every workflow starts exactly one way. When you add the first trigger you're asked directly: how should this workflow run?

When something happens (API / Webhook)

You get a unique Invoke URL. Any HTTP request sent to it fires the workflow; the request body, headers, and query string become the starting payload, available anywhere downstream as {{trigger.body}}, {{trigger.headers}}, {{trigger.query}}.

On a schedule

Pick a cron expression. Schedules have a five-minute floor — Requex checks the next ten fire times and rejects anything with a smaller gap, so you can't accidentally set a schedule that fires faster than the platform can run it.

✓ */5 * * * * — every 5 minutes

✓ 0 9 * * * — daily at 09:00

✗ * * * * * — every minute, rejected (below the floor)

Passing data between nodes

Any text field on any node — a URL, a header, a message body — accepts {{path}} placeholders. A placeholder is resolved against the current payload unless you give it a root:

{{body.email}} — a field on the current payload

{{trigger.body.email}} — the original request, even after a node downstream replaced the payload

{{steps[3].amount}} — a field from a specific earlier step, by its stable step number

A few nodes — Transform, HTTP Resilient, jq Transform, CSV parse — replace the payload with their own output rather than passing the original through. Their reference entries below call this out; when you see it, reach the original request again via {{trigger.*}} rather than assuming it still flows through unchanged.

Node reference

Every node type available in the builder, grouped the same way as the “Add node” gallery. Each ⓘ button on a node shows this same text next to a short animation of what it does.

Trigger

API / Webhook & Scheduled

Starts the workflow, from an inbound HTTP request or on a schedule.

Webhook mode: send any request to the Invoke URL. Schedule mode: pick an interval or a cron expression. The trigger payload is available everywhere as {{trigger.body}}, {{trigger.headers}}, {{trigger.query}}.

curl -X POST <invoke-url> -d '{"hello":"world"}' → downstream nodes read {{body.hello}}

Transform & Control

Filter

Stops the run unless the payload matches your conditions.

Each condition compares a payload field (dot path) to a value. Operators: equals, not_equals, contains, not_contains, exists, not_exists, greater_than, less_than.

field: body.type · equals · payment_intent.succeeded, only successful payments continue.

Transform

Reshapes the payload. ⚠ Replaces it, downstream nodes see only the new shape.

Template mode: write JSON with {{path}} placeholders; the rendered result becomes the new payload. Mapping mode: copy fields from → to. Reach the original request later via {{trigger.body.*}}.

{"text":"Order {{body.id}} for {{body.email}}"} → next node reads {{text}}.

Branch

Routes the run down different paths based on condition groups.

Define cases, each with its own conditions. Connect each case handle to a different node. First matching case wins.

Case "big order": body.total greater_than 100 → Slack. Case "normal" → Sheets.

Join

Waits for multiple incoming branches before continuing.

Wire two or more branches into this node; the flow continues once inputs arrive.

Fetch customer + fetch order in parallel branches → join → send one combined email.

Delay

Pauses the run for a fixed duration.

Set duration in seconds or minutes. Useful before follow-ups or to let external systems settle.

Stripe payment fails → wait 60 minutes (card retries settle) → email the customer.

Log

Records the payload in the run history and passes it through unchanged.

Drop it anywhere you want visibility without side effects.

switch default case → log, unmatched events stay auditable but quiet.

Verify Signature

Rejects requests whose HMAC signature does not match your secret.

Pick a preset (Stripe/Shopify/GitHub) or configure header + algorithm manually. Failed verification stops the run.

Preset stripe + your webhook signing secret → forged requests never reach later nodes.

Dedup

Stops the run if the same key was seen within the TTL. Providers deliver at-least-once, duplicates WILL happen.

Build the key from payload fields; identical keys inside the window are dropped. Also works as a change detector: key on a value, and only changes pass.

key {{body.id}} · TTL 1440 min → a Stripe retry of the same event is silently dropped.

Try / Catch

Marks a scope whose failures route to a catch path instead of killing the run.

Wire the normal path and a catch path; failures inside the scope divert to catch with error details.

try: call flaky API → catch: log + notify, workflow keeps going.

Replay

Re-sends a previously captured Requex request to a target URL.

Point it at a stored request (webhook + request ID) and a destination.

Schedule trigger → replay the archived failed request every hour until it succeeds.

Switch

Routes to different branches based on one expression value.

Expression uses {{path}}; each case value gets its own handle to wire. Unmatched goes to the default handle.

expression {{ headers["x-github-event"] }} · cases: push / pull_request / issues.

Merge

Combines payloads from multiple branches into one.

Pick a mode: concat arrays, deep-merge objects, pick specific fields, or zip. Set conflict strategy for overlapping keys.

Customer branch + order branch → deep-merge → one payload with both.

Rate Limit

Caps how many runs pass through per time window.

Set window + max. onLimit "delay" queues the excess; "fail" drops it (wire the error handle for visibility).

50 per 60s, delay mode → a webhook burst becomes a steady stream into Sheets.

Notify

Slack

Posts a message to a Slack channel via an incoming webhook.

Paste a Slack incoming-webhook URL and write the message with {{path}} placeholders.

🔥 New lead: {{body.email}}, budget {{body.budget}}

Discord

Posts a message to a Discord channel via a channel webhook.

Paste the Discord webhook URL (Server Settings → Integrations) and write the message with {{path}}.

🚀 {{body.repository.full_name}} just published {{body.release.name}}

Email

Sends an email through your own SMTP account (single or bulk).

Fill SMTP host/port/user/pass. To, subject, and body all support {{path}}. Bulk mode accepts a list or JSON array of recipients with per-recipient {{recipient.email}} templating.

To: {{trigger.body.email}} · Subject: Thanks {{trigger.body.name}}!

Requex Inbox

Archives the current payload into one of your Requex webhooks.

Pick a target webhook, the payload lands there like a normal request, inspectable and replayable. Great as a dead-letter archive on error paths.

HTTP delivery fails → error path → archive payload to "failed-deliveries" webhook.

Actions

HTTP Action

Sends an HTTP request to any URL (simple, no retries).

Set method, URL, headers, and a body template. Use {{path}} to inject payload values. For retries/backoff use HTTP Resilient instead.

POST https://api.example.com/orders with body {"id":"{{body.id}}","email":"{{body.email}}"}

HTTP Resilient

HTTP request with retries, backoff, and jitter. ⚠ On success the response body replaces the payload.

Configure retries and retryOn (5xx / 4xx / timeout). Wire the "error" handle to an alert path, it fires only after all retries fail. Original request stays at {{trigger.*}}.

POST your API, 3 retries, exponential backoff · error handle → Slack "delivery failed: {{error}}".

Respond to Webhook

Sets the HTTP response returned to whoever called the workflow URL.

Configure status, content type, and a body template. Put it early to ACK fast (Slack: 3s, Shopify: 5s), later nodes keep running after the response is sent.

200 · {"response_type":"in_channel","text":"Got it, {{body.user_name}}"}

Productivity

Google Sheets

Appends or updates rows in a Google Sheet.

Pick a Google account you connected on /connections, then choose the spreadsheet. Row template must render a JSON array, build it with a Transform first, then reference it.

Transform: {"row":["{{body.email}}","{{body.name}}"]} → rowTemplate: {{row}}

E-Commerce

Shopify Products

Fetches products from your Shopify store.

Provide store domain + Admin API token. The product list becomes the payload for downstream nodes.

Schedule trigger → fetch products → filter stock less_than 5 → Slack restock alert.

Shopify Orders

Fetches orders from your Shopify store.

Provide store domain + Admin API token, optionally filter by status. Orders become the payload.

Every hour → fetch open orders → iterator → per-order fulfilment call.

Create Order

Creates an order in Shopify from the current payload.

Map payload fields into the order template with {{path}} placeholders.

Form webhook → create draft order with {"email":"{{body.email}}"}.

AI

AI Agent

Runs an LLM agent that can reason over the payload and decide next steps.

Give it instructions and an API key; it produces a structured decision your downstream nodes act on.

Error webhook → agent decides severity → switch: page on-call vs. just log.

AI Text

Generates text with an LLM and merges it into the payload under your output key.

Pick provider/model, paste an API key, write a prompt with {{path}} placeholders. The rest of the payload passes through unchanged.

Prompt: "Summarize this error in one sentence: {{body}}" · outputKey: summary → Slack posts {{summary}}.

AI Classify

Classifies the payload into one of your categories; result merges in at the output key.

List categories comma-separated, write an input template. Route on the result with a Switch node.

categories: hot,warm,cold · outputKey: score → switch on {{score}}.

AI Extract

Extracts structured fields from messy input using an LLM.

Describe the fields you want; the extracted object merges into the payload at the output key.

Invoice email webhook → extract {vendor, amount, due_date} → append to Sheets.

Data

jq Transform

Extracts a value with a jq-style path expression.

Supports paths (.a.b), array index (.items[0]), and pipes. No object construction or comparisons, use Transform for reshaping. Result lands at the output key (or replaces the payload if empty).

.data.price · outputKey current → downstream reads {{current}}.

CSV

Parses CSV into rows, or emits CSV from data. ⚠ Parse replaces the payload with the rows array.

Parse: point dataPath at the CSV string; header:false keeps rows as arrays (what Sheets wants). Emit: turn an array into a CSV string.

dataPath body.csv → iterator (empty itemsPath) → append each row to Sheets.

State Store

Persists a value across runs, get, set, or increment a counter.

Choose mode + key. The value lands in the payload at the output key. Scope "workflow" isolates per workflow; "user" shares across your workflows.

increment key error-count → outputKey errorCount → filter errorCount equals 10 → alert once, not ten times.

Iterator / Loop

Runs the downstream nodes once per item of an array.

Point itemsPath at the array (empty = the payload itself). Each iteration the item becomes the payload. continueOnError keeps going when one item fails.

itemsPath body.items → each item POSTed individually by the next node.

Observability

Checkpoint

Records a named checkpoint in the run trace for debugging.

Drop between nodes to see exactly what the payload looked like at that point.

After transform → checkpoint "post-transform" → inspect in run history.

Example recipes

Failed payment recovery

Webhook trigger → Verify Signature (Stripe preset) → Filter body.type equals payment_intent.payment_failed → Delay 60 minutes (let card retries settle) → Email the customer.

Low-stock restock alert

Scheduled trigger (hourly) → Shopify Products → Filter stock less_than 5 → Slack message to the ops channel.

Form submissions into a spreadsheet

Webhook trigger → AI Extract (pull structured fields from free text) → Transform (build a row array) → Google Sheets append.

FAQ

Can one workflow have more than one trigger?

No — one trigger per workflow. Need both an incoming webhook and a schedule for the same logic? Build two workflows and have each call the same downstream steps, or use Requex Inbox to fan a scheduled run into the other workflow's webhook.

What happens if a node fails partway through a run?

By default the run stops and the failure is visible in run history. Wrap any node in Try / Catch to route failures to a separate handler instead, or use HTTP Resilient for automatic retries on flaky outbound calls.

Can I test a workflow without waiting for a real webhook?

Yes — use Run Now with a sample payload, or replay a previously captured request with the Replay node once you have real traffic flowing.

Build your first workflow

No signup required to start — connect a trigger and wire up your first node.

Open the workflow builder →

Related Resources

Workflow AutomationOverview, templates, and comparisons with n8n/Zapier.Mock ServerGive a workflow node a stable endpoint to call while testing.Quickstart GuideGet your first webhook URL in 60 seconds.Webhook GlossaryPlain-English definitions for HMAC, idempotency, and more.