Description
n8n-nodes-robotframework
This is an n8n community node that enables you to execute Robot Framework scripts directly within your n8n workflows, combining the power of low-code automation with advanced test and robotic process automation (RPA).
n8n is a low-code workflow automation tool similar to Zapier and Make, designed to automate complex workflows with ease. Robot Framework is a versatile automation framework widely used for robotic process automation (RPA), acceptance testing, and more. This node bridges the two systems, allowing seamless execution of Robot Framework scripts inside n8n workflows.
One of the most exciting use cases of this integration is with the Robot Framework Browser library, which supports UI-based interactions like user clicks and website automation without requiring a GUI system environment — everything runs smoothly inside a Docker container housing both n8n and the Robot Framework node.
Installation
This guide walks you through setting up the Robot Framework Node in n8n and running n8n locally using a Docker container. You can follow either the Quick Start or Detailed Instructions, based on your preference.
Quick Navigation
- Quick Start
- Detailed Instructions
- Installing Community Node
—
Quick Start
To quickly set up, ensure Docker is installed, then run the following command:
docker run -it --rm --name n8n -p 5678:5678 -v n8ndata:/home/node/.n8n delilovic/n8nrobotframework:latest
Once the container is up and running, you will see the following message in the terminal:
Editor is now accessible via:
http://localhost:5678/
Open this URL in your browser to start using n8n. Next, follow the Installing Community Node section to add the Robot Framework Node.
—
Detailed Instructions
#### Using the Default n8n Docker Image (Not Recommended)
The default Docker image for n8n is based on Alpine Linux. To set it up, you can refer to the official installation guide: Official n8n Docker Installation Guide.
By default, the Alpine-based Docker image does not include Python and Robot Framework pre-installed. Users need to manually install these dependencies. It has been verified that after installing these dependencies, the Robot Framework node becomes fully functional and ready for use.
Please ensure Python and Robot Framework are installed inside the Docker container before proceeding.
#### Using the Custom n8n_robotframework Docker Image (Recommended)
If you are using the Robot Framework Browser Library, you’ll need the custom Docker image n8n_robotframework, which is based on Debian Bullseye. This custom image includes pre-installed dependencies, such as Python, Robot Framework, and the Browser Library.
This setup ensures that the Robot Framework community node works out of the box.
1. Replace the default image in your setup:
docker.n8n.io/n8nio/n8n
with:
delilovic/n8n_robotframework:latest
2. To run the custom Docker container, execute:
docker run -it --rm --name n8n2 -p 5678:5678 -v n8ndata:/home/node/.n8n delilovic/n8nrobotframework:latest
Once the container is up and running, you will see the following message in the terminal:
Editor is now accessible via:
http://localhost:5678/
Open this URL in your browser to start using n8n. Then proceed to the next step, Installing Community Node, to add the Robot Framework Node.
—
Installing Community Node
After setting up n8n (via either Quick Start or Detailed Instructions), follow these steps:
1. Access Settings:
– Navigate to n8n settings in your instance.
2. Open Community Node Section:
– Go to Community Nodes.
3. Install Robot Framework Node:
– Click the Install button and enter:
n8n-nodes-robotframework
– Confirm the installation.
4. Refresh the Page:
– Refresh your browser window to apply the changes.
5. Start Using the Node:
– The Robot Framework Node will now be available in your n8n workflow editor.
—
About the Custom n8n_robotframework Image
The custom Docker image, n8n_robotframework, is regularly updated alongside major versions of n8n (e.g., 1.72.0, 1.73.0, etc.). It is specifically designed to support the Robot Framework and its Browser Library while requiring minimal changes to the original image.
Additionally, the Robot Framework and the Browser Library are automatically updated to their latest versions every time the build runs for new n8n major versions.
You can access its source code or contribute at this GitHub repository:
GitHub Repository – Custom n8n Robot Framework Image
Usage Example
In this example, we will demonstrate the capabilities of n8n and Robot Framework with a simple yet powerful use case: performing a user login on a website and validating that the user is logged in successfully.
The example highlights the ability to interact with websites, capture screenshots, and maintain browser context while executing workflows across multiple nodes. Each node represents a separate execution.
Additionally, we will showcase how to export the Robot Framework’s report files and pass variables between nodes seamlessly.
Overview
!loginnode.png”>2loginnode.png
When we open the Login node, we see the Robot Framework script area, where the code for automating the login process is written. In this example, we have selected the Include Log HTML option to ensure an execution report (log.html) is generated after the script runs.
As the node has already been executed, the log.html file is now available for download on the Output panel, providing a detailed log of the execution.
There is also an option to toggle Include Other Input Fields, which would pass variables from the previous node to the script. However, since the previous node is a trigger node without any relevant data to pass, this option has been left disabled.
!loginnodereport.png”>4loginnodereport.png
The log.html report file displays the standard Robot Framework execution report. It includes details such as the execution status (PASS), the steps performed (e.g., opening a new browser, navigating to the URL, and entering credentials), and the time taken for each step.
Additionally, as defined in the code, the report includes the screenshot taken just before pressing the login button. This provides a visual confirmation of the login page and the filled-in credentials at the time of execution, making it easier to verify and debug the automation process.
Validate Node Details
!validatenodecode.png”>6validatenodecode.png
In the Validate Login node, we use the Expression View, which allows us to dynamically reference JavaScript expressions and variables from the previous node. Instead of hardcoding values, we utilize variables such as {{ $json.currenturl }} and {{ $json.statefile }}. On the right side, we can see how these expressions are evaluated after the node is executed, as the variables and their values are now known to the editor.
This implementation reuses the browser context state_file from the previous node, enabling the browser to resume exactly where it left off. The workflow navigates to the saved URL and verifies the presence of a specific label (“Secure Area page for Automation Testing Practice”) that appears only after a successful login. Additionally, the workflow captures a screenshot, which is sent via Telegram. The screenshot’s file path is passed to the next node using the Log keyword.
By combining the use of variables from the previous node with runtime evaluations, this approach enhances the workflow’s flexibility and adaptability to various inputs and scenarios.
!telegramnode.png”>8telegramnode.png
Finally, the Telegram node demonstrates how seamlessly Robot Framework can integrate with other n8n nodes, such as AWS, OpenAI, Airtable, and many more.
In this example, the screenshot binary, which was read from disk in the previous node, is dynamically used in the Telegram node. The binary data is sent as a photo attachment, along with a caption reading: “Login was successful!”.
This setup highlights how easily you can combine Robot Framework automation with powerful integrations in n8n to create end-to-end workflows. By leveraging the ability to process files, interact with external APIs, and send notifications, n8n provides a seamless way to share updates across channels. The output panel confirms the successful delivery of the photo and caption to the Telegram channel, completing the workflow.
Importing This Example into Your n8n Instance
You can import this example into your n8n instance by following these steps:
1. Create an empty workflow in your n8n instance.
2. Open the workflow editor and click on the three dots ... at the top right.
3. Select Import from File from the dropdown menu.
4. Upload the
This Week's Favorites in automation
More in automation
. In this example, the Browser Library is used to perform the following actions:</p>
<li><strong>Failure Handling:</strong> The task begins by registering <code>Take Screenshot</code> (with the <code>EMBED</code> argument) as the failure handler using <code>Register Keyword To Run On Failure</code>. This ensures that a screenshot is automatically captured and embedded into the log in case any step during the execution fails. This is particularly useful for debugging issues in automated workflows.</li>
<li>Open a new browser instance in headless mode with a registered <code>userAgent</code>.</li>
<li>Navigate to the login page using the <code>${URL}</code> defined in the variables section.</li>
<li>Wait for the cookie consent modal (<code>div.fc-consent-root</code>) to be hidden before proceeding.</li>
<li>Enter the username (<code>${USERNAME}</code>) and password (<code>${PASSWORD}</code>) into their respective input fields.</li>
<li>Capture a full-page screenshot during the login process, embedded directly into the log for easier debugging or verification.</li>
<li>Click on the login button to authenticate.</li>
<li>Save the current URL (<code>${current<em>url}</code>) and browser state (<code>${state</em>file}</code>) to maintain session continuity across nodes.</li>
<li>Close the browser instance once the actions are complete.</li>
<li>Log both the current URL and the saved browser state for reuse in subsequent nodes.</li>
<h3>Key Notes:</h3>
<li><strong>Failure Handling</strong>: The <code>Register Keyword To Run On Failure</code> ensures screenshots (<code>Take Screenshot</code>) are automatically captured and embedded into the logs if any failure occurs during execution. This is done by passing the <code>EMBED</code> argument, making the logs more informative and accessible directly from the report.</li>
<li><strong>Session Continuity:</strong> The use of <code>${state_file}</code> ensures session continuity. This allows the <strong>Validate Login</strong> node to resume exactly where the <strong>Login</strong> node left off, avoiding the need for reauthentication.</li>
<li><strong>User-Agent Configuration:</strong> A custom <code>userAgent</code> is passed via <code>New Context</code>, simulating a specific browser environment (<code>Mozilla/5.0...Chrome/124.0...Safari/537.36</code>), which is helpful for compatibility testing.</li>
<p>Variables in the Robot Framework node are no longer automatically forwarded between nodes. Instead, variables must explicitly be passed to subsequent nodes using the <code>Log</code> keyword (e.g., <code>Log ${foo}</code>). This approach ensures that only the intended variables are available to downstream nodes, improving efficiency and clarity within workflows.</p>
<p>Additionally, the Robot Framework’s standard output is automatically included, providing the framework’s typical execution status and result details.</p>
<p>!<a href=){kind=link}
