Skip to main content

​
Understanding Types in Gumloop

Each input and output in a node has a specific type that defines the kind of data it can handle. Understanding types is crucial for building flows that work correctly, as type mismatches are one of the most common causes of flow errors.
The most common type you’ll encounter is Text, as most flows involve working with text data.

​
Core Data Types

Gumloop primarily works with these data types:

Text

A single piece of text such as a message, document, or value.Example: “Hello, world” or “The quarterly report shows a 15% increase in sales”

List of Text

A collection of multiple text items.Example: [“Email 1”, “Email 2”, “Email 3”] or [“Product A”, “Product B”, “Product C”]

List of List of Text

A nested collection of text lists, similar to a table or matrix.Example: A table with rows and columns of data

​
List of List of Text Example

This type is often the output of nodes that read tables or produce grouped data: 
[
  ["Apple", "Red", "$1.50"],     // First row: Item, Color, Price
  ["Banana", "Yellow", "$0.75"], // Second row: Item, Color, Price
  ["Orange", "Orange", "$1.25"]  // Third row: Item, Color, Price
]

​
Identifying Types in Your Flow

Types are visually indicated in the node’s side-menu when you click on a node.
Node type indicator in side menu

​
Type Compatibility

For a flow to work correctly, the output type of one node must match the input type of the next node. If the types don’t match, the flow will fail due to a type mismatch error.

​
Compatibility Reference Table

Source TypeTarget TypeCompatible?Solution if Incompatible
TextText
Compatible
N/A
TextList of text
Incompatible
Use Duplicate node
List of textText
Incompatible
Use Join List Items or Loop Mode
List of textList of text
Compatible
N/A
List of List of textList of text
Incompatible
Use Flatten List of Lists
List of List of textText
Incompatible
Use Flatten + Join List Items

​
Common Type Mismatch Scenarios

Problem: You have a list of items (such as emails from Gmail Reader) but need to process them as a single text input.Example:
  • Gmail Reader outputs a List of text (multiple emails)
  • You want to send a single message to Slack containing all emails
Solutions:
  • Join List Items Node
  • Loop Mode
Combines all items in the list into one text string.
  • Input: List of emails
  • Output: One text string containing all emails (with separators)
  • Use case: When you need to process all items together as one unit
Problem: You have a single text item but need to use it with each item in a list.Example:
  • You have a style guide (text) that needs to be applied to multiple blog posts (list)
  • An API key (text) that needs to be used with multiple API calls (list)
Solution: Use the Duplicate Node
  • Input: Single text
  • “List size to match” input: Connect your list
  • Output: List containing copies of your text, matching the size of your other list
Problem: You have a nested list (lists within a list) but need a flat list.Example:
  • Website Crawler outputs URLs for each site (creating a list of lists)
  • You need a simple list of all URLs for processing
Solutions:
  • Flatten List of Lists Node
  • Subflow with Loop Mode
Combines all nested lists into one flat list.
  • Input: Nested list structure
  • Output: Single-level list with all items
  • Use case: When you need all items in one flat structure

​
Loop Mode: A Powerful Tool for Type Handling

Loop Mode is one of the most powerful features for handling type mismatches in Gumloop. When enabled on a node, it allows that node to process a list input one item at a time.

​
How Loop Mode Works

1

Without Loop Mode

  • Input: List of text [“Item 1”, “Item 2”, “Item 3”]
  • Node expecting Text input: Error: Type mismatch
2

With Loop Mode Enabled

  • Input: List of text [“Item 1”, “Item 2”, “Item 3”]
  • Processing: Node processes “Item 1”, then “Item 2”, then “Item 3” separately
  • Output: List of results, one for each input item
  • Result: Success

​
When to Use Loop Mode

Loop Mode is ideal when you need to:
  • Process each item in a list individually
  • Apply the same operation to multiple items
  • Connect List outputs to nodes that expect Text inputs

​
Loop Mode vs. Join List Items

FeatureLoop ModeJoin List Items
Processing StyleIndividual processingCombined processing
InputList of itemsList of items
OutputList of resultsSingle text item
Use CaseWhen each item needs individual attentionWhen all items should be processed together
ExampleSummarize each document separatelyCombine all documents and summarize once

​
List Operation Nodes for Type Conversion

Gumloop provides several specialized nodes designed specifically for handling type conversions:

Join List Items

Purpose: Combine all items in a list into a single text string
  • Input: List of text
  • Output: Text
  • Options: Choose separator (newline, comma, space, etc.)
  • Example use: Combining search results into one report

Duplicate

Purpose: Create multiple copies of a single text item
  • Input: Text
  • Output: List of text (with repeated items)
  • Options: Specify how many copies or match another list’s size
  • Example use: Using the same prompt for multiple documents

Flatten List of Lists

Purpose: Convert a nested list into a simple, flat list
  • Input: List of List of text
  • Output: List of text
  • Example use: Processing crawled web pages

Get List Item

Purpose: Extract a specific item from a list
  • Input: List of text
  • Output: Text (single item)
  • Options: Specify index (position) to extract
  • Example use: Getting only the first search result

Combine Lists

Purpose: Merge multiple lists into one
  • Input: Multiple List of text inputs
  • Output: Single List of text with all items
  • Example use: Combining results from multiple sources

​
Best Practices for Managing Types

Consider what type of data each step will produce and consume. Identify where type conversions will be needed before you start building your flow.
Use Error Shield around sections processing lists. Use Duplicate node to match list sizes when needed.
Include type information in your node names and descriptions.Example: “Join Customer Names (List → Text)”This makes it easier to understand data flow at a glance.
Creates cleaner, more maintainable flows. Helps isolate and solve type-related issues.

​
Frequently Asked Questions

If you can’t connect two nodes, check their input/output types. Hover over the connection points to see the expected type. Use appropriate type conversion nodes or Loop Mode to resolve mismatches.
  • Use Loop Mode when you want to process each item in a list individually
  • Use type conversion nodes (like Join List Items) when you want to transform the data structure itself
When a node outputs multiple lists (like a Google Sheets Reader with multiple columns), you have several options:
  1. Process each list separately with different nodes
  2. Combine the lists first if they need to be processed together
  3. Use Loop Mode to process corresponding items across multiple lists
When working with nodes that produce a None type output (like JSON Reader or Run Code):
  1. First, understand what the actual output will be at runtime based on your input data
  2. Set up your subsequent nodes expecting that type
  3. Use type conversion nodes if needed to ensure compatibility

Loop Mode

Learn more about Loop Mode functionality

List Operations

Explore all list operation nodes

Error Handling

Troubleshoot type mismatch errors