# Apps
Source: https://docs.impresivai.com/built-in-nodes/apps
Send and receive data with external app integrations
# App Action Nodes
App Action nodes connect your workflows to external services.
## Messaging apps
Send messages to users across multiple platforms.
* **WhatsApp**\
Send text, images, and buttons
* **Telegram**\
Send messages to channels, groups, or users
* **Instagram DM (Business)**\
Send replies to conversations
Use cases:
* Auto-reply bots
* AI chat assistants
* Customer service automation
## Data and forms
Update records, spreadsheets, and internal systems.
* **Google Sheets**\
Add rows and update cells
* **Airtable / Notion**\
Create and update records
* **Web form APIs**\
Send collected form data
Use cases:
* Lead logging
* Saving AI output
* Report generation
## Notifications
Notify users and teams through communication tools.
* **Email (SMTP, Mailgun, Sendinblue)**
* **Slack / Discord**
* **Push notifications (OneSignal, etc.)**
Use cases:
* Alert on key conditions
* Notify reviewers
* Escalate failed flows
## Custom API actions
If an app is not available yet, use:
* **HTTP Request** node
* Custom headers, payloads, and auth
* API key or bearer token authentication
## How to use
1. Add an **App Action** node
2. Select an app and action
3. Connect your account
4. Map fields with dynamic variables (`{{ }}`)
5. Save and run to test
## Manage connections
* Open **Dashboard > Connected Apps**
* Reconnect or remove integrations anytime
* Credentials are encrypted by default
# Core
Source: https://docs.impresivai.com/built-in-nodes/core
Core nodes for requests, code, timing, and flow control
# Core Function Nodes
Core nodes give you direct control over execution, logic, and external communication.
***
## HTTP Request
Send requests to external APIs.
* Supports: `GET`, `POST`, `PUT`, `DELETE`, `PATCH`
* Add headers, query params, body (JSON/form/raw)
* Handle auth with bearer tokens, API keys, or custom headers
* Returns full response: status, headers, body
Use it to connect with services that don’t have a built-in node yet.
***
## Code (Script)
Write custom JavaScript for advanced logic.
* Access incoming variables
* Return transformed output
* Use cases: custom calculations and payload shaping
Good for edge cases, inline logic, or mini utilities.
***
## Wait
Pause workflow execution before continuing.
* Set duration in seconds, minutes, hours
* Use for delays, throttling, or time-based logic
* Can be used between nodes or before actions
***
## Respond
Return a custom response to the trigger source.
* Use with Webhook or Execute Node
* Define status code, headers, body
* End the flow early if needed
Example: return `{ "status": "ok" }` after a webhook is received and processed.
***
## Execute Node
Run another workflow like a reusable function.
* Pass input variables into the target workflow
* Wait for completion and receive its output
* Use for reusable workflow modules
***
## Extract Page from HTML
Extract structured content from HTML.
* Input: raw HTML or URL
* Output: text, tables, metadata, or selector-based fields
* Use cases: scraping, summarization, and data extraction
***
# Data Flow
Source: https://docs.impresivai.com/built-in-nodes/data-flow
Control branching, routing, and iteration
# Data Flow Nodes
Data flow nodes control branching, routing, filtering, and iteration.
***
## If
Route execution by a boolean condition.
* Input: expression (e.g. `{{user.age}} > 18`)
* Output: `true` or `false` branch
* Supports numbers, strings, booleans, and nested variables
***
## Switch
Route execution based on a value.
* Input: expression or variable (e.g. `{{user.type}}`)
* Add multiple cases (e.g. `"admin"`, `"guest"`, `"member"`)
* Includes default fallback if no case matches
***
## Loops
Repeat steps for each item in a list.
* Input: array (e.g. `{{items}}`)
* Executes child nodes once per item
* Built-in variable: `{{loop.item}}`
* Optional fixed-count loops supported
Use this to send multiple messages, make batched API calls, or process each entry individually.
***
## Filter
Continue only when a condition matches.
* Input: condition (e.g. `{{email}} contains "gmail.com"`)
* Output: continues if true, skips if false
* Often used right after a trigger to clean data before logic
***
# Data Transformation
Source: https://docs.impresivai.com/built-in-nodes/data-transformation
Transform and format data between workflow steps
# Data Transformation Nodes
Use transformation nodes to clean, format, and compute values between steps.
***
## Math
Perform numeric calculations.
* Supported: `+`, `-`, `*`, `/`, `%`, `^`, rounding, min/max
* Example: `{{price}} * 1.1`, `Math.round({{value}})`
***
## String
Modify and extract text.
* Operations: `split`, `join`, `replace`, `substring`, `toLowerCase`, `trim`
* Example: `{{text}}.toLowerCase().trim()`
***
## Array
Operate on arrays and lists.
* Operations: `map`, `filter`, `reduce`, `length`, `includes`, `indexOf`
* Example: `{{items.length}}`, `{{items.map(x => x.name)}}`
***
## Object
Read and reshape object data.
* Access nested fields: `{{user.profile.name}}`
* Restructure or flatten keys
* Merge objects or remove null/undefined fields
***
## Date
Parse, format, and compare dates.
* Format: `YYYY-MM-DD`, `HH:mm:ss`, ISO strings
* Functions: `now`, `add`, `subtract`, `diff`, `format`
* Example: `{{date}}.add(2, 'days')`, `now().format("YYYY-MM-DD")`
***
## Crypto
Apply basic cryptographic utilities.
* Hashing: `SHA256`, `MD5`, `bcrypt`
* Encoding: `base64`, `hex`
* Useful for signatures, password handling, and IDs
***
# Impresiv AI
Source: https://docs.impresivai.com/built-in-nodes/impresiv-ai
AI nodes for generation, analysis, and agent workflows
# Impresiv AI Nodes
Use AI nodes to generate content, analyze text, and automate decisions.
***
## AI Agent
Run multi-step agents that reason over context and take actions.
* Configure instructions, tools, and memory
* Ideal for assistants and multi-step workflows
* Connect agent tools such as API calls and function nodes
***
## Generate Image
Create images from text prompts.
* Input: prompt (plus optional style settings)
* Output: image URL or base64
* Common use cases: marketing assets and visual drafts
***
## Generate Video
Generate short videos from text prompts.
* Input: prompt or script
* Output: video URL
* Use cases: social clips and product explainers
***
## Transcribe Audio
Convert audio speech to text.
* Input: audio file upload or URL
* Output: transcription text
* Supports formats like MP3, WAV, M4A
***
## Content Moderation
Flag unsafe or policy-sensitive content.
* Categories include abuse, violence, sexual content, and self-harm
* Output includes a flag and category details
* Useful for moderation and guardrails
***
## Text Classifier
Classify text into predefined labels.
* Input: text
* Output: predicted label
* Use cases: routing, intent detection, auto-tagging
***
## Sentiment Analysis
Analyze the tone of incoming text.
* Output: sentiment label (positive, neutral, negative)
* Also returns confidence score
* Common use cases: customer feedback, response filtering
***
## Agent Tools
Extend AI agents with real-time tools and context:
* Web Search
* API Call
* Function Execution
* Long-Term Memory
Configure tools inside the AI Agent node’s settings.
***
# Trigger
Source: https://docs.impresivai.com/built-in-nodes/trigger
Start workflows from events, schedules, or tests
# Trigger Nodes
Triggers are how a workflow starts. Impresiv supports multiple trigger types depending on your use case.
## Webhook
Start a flow when data is sent to a URL.
* Methods: `GET`, `POST`, `PUT`, `PATCH`, `DELETE`
* Headers and body supported
* URL is auto-generated when you create the node
Use this when integrating with external systems or tools that send data.
## Schedule
Trigger your flow on a recurring basis.
* Interval options: minute, hour, day, week, month
* Good for sync tasks, checks, or timed actions
## App Trigger
Start flows from external apps.
Examples:
* Incoming message from WhatsApp, Telegram, or Instagram
* New row in Google Sheets
* New subscriber in Mailchimp
> Requires app integration to be connected first.
## On Click (test only)
Manual trigger for testing flows inside the builder.
* Doesn’t expose a real endpoint
* Use to test downstream nodes quickly
## Trigger by Node
Call a workflow from inside another workflow.
* Acts like a function call
* Pass data between flows
* Great for modular flow design
## Error Trigger
Start a flow when another one fails.
* Gets error info, execution logs, and flow metadata
* Useful for alerts, fallbacks, or auto-recovery flows
***
# Introduction
Source: https://docs.impresivai.com/introduction
AI Workflow Automation Builder
# Welcome to Impresiv
Impresiv is a visual automation platform for teams that need reliable workflows with AI built in.
With Impresiv, you can:
* Build workflows in a drag-and-drop editor
* Add AI steps for generation, extraction, and classification
* Connect external tools with API and app nodes
* Use conditions, loops, and custom code for advanced logic
## How it works
1. Choose a trigger (webhook, schedule, app event, or manual test)
2. Add nodes to process data and run actions
3. Test, publish, and monitor execution logs
## Why teams use Impresiv
Launch production workflows quickly without writing boilerplate code.
Use modern AI models directly in your workflow steps.
Connect internal systems and third-party APIs in one flow.
Move from simple automations to complex, modular workflow systems.
Build your first workflow in a few minutes.
# Actions
Source: https://docs.impresivai.com/node-builder/actions
Build action parameters and JavaScript execution
# Actions
In step 4, click **Add Action** to define what your node does.
Each action has:
* Enable/disable toggle
* **Parameters** tab
* **Execute (JS)** tab
* **Sample output (json)** tab
## Parameter validation
Validate required fields early and return clear errors.
```js theme={null}
//can only access: parameters, log(), fetch()
if(!parameters.name) throw new Error('Name is required')
if(!parameters.age) throw new Error('Age is required')
if(parameters.age < 18) throw new Error("Too young")
```
## API call example
```js theme={null}
const url = "https://jsonplaceholder.typicode.com/posts"; //Endpoint for testing
const data = {
name: parameters.name,
age: parameters.age,
};
const response = await fetch(url, {
method: "POST",
headers: {
"Content-Type": "application/json"
},
body: JSON.stringify(data)
});
return response;
```
## Return format
The action response is already an object or an array of objects.
Do not parse it again with `response.json()`.
## Debugging
Use the right panel:
* **Outputs** to inspect returned data
* **Errors** to view thrown validation messages
* **Logs** to trace execution
Keep output JSON stable. Downstream workflow mappings rely on this structure.
# Authentication
Source: https://docs.impresivai.com/node-builder/authentication
Configure how users connect accounts to your node
# Authentication
In step 2, click **Add** to create an authentication method.
The modal includes:
* **Label**
* **Description**
* **Type**
Supported types:
* **Credentials form** (API key, bearer token, custom fields)
* **OAuth 2.0**
## Credentials form
Use the form builder to define fields shown to end users.
For each field, set:
* **Name** (key used in scripts)
* **Label** (shown in UI)
* **Type** (for example, string)
* **Required** (on/off)
The preview panel updates live and shows required markers.
## OAuth 2.0
Configure standard OAuth fields:
* Authorization URL
* Scopes
* Additional params
* Code challenge (optional)
* Access token URL
* Refresh token URL
* Redirect URL
You can also enable **Client credentials filled by user** when each workspace must bring its own client ID and secret.
## Testing checklist
1. Confirm redirect URL matches your provider app settings.
2. Connect a test account from the preview panel.
3. Verify token exchange succeeds.
Keep scope lists minimal. Request only permissions required by your trigger and action logic.
# Node Builder Overview
Source: https://docs.impresivai.com/node-builder/introduction
Create reusable custom nodes for your Impresiv workflows
# Node Builder Overview
Node Builder lets you create reusable custom nodes with your own authentication, triggers, and actions.
## Builder flow
The builder is organized into five steps:
1. **Node information**
2. **Authentication**
3. **Triggers**
4. **Actions**
5. **Versions**
At each step, use the right panel to preview behavior, outputs, and logs.
## What you can build
* App connectors with credentials form or OAuth 2.0
* Webhook and polling triggers
* JavaScript actions with validation and API calls
* Versioned node releases for production workflows
Define node identity, naming, and metadata.
Configure credentials form or OAuth 2.0.
Add webhook or polling trigger scripts.
Create action parameters and JS execution logic.
Save frequently while building. Publish only after testing in Preview and Logs.
# Node Information
Source: https://docs.impresivai.com/node-builder/node-information
Set up the base identity of your custom node
# Node Information
Use this step to define the node identity users will see inside the workflow editor.
## Recommended setup
* **Name**: clear product name (for example, "Polymarket")
* **Description**: short purpose statement
* **Icon**: recognizable app icon
* **Category**: group nodes by use case (messaging, data, finance, etc.)
## Naming guidelines
* Keep names short and specific
* Use sentence case for labels
* Avoid internal abbreviations
## Before you continue
Confirm the node name, icon, and description are correct. These are shown in the right-side preview card and in the node picker.
Good naming improves searchability and makes workflows easier to read.
# Triggers
Source: https://docs.impresivai.com/node-builder/triggers
Set up webhook and polling trigger logic
# Triggers
In step 3, click **Add Trigger** and fill:
* **Label**
* **Description**
* **Type**: `Webhook` or `Polling`
## Trigger editors
Depending on trigger type, you will see tabs such as:
* **Parameters**
* **Subscribe (JS)**
* **Unsubscribe (JS)**
* **Handler (JS)**
* **Poller**
* **Sample Outputs (json)**
Use **Sample Outputs (json)** to define the payload shape passed to later steps.
## Webhook trigger pattern
* `Subscribe (JS)`: register remote webhook
* `Unsubscribe (JS)`: clean up registration
* `Handler (JS)`: normalize incoming payload before output
## Polling trigger pattern
Polling should return data only when a new item exists.
```js theme={null}
const category = parameters.category || 'all';
const key = `latestMarketId_${category}`;
// Example: fetch latest items from API
const res = await fetch('https://example.com/markets');
const markets = await res.json();
if (!markets?.length) return false;
const latest = String(markets[0].id);
const previous = await getValue(key);
await setValue(key, latest);
if (latest !== previous && previous) {
return markets[0];
}
return false;
```
## Validate in Preview
* Use **Listen** for webhook testing
* Provide parameter values (for example `category`)
* Check **Outputs** and **Logs** before publishing
# Versions and Publish
Source: https://docs.impresivai.com/node-builder/versions
Test, version, and publish your node safely
# Versions and Publish
After configuring node information, authentication, triggers, and actions:
1. Save changes
2. Run trigger/action tests from Preview
3. Review outputs and logs
4. Click **Publish**
## Recommended release flow
* Keep one draft version while iterating
* Publish only tested changes
* Retest OAuth and polling behavior after updates
## Pre-publish checklist
* Authentication connects successfully
* Required parameters are validated
* Trigger sample output is accurate
* Action output JSON is stable
* Error messages are clear
Small, frequent versions are easier to debug than large one-time releases.
# Quickstart
Source: https://docs.impresivai.com/quickstart
Build and publish your first workflow in minutes
# Quickstart
Use this guide to create and publish your first Impresiv workflow.
## 1. Open the dashboard
Go to [Impresiv Dashboard](https://impresivai.com/dashboard) and sign in.
## 2. Create a workflow
Select **New Flow**, then enter a clear name like **Send AI Summary to Slack**.
## 3. Add a trigger
Each workflow starts with one trigger. Common options:
* **Webhook**: start from an HTTP request
* **Schedule**: run on a fixed interval
* **Form**: run after user input
## 4. Add action nodes
Add the steps your workflow should perform:
* **AI Action** for model-based tasks
* **API Request** for external services
* **If / Else** for branching logic
* **Transform** for formatting and mapping data
* **Respond** to return output
## 5. Pass data between nodes
Map outputs from one node into another node input.
Example: use AI-generated text in a Slack message payload.
![Passing data between nodes]()
## 6. Test the workflow
Click **Run** (or send a test webhook event) and review execution logs step by step.
You can test and edit as many times as needed before publishing.
## 7. Publish
When the flow is ready, click **Publish**.
The workflow is now live and will run whenever the trigger fires.
# Build Workflow
Source: https://docs.impresivai.com/workflows/build-workflow
Create a workflow from trigger to publish
# Building a Workflow
Use the visual builder to connect triggers, logic, AI, and integrations.
## 1. Create a New Workflow
Go to your [Dashboard](https://impresivai.com/dashboard) and click **“New Flow”**.
Give your workflow a clear name and optional description.
## 2. Add a Trigger
A trigger starts the workflow. Common options:
* **Webhook** — responds to external HTTP calls
* **Schedule** — runs on an interval
* **Form Input** — starts from submitted user input
* **Manual** — starts from the builder for testing
Configure trigger settings for your use case.
## 3. Drag in Nodes
Add nodes after the trigger to define workflow behavior.
Common node types:
* **API Request** — call external APIs
* **AI Action** — run AI prompts and model tasks
* **Condition** — branch with if/else logic
* **Transform** — format and reshape data
* **Respond** — return output to a webhook caller
Connect nodes in order to build the full execution path.
## 4. Configure Each Node
Click on a node to configure its:
* **Inputs** — values from trigger or earlier nodes
* **Logic or Prompt** — instructions for AI/script nodes
* **Request Settings** — headers, params, body, and auth for APIs
* **Outputs** — values available to later nodes
Use **dynamic data references** (`{{ }}`) to pull in outputs from earlier steps.
You can preview what data is available by hovering over the connecting lines or using the variable selector in the input fields.
## 5. Test the Workflow
Click **Run** to test end to end.
Review each node output in the execution logs, then iterate.
## 6. Save Progress
Impresiv auto-saves while you build.
To make the workflow live, publish it from the builder.
# Passing Data
Source: https://docs.impresivai.com/workflows/passing-data
Use outputs from one node as inputs to the next
# Passing Data Between Nodes
Each node returns output that you can map into later nodes.
## How data mapping works
* Run or test your workflow to generate sample output
* Select an input field in the next node
* Choose data from previous node outputs
* Save and re-test to confirm the value path
You can map nested fields, arrays, and objects.
## Example
Use text returned from an **AI Action** node in a **Slack message** node.
![Passing data between nodes]()
## Best practices
* Use clear node names so outputs are easy to find
* Validate mappings in test logs before publishing
* Add fallback values for optional fields
# Publishing Workflow
Source: https://docs.impresivai.com/workflows/publish-workflow
Publish workflow changes and make them live
# Publishing a Workflow
Publishing makes your latest workflow version active.
## Why publish
* Activates live triggers (webhook, schedule, app events)
* Applies your latest workflow logic in production
* Keeps a clear current version for your team
## How to publish
1. Click **“Publish”** in the top right
2. Confirm changes
3. Wait for the success state in the builder
Your workflow is now live.
## Update a published workflow
Edit your flow anytime. Just click **“Publish”** again to push changes.
> Impresiv always runs the latest published version.
## Testing after publish
You can continue testing after publishing by using **Run** and test events.