Skip to main content

​
Human Node

The Human node pauses your workflow and waits for a real person to make a decision. It’s like putting a speed bump in your automation that says “A human needs to check this before we continue.”

​
When to Use

  • Approvals - Get sign-off before sending something important
  • Reviewing AI work - Have someone verify that AI-generated content looks good
  • Making decisions - Let a person decide what to do next
  • Quality checks - Make sure important outputs are correct
  • Compliance - When rules require a human to be involved

​
Example: Content Approval

Review AI-generated content before publishing:
1

Generate content

Use an LLM node to create a blog post or social media content.
2

Request approval

Add a Human node:
  • Prompt: “Please review this content before publishing. Check for accuracy, tone, and brand alignment.”
  • Context:
{
  "content": "{{llm_1.response}}",
  "topic": "{{webhook_1.body.topic}}",
  "targetAudience": "{{webhook_1.body.audience}}"
}
3

Handle the decision

  • Approved → External API (publish to CMS)
  • Rejected → LLM (revise based on feedback) → Human (re-review)

​
Example: High-Value Order Approval

Require manual approval for large orders: 
├── Webhook (new order)
├── Condition (order.total > 10000)
│   ├── Met:
│   │   └── Human (approve high-value order)
│   │       ├── Approved: External API (process order)
│   │       └── Rejected: External API (email customer about review)
│   └── Unmet:
│       └── External API (auto-process order)
Configuration: 
{
  "prompt": "High-value order requires approval",
  "context": {
    "customer": "{{webhook_1.body.customer}}",
    "items": "{{webhook_1.body.items}}",
    "total": "{{webhook_1.body.total}}",
    "riskScore": "{{llm_1.response.riskScore}}"
  },
  "assignee": "[email protected]"
}

​
Example: Sensitive Action Confirmation

Require approval before destructive operations: 
├── Webhook (delete request)
├── Human (confirm deletion)
│   ├── Approved:
│   │   ├── HTTP Request (delete resource)
│   │   └── External API (log deletion)
│   └── Rejected:
│       └── External API (notify requestor of rejection)

​
What the Reviewer Sees

When your workflow pauses at a Human node, the person you assigned gets:
  1. A notification - An email or Slack message with a link
  2. A review page - Shows your prompt and all the context you provided
  3. Approve and Reject buttons - The main decision
  4. A comment box - They can add notes explaining their choice
Your workflow stays paused until someone responds.

​
What If No One Responds?

If no one answers within the timeout period, you can set up what happens next: 
├── Human (wait 24 hours)
│   ├── Approved: Continue the normal flow
│   ├── Rejected: Handle the rejection
│   └── [If no response]:
│       └── Send alert to manager
You can configure what happens when time runs out.

​
Escalation Patterns

​
Reminder then Escalate

{
  "timeout": 86400000,
  "reminderInterval": 14400000,
  "escalationEmail": "[email protected]"
}
Sends reminders every 4 hours, escalates after 24 hours.

​
Multiple Approvers

For workflows requiring multiple approvals: 
├── Human (technical review)
│   └── Approved:
│       └── Human (legal review)
│           └── Approved:
│               └── Human (executive sign-off)
│                   └── Approved: Proceed

​
Rejection Handling

Don’t just end on rejection - handle it gracefully: 
├── Human (approve marketing email)
│   ├── Approved: Send email
│   └── Rejected:
│       ├── Condition (has feedback?)
│       │   ├── Met: LLM (revise with feedback) → Human (re-review)
│       │   └── Unmet: External API (notify marketing team)

​
Using Reviewer Feedback

Access the reviewer’s comment for follow-up: 
├── Human (review content)
│   └── Rejected:
│       └── LLM (revise based on: "{{human_1.comment}}")
│           └── Human (re-review revised content)

​
Tips

Make prompts specific: “Approve sending this email to 5000 customers?” is better than “Approve?”
Include all relevant context in the approval request. The reviewer shouldn’t need to look up additional information.
Set reasonable timeouts. 24 hours works for most approvals, but time-sensitive workflows might need shorter timeouts with escalation.
The workflow pauses completely at Human nodes. Don’t use them for operations that need to happen quickly or frequently.

​
Human vs. Human Communicator

FeatureHuman NodeHuman Communicator
PurposeSingle approval/decisionMulti-turn conversation
InteractionApprove/Reject buttonsFree-form messages
ComplexitySimpleComplex
Use case”Should we proceed?""Tell me more about X”
Use Human for simple yes/no decisions. Use Ask a Person for back-and-forth conversations.

​
Settings

​
name
string
default:"Human"
What to call this node (shown on the canvas).
​
key
string
default:"human_1"
A short code to reference this node’s result.
​
assignee
string
Who should make this decision:
  • Type someone’s email address
  • Type their Slack username
  • Leave empty if anyone on your team can approve
​
prompt
string
required
What to tell the reviewer. Explain what they’re looking at and what decision they need to make.
​
context
object
Show them the relevant information they need to make their decision.
​
timeout
number
default:"86400000"
How long to wait for a response. Default is 24 hours (in milliseconds: 86400000).
​
reminderInterval
number
Send reminder notifications if they haven’t responded (in milliseconds).
​
notificationChannel
string
default:"email"
How to notify them: email, slack, or both.

​
Outputs

The Human node has two outputs:
​
approved
handle
Green (Approved) - Goes here when they approve.
​
rejected
handle
Red (Rejected) - Goes here when they reject.
​
decision
string
What they decided: approved or rejected.
​
comment
string
Any notes they added with their decision.
​
decidedBy
string
Who made the decision.
​
decidedAt
string
When they made the decision.
​
responseTime
number
How long it took them to respond (in milliseconds).

Condition

Route based on approval decision.

Ask a Person

For multi-turn human conversations.