# Welcome to Nodes2Cloud (/docs)
## Core Components [#core-components]
Nodes2Cloud is composed of several powerful components that work together to turn your visual graphs into real, deployable code. Select the area you want to explore:
### Visual Editor [#visual-editor]
The intuitive, drag-and-drop web interface where you design your automation workflows. It provides a real-time canvas for connecting triggers, logic gates, and third-party integrations without writing boilerplate.
* **Key Features:** Real-time validation, dynamic node configuration, and secure credential management.
* **Get Started:** Read the [Platform Overview](/docs/getting-started/platform-overview)
### AOT Compiler [#aot-compiler]
The engine that powers Nodes2Cloud. It takes your visual graph and compiles it Ahead-of-Time into highly optimized JavaScript, tailored specifically for Cloudflare Workers.
* **Key Features:** Zero-overhead execution, raw code generation, and Edge-native optimizations.
* **Get Started:** Understand the architecture in the [Platform Overview](/docs/getting-started/platform-overview)
### AI Assistant [#ai-assistant]
Your built-in AI copilot. Instead of dragging and dropping, simply describe the workflow you want in plain English, and the AI will instantly generate the entire node topology and connections for you.
* **Key Features:** Natural language parsing, automatic node selection, and intelligent graph generation.
* **Get Started:** Build your first workflow in 5 minutes with the [Quickstart](/docs/getting-started/quickstart)
# Components (/docs/test)
## Code Block [#code-block]
```js
console.log('Hello World');
```
## Cards [#cards]
# Core Concepts (/docs/getting-started/core-concepts)
# Core Concepts [#core-concepts]
To build workflows effectively in Nodes2Cloud, you need to understand the three fundamental building blocks: **Nodes**, **Edges**, and **Data References**.
## Nodes [#nodes]
A **Node** is a single step in your workflow. Nodes perform specific actions, such as receiving a webhook, sending an email, or transforming data.
There are three main categories of nodes:
1. **Trigger Nodes:** These start the workflow. Every workflow must have exactly one active trigger (e.g., Webhook, Cron).
2. **Action Nodes:** These perform an operation (e.g., Send Slack Message, Query Database).
3. **Control Flow Nodes:** These route the execution path based on logic (e.g., If/Else, Loop).
## Edges [#edges]
An **Edge** is the visual connection between two nodes on the canvas.
* **Execution Flow (Solid Lines):** These determine the order in which nodes execute. When Node A finishes, the engine follows the solid edge to execute Node B.
* **Data Flow (Implicit):** You do not need to wire "data" edges explicitly. In Nodes2Cloud, any node can read the output of any node that executed before it using a Data Reference.
## Data References (Variables) [#data-references-variables]
When a node executes, it produces output data. You can reference this data in subsequent nodes using our expression syntax, denoted by `{{ }}`.
### `$item` [#item]
This is the most common reference. It allows you to access the output of a specific node by its ID.
```javascript
{{ $item("webhook_trigger").body.email }}
```
### `$loop` [#loop]
When you are inside a Loop node, you can access the current item being processed using the `$loop` variable.
```javascript
{{ $loop.currentItem.email }}
```
### `$error` [#error]
Used primarily in error-handling branches. If a node fails, the execution can be routed to an error branch where you can inspect the failure.
```javascript
{{ $error.message }}
```
### Built-in Helpers [#built-in-helpers]
You also have access to standard context helpers:
* `{{ $now }}` - The current timestamp.
* `{{ $env("MY_SECRET") }}` - Access an environment variable securely.
## Executions [#executions]
An **Execution** is a single run of your workflow. When a trigger fires, the Cloudflare Worker wakes up, instantiates a runtime context, and processes the graph node by node. Because it runs on the edge, executions are stateless and highly parallel.
# Platform Overview (/docs/getting-started/platform-overview)
# Platform Overview [#platform-overview]
Nodes2Cloud is a next-generation visual workflow builder. Unlike traditional integration platforms (iPaaS) that charge you per-execution or hold your data hostage, Nodes2Cloud is built on a fundamentally different architecture: **Ahead-of-Time (AOT) Compilation to Cloudflare Workers.**
## Why Nodes2Cloud? [#why-nodes2cloud]
When you build a workflow in Nodes2Cloud, you aren't paying us every time it runs. Because your workflows are compiled into standard JavaScript and deployed directly to your own Cloudflare account, you only pay Cloudflare's incredibly cheap infrastructure costs (which usually fall under their generous free tier).
Traditional platforms store your workflows as proprietary JSON that only their engine can run. Nodes2Cloud compiles your visual graph into raw, readable JavaScript. You can export your workflow at any time, eject from the platform, and run the code yourself.
Your workflows execute on Cloudflare's Edge Network (Workers, D1 Database, KV Storage, and Queues). This means your integrations run globally, with sub-millisecond cold starts and massive scalability.
Don't want to drag and drop? Use the built-in AI Assistant to describe your workflow in plain English. The AI understands the Nodes2Cloud DSL (Domain Specific Language) and will instantly generate the node topology and wire up the connections for you.
## How the Architecture Works [#how-the-architecture-works]
The Nodes2Cloud compiler runs entirely in the background. You never have to see the generated code unless you want to!
When you click "Deploy" on the canvas:
1. The editor sends your visual graph to the compilation engine.
2. The Compiler parses the graph, resolves credentials, and generates a standard Cloudflare Worker script.
3. The script is deployed to Cloudflare via the Cloudflare API.
4. When a trigger occurs (e.g. a webhook fires), Cloudflare spins up the Worker and executes your compiled code instantly.
# Quickstart (/docs/getting-started/quickstart)
# Quickstart [#quickstart]
Welcome to Nodes2Cloud! In this guide, you will build and deploy a simple workflow that triggers via Webhook and sends a response back.
### Create a Workflow [#create-a-workflow]
Head over to your Nodes2Cloud dashboard and click **New Workflow**.
### Add a Trigger [#add-a-trigger]
Drag a **Webhook Trigger** node onto the canvas. This is how we will start our execution. The node will automatically generate a unique URL for you.
### Add an Action [#add-an-action]
Drag an **HTTP Request** node or a **Slack** node onto the canvas.
Connect the Webhook node to the Action node by clicking and dragging from the Webhook's output port (the right side) to the Action's input port (the left side).
### Test the Run [#test-the-run]
Click the **Test Workflow** button in the top right.
Nodes2Cloud will securely execute your graph logic in the cloud and show you exactly what data flowed through each edge!
### Deploy to the Edge [#deploy-to-the-edge]
Once you're happy with your logic, click **Deploy**.
Behind the scenes, Nodes2Cloud will instantly compile your visual graph into an ultra-fast Cloudflare Worker and deploy it directly to the Cloudflare Edge network!
Your Webhook URL is now live and ready to accept real traffic with zero cold-starts!
# Cloudflare Native (/docs/node-catalog/cloudflare-native)
# Cloudflare Native [#cloudflare-native]
Because Nodes2Cloud compiles your visual workflow into a real Cloudflare Worker deployed to your own Cloudflare account, it has **zero-latency, direct binding access** to your other Cloudflare resources.
These nodes do not execute HTTP calls over the public internet. Instead, they use native Cloudflare Worker bindings (like `env.DB` or `env.KV`) resulting in sub-millisecond execution times.
## Databases & Storage [#databases--storage]
| Node | Description |
| ------------------------------ | ------------------------------------------------------------- |
| **Cloudflare D1: Query** | Runs a parameterized SQL query (SELECT) against a D1 database |
| **Cloudflare D1: Execute** | Executes a SQL statement (INSERT/UPDATE/DELETE) against D1 |
| **Cloudflare KV: Set** | Writes a key-value pair to a KV namespace |
| **Cloudflare KV: Get** | Reads a value from a KV namespace |
| **Cloudflare R2: Upload File** | Uploads a FileRef or raw bytes to an R2 storage bucket |
| **Cloudflare R2: Get File** | Retrieves an object from an R2 bucket as a FileRef |
## AI & Machine Learning [#ai--machine-learning]
| Node | Description |
| ------------------- | ------------------------------------------------------------------------- |
| **Workers AI** | Runs an inference model (LLMs, embeddings, etc.) on Cloudflare Workers AI |
| **Vectorize Query** | Finds nearest-neighbour matches in a Cloudflare Vectorize vector database |
# Core Actions & Logic (/docs/node-catalog/core-actions)
# Core Actions & Logic [#core-actions--logic]
These nodes provide the fundamental building blocks for your workflows, allowing you to branch logic, transform data, loop over arrays, and make generic HTTP requests.
## Core I/O [#core-io]
| Node | Description |
| ---------------------- | -------------------------------------------------------------------- |
| **HTTP Request** | Makes a generic HTTP request to any API or URL |
| **Respond to Webhook** | Sends a custom HTTP response back to the caller of a Webhook Trigger |
| **RSS: Read Feed** | Fetches and parses an RSS or Atom feed |
## Logic & Control Flow [#logic--control-flow]
| Node | Description |
| ------------------- | -------------------------------------------------------------------- |
| **If / Else** | Branches the workflow based on a boolean condition |
| **Switch** | Branches the workflow into multiple paths based on a value |
| **Filter Array** | Filters an array of items based on a condition |
| **Merge Branches** | Merges multiple execution branches back into a single flow |
| **Loop (For Each)** | Iterates over an array, executing a sub-graph for each item |
| **Call Workflow** | Calls another compiled Nodes2Cloud workflow and waits for its result |
| **Cross-Run State** | Reads or writes state that persists across executions |
## Data & Transformation [#data--transformation]
| Node | Description |
| --------------------- | ----------------------------------------------------------------- |
| **Set** | Creates or overwrites properties in the payload |
| **Run JavaScript** | Executes custom JavaScript code to transform data |
| **Extract from File** | Extracts text from a FileRef (PDF, CSV, TXT, JSON) |
| **Convert to File** | Converts text, JSON, or CSV data into a FileRef |
| **Aggregate** | Buffers items and flushes them as a batch (e.g. for bulk inserts) |
| **Compression** | Gzip/Gunzip and Brotli compression |
| **Cryptography** | Hash (SHA-256), HMAC, Encrypt, Decrypt, and UUID generation |
## AI Agents [#ai-agents]
| Node | Description |
| ------------------------- | ------------------------------------------------------------------------------ |
| **AI Agent** | An autonomous LLM loop that can think, reason, and use tools to achieve a goal |
| **AI Tool: HTTP Request** | Exposes a generic HTTP Request as a tool for the AI Agent to use |
# Overview (/docs/node-catalog)
# Node Catalog [#node-catalog]
Nodes2Cloud includes over 120 built-in nodes spanning triggers, logic gates, native Cloudflare integrations, and external third-party services.
Our visual nodes are designed to abstract away boilerplate code while giving you the full power of a real JavaScript execution environment.
## Node Anatomy [#node-anatomy]
Every node in the catalog shares a consistent, predictable structure in the visual editor:
* **Manifest**: The node's identity (its name, icon, color, and category).
* **Properties**: The configuration panel where you provide inputs (text fields, code editors, credentials).
* **Inputs & Outputs**: The visual ports on the sides of the node used to wire data into and out of the node.
* **Validator**: Built-in logic that ensures your node is correctly configured (e.g. missing required fields or invalid credentials) before you deploy.
Explore the sidebar to see all available triggers, core logic nodes, native Cloudflare bindings, and third-party integrations.
# Integrations (/docs/node-catalog/integrations)
# Integrations [#integrations]
Nodes2Cloud includes over 70 built-in connectors for popular third-party services. These nodes automatically handle authentication (OAuth2 refresh cycles, API key injection, AWS SigV4 signing, etc.) and payload formatting so you don't have to write boilerplate HTTP requests.
## Messaging & Chat [#messaging--chat]
| Node | Description |
| --------------------------------- | ------------------------------------------------------------------------- |
| **WhatsApp: Send Message** | Send a text message via WhatsApp Business Cloud API |
| **WhatsApp: Send Template** | Send a pre-approved template notification via WhatsApp Business Cloud API |
| **Slack: Post Message** | Posts a message to a Slack channel using a bot token |
| **Telegram: Send Message** | Sends a text message via a Telegram bot |
| **Discord: Send Message** | Sends a message to a Discord channel via a bot token |
| **Twilio: Send SMS** | Sends an SMS via the Twilio API |
| **Microsoft Teams: Post Message** | Posts a message to a Teams channel via Microsoft Graph |
| **Matrix: Send Message** | Sends a text message to a Matrix room |
## Email & Marketing [#email--marketing]
| Node | Description |
| -------------------------------- | ---------------------------------------------------------------------- |
| **Gmail** | Send, reply to, read, and manage messages, drafts, and labels in Gmail |
| **Microsoft Outlook: Send Mail** | Sends an email from the connected Microsoft account via Graph |
| **SendGrid: Send Email** | Sends an email via the SendGrid API |
| **AWS SES: Send Email** | Sends an email via Amazon SES (v2), signed with SigV4 |
| **Send Email (Generic)** | Sends a transactional email via Resend, Mailgun, or Postmark |
| **Mailchimp: Add List Member** | Adds a member to a Mailchimp audience list |
## CRM & Customer Support [#crm--customer-support]
| Node | Description |
| ----------------------------- | -------------------------------------------------- |
| **Salesforce: Create Record** | Creates a record of any sObject type in Salesforce |
| **HubSpot: Create Contact** | Creates a contact via the HubSpot CRM API |
| **Pipedrive: Create Deal** | Creates a deal in Pipedrive |
| **Zendesk: Create Ticket** | Creates a support ticket in Zendesk |
| **Intercom: Create Contact** | Creates (or updates) a contact in Intercom |
| **Freshdesk: Create Ticket** | Creates a support ticket in Freshdesk |
| **ActiveCampaign** | Creates a contact in ActiveCampaign |
## Productivity & Documents [#productivity--documents]
| Node | Description |
| ---------------------------- | ---------------------------------------------------------------------- |
| **Notion: Create Page** | Creates a page in a Notion database |
| **Airtable: Create Record** | Creates a record in an Airtable table |
| **Google Sheets** | Reads, writes, and manages rows/columns of a Google Sheets spreadsheet |
| **Google Docs** | Create, get, and append text to Google Docs documents |
| **Google Drive** | Upload, download, and manage files in Google Drive |
| **Google Calendar** | Create, get, update, delete events, and check free/busy time |
| **Microsoft Excel: Add Row** | Adds a row to an Excel table via Microsoft Graph |
| **Dropbox: Upload File** | Uploads a file (FileRef or text content) to Dropbox |
## Project Management [#project-management]
| Node | Description |
| --------------------------- | ----------------------------------------------- |
| **Jira: Create Issue** | Creates an issue in a Jira project |
| **Trello: Create Card** | Creates a card on a Trello list |
| **Asana: Create Task** | Creates a task in an Asana project |
| **Monday.com: Create Item** | Creates an item on a Monday.com board (GraphQL) |
| **ClickUp: Create Task** | Creates a task in a ClickUp list |
## Artificial Intelligence [#artificial-intelligence]
| Node | Description |
| --------------------------- | -------------------------------------------------- |
| **OpenAI: Chat Completion** | Sends a chat completion request to the OpenAI API |
| **Anthropic: Send Message** | Sends a message to the Anthropic Messages API |
| **OpenAI Model** | An OpenAI chat model for an AI Agent to think with |
## DevOps & Cloud (AWS / GitHub) [#devops--cloud-aws--github]
| Node | Description |
| ------------------------- | --------------------------------------------------------------------- |
| **GitHub: Create Issue** | Creates an issue in a GitHub repository |
| **GitLab: Create Issue** | Creates an issue in a GitLab project |
| **AWS S3: Get Object** | Downloads an object from an S3 bucket, signed with SigV4 |
| **AWS SNS: Publish** | Publishes a message to an SNS topic, signed with SigV4 |
| **AWS SQS: Send Message** | Sends a message to an SQS queue, signed with SigV4 |
| **AWS Lambda: Invoke** | Invokes a Lambda function and returns its response, signed with SigV4 |
## Databases & Data Warehousing [#databases--data-warehousing]
| Node | Description |
| -------------------------- | ------------------------------------------------------------------- |
| **Supabase: Select Rows** | Selects rows from a Supabase table via its PostgREST API |
| **Google BigQuery** | Runs parameterized SQL queries and inserts rows into BigQuery |
| **Google Firestore** | Create, get, update, delete, list, and query documents in Firestore |
| **Snowflake: Query** | Runs a parameterized SQL statement via the Snowflake SQL API |
| **Redis: Set / Get** | Runs a SET or GET against an Upstash Redis REST endpoint |
| **Kafka: Produce Record** | Produces a record to a Kafka topic via the Confluent REST API |
| **AWS DynamoDB: Put Item** | Writes an item to a DynamoDB table, signed with SigV4 |
## E-Commerce, CMS & Forms [#e-commerce-cms--forms]
| Node | Description |
| ---------------------------- | ---------------------------------------------- |
| **Stripe: Create Customer** | Creates a customer via the Stripe API |
| **Shopify: Get Orders** | Lists recent orders from a Shopify store |
| **WooCommerce: Get Orders** | Lists recent orders from a WooCommerce store |
| **WordPress: Create Post** | Creates a post via the WordPress REST API |
| **Typeform: Get Responses** | Fetches responses submitted to a Typeform form |
| **Webflow: Create CMS Item** | Creates an item in a Webflow CMS collection |
## Social Media [#social-media]
| Node | Description |
| --------------------------- | ------------------------------------------------- |
| **LinkedIn: Create Post** | Publishes a post to a LinkedIn member feed |
| **X (Twitter): Post Tweet** | Posts a tweet from the connected X account |
| **YouTube** | Manage videos, playlists, and channels on YouTube |
# Triggers (/docs/node-catalog/triggers)
# Trigger Nodes [#trigger-nodes]
Triggers are the entry points for your workflow. Every workflow must start with exactly one Trigger node (with the exception of sub-workflows, which start implicitly when called).
When a trigger fires, Nodes2Cloud instantiates your compiled Cloudflare Worker and begins execution.
## Available Triggers [#available-triggers]
| Node | Description |
| ------------------------------------ | -------------------------------------------------------------------------- |
| **Manual Trigger** | Starts the flow from a test payload you provide — no external event needed |
| **Webhook Trigger** | Triggers the workflow when a webhook request is received |
| **Cron Trigger** | Triggers the workflow on a schedule (e.g. every hour) |
| **Error Trigger** | Captures and handles unhandled errors that crash the workflow |
| **Queue Trigger** | Triggers the workflow when a message is pulled from a Cloudflare Queue |
| **Google Sheets: Row Added/Updated** | Triggers when a row is added or updated in a Google Sheet |
| **Google Docs: Document Updated** | Triggers when text is added or modified in a Google Doc |