​
Welcome to the Gumloop community 👋

If you’re interested in building powerful automations without writing a single line of code, you’ve come to the right place. Gumloop offers an intuitive and collaborative platform to create AI-powered workflow automations called flows using modular components known as nodes.

​
Key Features

Automation Building: Drag, drop, and link nodes onto a canvas to create powerful automations (we call them flows).
 Integrations: Connect to popular services like Slack, Salesforce, Airtable, AWS, GitHub, Outlook, Google, and more. Scalable Infrastructure: Run your flows at massive scale with no technical background needed. Team Collaboration: Share and build flows together with your team members under a workspace.
 AI-Powered Capabilities: Leverage advanced AI models to process data, generate content, analyze information, and make decisions within your flows.

​
Core Terminology

Nodes: The modular building blocks that you drag onto the canvas. Think of these as individual no-code Lego pieces that each perform a specific function (like reading from a Google Sheet or processing text with AI). Flows: A series of connected nodes designed to achieve a specific goal. These are your no-code Lego creations that transform raw data into valuable outputs. Subflows: Reusable flows embedded within larger flows. These allow you to make complex processes simple, modular, and maintainable. Learn more in our Subflows documentation. Workbooks: Collections of related flows organized in one document, similar to how spreadsheet applications group related sheets. Learn more in our Workbooks documentation. Workspaces: Collaborative environments where teams can build and share automations, manage credentials, and work together on projects (available on Pro plan and above). Learn more in our Organizations and Workspaces documentation.

​
What is a Node?

Nodes are the modular components that make up a flow. Each one is a step in a series of steps towards a goal. You can drag-and-drop them on to the canvas from the node menu that can be shown/hidden through the + icon on the side panel of your workbook.
Node library menu showing various node categories

​
Node Anatomy

Nodes generally have three key components:
  1. Inputs: Data that flows into the node for processing
  2. Parameters: Configuration options that control how the node functions
  3. Outputs: Results produced by the node that can connect to subsequent nodes
Many of these attributes may also be optional. Let’s take a look at an example:
Extract Data node example showing inputs, parameters, and outputs
This node above is an AI data extractor. It takes some content as input, extracts the data you specify (in this case ‘Company Name’) and outputs the extracted data. If you did not pass in an input to this node and tried to run it, it would fail because it’s trying to extract a company name from nothing. The data you pass in is entirely up to you. This node can perform data extraction on anything, whether it’s text from a Google Doc, a website, an email, etc.
Pro Tip: You can click on the node title to give the node a nickname.

​
Node Categories

Gumloop offers various types of nodes to build comprehensive workflows:

​
What is a Flow?

Flows are the heart of Gumloop, allowing you to connect nodes to execute specific tasks. When a flow is run, data passes from one node to the next, with each node manipulating or generating content along the way. Here is an example of a flow that analyzes a website using AI and outputs a Google Doc report.
Example flow showing website analysis and Google Doc output

​
Running a Flow

You can simply run the flow by hitting the run button in the top right corner:
Run button in the flow interface
After hitting run, a run report will pop up describing the current stage of the flow in real-time as actions are happening. The run report also shows the total time, credits used, and completion status of the automation run. Each node’s log is available in these collapsable components, making it easy to debug if something goes wrong.
Run report showing execution details

​
Credits System

Flows consume credits when they run. Each flow run costs 1 credit, and certain nodes that use external APIs (like AI nodes or web scraping) cost additional credits, example:
  • Advanced AI calls (GPT-4.1, Claude 3.7 Sonnet): 20 credits
  • Standard AI calls: 2 credits
  • Search Companies: 30 credits
  • Website Scraper: 1 credit
  • Web Search: 2 credits
You can reduce costs by providing your own API keys for certain services (available on premium plans). Learn more in our Credits documentation.
The credit cost is indicated on each node’s tooltip.

​
How to Build a Flow

The flow building page is a large canvas for you to design your personalized flow. Each node can be found in the library on the left side.
Blank canvas for building flows
Nodes are dragged and dropped onto the canvas one at a time. Once they’re on the canvas they’re ready to be connected together. The inputs of one node are derived from the outputs of another. It’s crucial that the output type matches the input type of connected nodes to prevent data mismatches and flow crashes.

​
Understanding Types

Each node has specific input and output types:
  • Text: A single piece of text
  • List of text: A collection of multiple text items
  • List of List of text: A nested collection of text lists
For example, if a Google Sheets Reader outputs a List of text but your AI node expects Text, you’ll need to use a node like Join List Items to convert between types. Learn more in our Types documentation.

​
Loop Mode

Many nodes support Loop Mode, which allows them to process lists of inputs automatically. Think of it as a “for loop” in programming:
  • Normal Mode: Process one item at a time
  • Loop Mode: Process each item in a list individually
For example, a Summarizer node in Loop Mode can process multiple emails in one operation, creating a summary for each email automatically. Learn more in our Loop Mode documentation.

​
The Standard Format of a Flow

Most flows follow this general pattern: Ingest data → Prepare it for AI → Process it with AI → Output a result

​
1. Loading Data

Flows typically start by ingesting some sort of data. This could be:
  • Reading from a Google Sheet
  • Importing a CSV file
  • Scraping a website
  • Reading emails from Gmail
  • Collecting data from Slack messages
Example: A Google Sheets Reader node fetching customer information

​
2. Text Manipulation, File & List Operations

These nodes prepare your data for processing:
  • Reformatting text
  • Splitting content into chunks
  • Combining multiple pieces of information
  • Converting between data types
  • Extracting specific values from complex data
Example: Using Combine Text to merge customer name with a template message

​
3. Using AI

AI nodes process the prepared data:
  • Summarizing long documents
  • Answering questions about the data
  • Extracting specific data points
  • Categorizing content
  • Scoring or evaluating information
Example: Using Ask AI to generate personalized email responses based on customer inquiries

​
4. Integrations

The final step is to output results to external systems:
  • Sending emails via Gmail
  • Posting messages to Slack
  • Writing to Google Sheets
  • Creating tasks in project management tools
  • Generating files and reports
Example: Using Gmail Sender to deliver personalized responses to customers

​
Real-World Flow Example

Here’s a practical example of how these components work together: Customer Support Automation 
Gmail Reader → Extract Data → Categorizer → Ask AI → Gmail Sender
  1. Gmail Reader: Fetches new customer emails
  2. Extract Data: Pulls out customer name, issue type, and account details
  3. Categorizer: Sorts emails into urgent, standard, or information requests
  4. Ask AI: Generates appropriate responses based on the category
  5. Gmail Sender: Sends the response back to the customer
This flow automates repetitive customer support tasks while maintaining personalization.

​
Advanced Features

​
Subflows

Subflows allow you to:
  • Break down complex logic for better maintenance
  • Enable efficient looping operations
  • Reuse common functionality across different flows
To create a subflow:
  1. Add input nodes to specify what data the subflow expects
  2. Add output nodes to define what the subflow returns
  3. Build your logic between these endpoints
Learn more in our Subflows documentation.

​
Triggers and Alerts

Triggers automatically start flows based on events:
  • Time-based scheduling
  • New emails in Gmail
  • New messages in Slack
  • Webhooks for custom integrations
You can also set up email notifications for flow failures. Learn more in our Triggers documentation and Alerts documentation.

​
Interfaces

Transform your workflows into user-friendly interfaces:
  • Create simple, customizable forms
  • Hide complex workflow logic
  • Allow non-technical users to run your flows
  • Deliver results directly to users
Learn more in our Interfaces documentation.

​
Get Started with Templates

The fastest way to get started is by using a prebuilt template. We’ve built 60+ functional flows with annotations for you to browse. Keep in mind however that the true power of the platform lies in personalization. Use templates as a starting point but then make things your own! Get started with templates here: https://www.gumloop.com/templates

​
Next Steps

Now that you understand the basics of Gumloop, here are some recommended next steps:
  1. Explore Templates: Browse our template library to see what’s possible
  2. Create Your First Flow: Start with a simple automation that solves a real problem
  3. Set Up Credentials: Connect to external services like Gmail, Slack, and more
  4. Join the Community: Connect with other Gumloop users at forum.gumloop.com