Automate the Web Visually

FlowsMatch Terms of Use

1. Acceptance of Terms

By accessing and using the FlowsMatch website and Chrome extension, you accept and agree to be bound by the terms and provision of this agreement.

2. Description of Service

The Extension: FlowsMatch provides a visual interface for creating web automation scripts. These scripts are executed locally within your web browser. No automation data is sent to our servers for execution.

The Website: This website is provided for informational purposes to demonstrate the capabilities of the FlowsMatch extension.

3. User Conduct

You are solely responsible for the automations you build and run. This tool must not be used for any wrongdoing, harmful actions, or malicious activities. You agree not to use the service for any of the following:

• Any illegal or unauthorized purpose.
• Scraping or data extraction from websites without their explicit permission.
• Interfering with or disrupting the service or servers or networks connected to the service.
• Automating actions on websites in a way that violates their terms of service.
• Harassment, spamming, or any form of cyber-bullying.
• Distributing malware or harmful code.

4. Disclaimer of Warranties

The service is provided "as is". We make no warranty that the service will be uninterrupted, timely, secure, or error-free.

5. Limitation of Liability

In no event shall FlowsMatch or its owners be liable for any direct, indirect, incidental, special, or consequential damages resulting from the use or the inability to use the service.

6. Contact Information

For any questions about these Terms, please contact us at flowsmatch_feedback@filesmatch.com.

FlowsMatch Privacy Policy

Information Collection and Use

We are committed to your privacy. This policy applies to both the FlowsMatch Chrome Extension and this website.

1. The FlowsMatch Chrome Extension

FlowsMatch is designed to be a local-first tool that you control.

• Local Execution: All automation flows, scripts, and actions are executed locally within your Chrome browser. We do not transmit your browsing activity or automation data to external servers.
• Templates & Storage: The automation templates you save are stored locally on your device using Chrome's chrome.storage.local API. They remain on your machine unless you explicitly export them.
• Uploaded Data: Data you upload (such as CSV files for loops) is processed entirely in your browser's memory for the duration of the automation run and is not uploaded to any server.
• Permissions:
  • Host Permissions (All URLs): Required to allow the automation engine to interact with, click, and type on any website you choose to automate.
  • Scripting, ActiveTab, & Tabs: Used to interact with web pages and manage browser tabs during automation.
  • Storage: Used to save your automation templates and settings locally.
  • Context Menus: Used to provide the "Inspect Element" tool via right-click.
  • Downloads: Used to save files directly to the user's Downloads folder without showing the operating system save dialog, as part of the Download File automation action.
  • Content Settings: FlowsMatch automates user-defined browser workflows that may include clicking links that open popup windows and triggering file downloads programmatically. Chrome's built-in popup blocker and automatic download restrictions block these actions when initiated by extension-injected scripts rather than direct user input. The contentSettings permission is used solely to allow popups and automatic downloads from the specific site the user is actively automating â no other content settings are modified, and only the origin of the current tab is affected at the time the relevant automation step runs.
  • Alarms: Used to run user-created automations on a schedule. When a user schedules a saved flow (e.g., "every 30 minutes," "daily at 9:00," or a one-time run), chrome.alarms triggers the extension's background service worker at the chosen time so the automation can run without the extension's tab being open. Alarms are created only for schedules the user explicitly sets up, and are removed when the user pauses or deletes them. No additional data is collected or transmitted.
  • Notifications: Used to inform the user when a scheduled automation finishes or fails. Because scheduled flows run in the background with the extension UI closed, a desktop notification is the only way to tell the user the outcome; clicking it opens the extension with that run's results ready to download. Notifications are shown only for scheduled runs, and the user can disable them per schedule. No additional data is collected or transmitted.
  • Offscreen: The extension includes a video recording feature for automation flows. We use the offscreen API to create a hidden document that handles the processing and encoding of captured frames into a downloadable video file. This is necessary because the background service worker does not have access to the required DOM APIs (such as HTMLCanvasElement and MediaRecorder) needed to compile images into a video.
  • Google API Services User Data Policy - Google Integrations: FlowsMatch integrates with Google services to provide enhanced automation capabilities. These integrations are built on a "Privacy by Design" principle, ensuring the application operates within the most restrictive security boundaries possible. To comply with Google's policies, we disclose:
    • Chrome Identity API & OAuth2: We utilize the Chrome Identity API for secure login and token management. We request the https://www.googleapis.com/auth/drive.file scope to interact with the Google Sheets and Drive APIs.
    • Restricted App-Created Access: By using the drive.file scope, FlowsMatch is limited to accessing only the specific files that it creates. The extension cannot see, read, or modify any other spreadsheets, documents, or files in your Google Drive that were not created by the application itself.
    • Minimal Data Usage (No Scraping): FlowsMatch does not read, extract, or "scrape" existing data from the content of your personal Google Sheet cells. Its functionality is strictly limited to creating new spreadsheet files during a flow's execution and inserting user-defined data into those specific files.
    • Purpose & Usage: Permissions are used exclusively to allow your automation flows to generate reports and logs in Google Sheets. All data processing occurs locally within your Chrome profile; no spreadsheet data is transmitted to or stored on our servers.
    • Data Protection & Sharing: We do not store Google credentials or OAuth tokens on our servers. We do not share, sell, or use any data accessed through these integrations for any purpose other than executing your specific automation tasks.
    • User Control: You have full control over your data. You can revoke access at any time using the 'Sign Out / Switch' button within the 'Declare Spreadsheet' node, through your Google Account security settings, or by uninstalling the extension.
• Execution History: We store a local record of your automation runs (flow name, status, timestamp, duration, and any error messages) within your browser's local storage (chrome.storage.local). This history is maintained solely for your convenience to review past executions and is limited to the 100 most recent entries. This data is never transmitted to our servers, shared with third parties, or used for any purpose other than providing you with a personal log of your automation activities.

2. The FlowsMatch Website

This website is static and does not use first-party cookies or analytics services.

Third-Party Embeds: We embed videos from YouTube. When you interact with these videos, Google may collect data or set cookies in accordance with their Privacy Policy.

Hosting Provider: This website is hosted via Cloudflare. Cloudflare may collect technical data (such as IP addresses and system logs) strictly for security, performance, and reliability purposes. This data is governed by Cloudflare's privacy policy.

Data Security

Since FlowsMatch operates primarily locally, your data remains within your own browser environment. We do not have access to your passwords, cookies, or the data you scrape. Any data interaction with Google services occurs directly between your browser and Google, orchestrated by the extension, without passing through our servers.

Contact Us

If you have any questions regarding this privacy policy, you may contact us at flowsmatch_feedback@filesmatch.com.

About FlowsMatch

FlowsMatch is a powerful, visual web automation tool designed to simplify complex browser-based workflows. Our mission is to empower users to automate repetitive tasks without writing a single line of code.

Whether you're a QA tester, a data entry specialist, or just looking to streamline your web interactions, FlowsMatch provides an intuitive interface to build robust automations.

Ethical Use: FlowsMatch is intended for legitimate and ethical automation tasks only. Users are strictly prohibited from using this tool for any harmful, malicious, or illegal activities.

For feedback, support, or inquiries, please contact us at flowsmatch_feedback@filesmatch.com.

How to Use FlowsMatch

Product Overview

FlowsMatch is a visual web automation tool that runs locally in the browser. Users build automation flows by dragging and dropping "nodes" (steps) and connecting them.

• Local Execution: All scripts run inside the user's browser — no data is sent to the cloud for execution. Scheduled runs also execute locally via Chrome's alarm system; Chrome itself must be running for a scheduled flow to fire.
• Visual Designer: No coding required. Users connect steps like "Go To URL", "Click", and "Type".
• Privacy Focused: Templates and data are stored in Chrome's Local Storage, unless you explicitly export or save them to a local file.

Core Concepts

• Nodes: Individual steps in the automation (e.g., Click, Type, Wait). Nodes are grouped into four categories in the "Add Step" menu: Browser, Network, Data, and Logic.
• Connections: Lines connecting nodes that define the order of execution.
• Container Steps: "Loop Over Data", "If/Else Condition", and "Try / Catch" are special nodes that hold a nested branch of steps. Their inner steps are visually indented, and each container has its own exit path that resumes the main flow afterward.
• Variables: Dynamic data placeholders using {{variable_name}} syntax. Variables can hold plain values, lists, tables, or entire API responses, and can be inserted into any field via the "+ Insert" / dropdown variable picker.
• Inspector: A built-in tool to select elements on a webpage and automatically generate robust CSS/XPath selectors. Available from the ⌕ button on any node field that accepts a selector.
• Notes: A freeform "Add Note" step for documenting a flow. It has no effect on execution and doesn't count as a browser/data/logic step.
• Handled Errors: Errors caught by a "Try / Catch" block are logged in the Handled Errors panel instead of stopping the run.

User Interface Guide

The Designer

• Canvas: The main area where you drag and drop nodes.
• Connecting: Drag from the bottom handle of one node to the top handle of another.
• Inspector: Click the "Inspect" button on any node input to open the selector tool. Click an element on the webpage to capture its selector.
• Branches: Container steps (Loop, If/Else, Try/Catch) render their nested steps indented beneath them. Use the "+" on a branch to add steps to that specific path (e.g., the "True" branch of an If/Else).

Running Automations

1. Click "Run Automation".
2. The view switches to Execution Mode.
3. Steps turn Blue (Running), Green (Success), or Red (Failed).
4. Headless Mode: Check "Run Headless" to run the automation in a background tab without focusing it.
5. Stopping: Clicking "Stop" in the UI aborts the run immediately. To exit cleanly and still generate output files (screenshots, spreadsheets), use a "Stop Flow" step inside your logic instead.
6. After a run finishes, screenshots and any generated files are available for download; execution history (flow name, status, timestamp, duration, errors) is kept locally for your 100 most recent runs.

Templates

• Save: Save your current flow to local storage under a name and optional category.
• Load: Reopen previously saved flows from "My Templates", searchable by name or category.
• Favorites / Quick Access: Star a template to pin it to Quick Access for one-click running without opening the designer.
• Local Files: Open a flow directly from a .json file on disk. Once opened this way, "Save" writes changes straight back to that same file instead of browser storage.
• Import/Export: Share flows as .json files, or export the current flow as a timestamped download.
• Templates can also be called as steps inside other flows — see "Run Flow" under Logic & Control Flow.

Scheduled Runs

Schedule a saved template to run automatically in the background — Chrome must be running, but the FlowsMatch tab does not need to be open.

• Creating a Schedule: From the logo menu, choose "Scheduled Runs," pick a saved template, and choose how often it runs: Every N Minutes, Daily at a Time, or One Time.
• Background Execution: Scheduled runs execute headlessly, the same underlying mechanism as "Run Headless" — no visible tab or window disruption.
• Notifications: A desktop notification reports when a scheduled run finishes or fails; clicking it opens FlowsMatch with that run's results ready to download.
• Results: Flows that write to Google Sheets save their results automatically. For local Excel/CSV output, use "Load Results" in the Scheduled Runs panel after a run to generate the downloadable files.
• Managing Schedules: Pause, resume, or delete any schedule; each row shows its last run's status and timestamp.
• Scheduled templates that contain "Run Flow" steps expand and run their sub-flows normally.

Feature Reference

Browser Actions

Go To URL

Navigates the browser to a new web page. This is usually the first browser step in any flow.

• Always use a full URL, including "https://" or "http://".
• Ensure this step is present before any other browser interaction steps like "Click" or "Type".

URL: https://www.google.com

Click Element

Finds an element on the page using a selector and performs a click action on it.

• Use the "Inspect" button to get a reliable selector for the element you want to click.
• For dynamic pages, you may need to add a "Wait" step before the click so the element has time to load.
• If multiple elements match the selector, the first one found is clicked.
• For complex menus, use one "Click" to open the menu, and a second "Click" to select an item.
• You can match by text/value using a regular expression by prefixing the selector with regex/ (e.g., regex/^Submit.*).

Selector: [data-testid="login-button"]
Or: regex/Login

Type Text

Finds an input field, textarea, or other editable element and types text into it.

• Use the "Inspect" button to get a selector for the input field.
• Use variables from previous steps (like from a CSV loop or a "Declare Variable" step) via {{variableName}} syntax.
• To clear the field before typing, add a "Clear Input" step first.

Selector: input[name="username"]
Text: john.doe@example.com

Clear Input

Finds an input field, textarea, or other editable element and clears its current value.

• Use this step before "Type Text" to ensure the field is empty.
• The selector should point to the input or textarea element itself.

Selector: input[name="search_query"]

Select Option

Selects an option from a dropdown menu. Supports standard <select> elements as well as custom dropdown components (e.g., Element UI, Vuetify).

• The value you provide is matched against the option's text, value attribute, or data-label.
• Matches are case-insensitive and support partial text (e.g., "Asia" matches "Southeast Asia").
• For custom dropdowns, the selector must point to the element that opens the dropdown.

Selector: #country-select
Value: US

Toggle Checkbox / Select Radio Button

Clicks a checkbox or radio button to toggle/select it. Functionally the same as "Click Element" but labeled for clarity when building forms.

• Use the Inspector to target the input element of type checkbox or radio directly.
• Sometimes the clickable element is the associated <label>, so you may need to select that instead.

Selector: input[id="terms-and-conditions"]
Selector: input[name="shipping_method"][value="express"]

Click Link

Clicks a link (<a> tag). The selector can point to the link itself or any container that wraps a link — the action finds the link inside automatically. The "Tab Behavior" setting controls what happens after the click.

• Navigate in current tab: the current page navigates to the link destination. Use for simple linear flows.
• Open in new tab (switch focus): a new tab opens and the automation follows it. Use when you need to interact with or extract data from the linked page, then add a "Close Tab" step to return.
• Open in new tab (stay here): the link opens as a background tab while the automation stays on the original page. Useful for opening many links at once without losing your place.

Selector: td.symbol > a
Tab Behavior: Open in new tab (switch focus)

// After interacting with the new tab:
Close Tab -> Active Page   (returns focus to the original page)

Hover Element

Simulates hovering the mouse cursor over a specific element. Useful for revealing dropdown menus or tooltips that only appear on hover.

• Place this before a "Click" step targeting an element that is only visible on hover.

Selector: .menu-item

Press Key

Simulates pressing a key or key combination. If an optional selector is provided, the automation waits for and focuses that element before pressing the key.

• For single keys, use names like Enter, Tab, Escape. For letters, just use the letter (e.g., a).
• For combinations, join keys with +, like Control+A or Shift+Enter.
• Use the selector to target a specific field (like a search box); leave it empty to trigger page-level shortcuts (like Escape or Control+P).
• Providing a selector increases reliability, since the automation waits for the element to appear before acting.

Key: Enter
Times: 1

Wait

Pauses the automation for a specified number of seconds.

• Use this to wait for animations to complete or elements to become available on dynamic pages.
• Prefer waiting for specific elements to appear where possible, rather than long fixed waits.

Seconds: 3

Wait for Element

Pauses the automation until an element appears on (or disappears from) the page, then continues immediately. More reliable and usually faster than a fixed "Wait" of N seconds.

• Use "Element appears" before interacting with content that loads asynchronously (AJAX results, modals, spinner-gated sections).
• Use "Element disappears" to wait for loading spinners or overlays to go away before clicking underneath them.
• The step succeeds the moment the condition is met — a generous timeout costs nothing when the page is fast.
• Selectors picked with "Inspect" self-heal: backup selectors are saved and tried automatically if the primary stops matching.

Selector: .search-results .result-row
Wait Until: Element appears
Timeout: 30 seconds

Scroll

Scrolls the page — either jumping to the bottom/top a number of times (with a pause between jumps), or scrolling until a specific element is centered on screen.

• For infinite-scroll feeds, scroll down 3–5 times with a 1–2 second pause: each jump reaches the current bottom, the pause lets the next batch load, and the following jump reaches the new bottom.
• Place a "Declare Variable" (list extraction) step after the scrolls to capture everything that loaded.
• Use "Scroll to element" to bring a specific section into view before clicking or screenshotting it — selectors self-heal via backup selectors, same as other steps.
• Interaction steps like Click already scroll their target into view automatically — you only need this step for lazy-loading pages or precise visual positioning.

Scroll Mode: Scroll the page
Direction: Down (to the bottom)
Scrolls: 3 times
Pause Between Scrolls: 2 seconds

Click Until Gone

Repeatedly clicks a button — like "Load More" or "Next" — pausing between clicks so new content can load, until the button is no longer present or becomes disabled. A self-contained replacement for the older Loop + If/Else + Break Loop pattern previously needed to detect the end of pagination.

• Best suited for "Load More" style buttons that append content to the same page rather than replacing it. Place a "Declare Variable" (list extraction) step after this one to capture everything that accumulated.
• For true multi-page navigation where each click replaces the page contents, extract data before this step runs again — it does not execute other steps between clicks.
• Max Clicks is a safety cap, not a target — the step always stops early the moment the button disappears or becomes disabled.
• Two stopping conditions are detected, whichever comes first: the button element is no longer present in the DOM, or the button gains a disabled attribute or aria-disabled="true" — the pattern many pagination controls use to signal "no more pages" without removing the button entirely.
• Selectors picked with "Inspect" self-heal via backup selectors, same as other selector-based actions. For infinite-scroll pages that require triggering lazy loading before the button appears, use a Scroll step first; use Wait for Element after to confirm new content has loaded before extracting it.

Selector: button.load-more
Max Clicks: 20
Pause Between Clicks: 1.5 seconds

Screenshot

Takes a screenshot of the visible browser area, or the entire page if "Capture Full Page" is enabled. Screenshots are saved in memory and can be downloaded as a .zip file after the run.

• Use for debugging to see the state of the page at a specific point in the flow.
• Place it after a "Go To URL" or "Click" step to verify the page loaded correctly.
• Enable "Capture Full Page" to automatically scroll and stitch the entire webpage into a single high-resolution image.

Checkbox: Capture Full Page (enabled)

Switch Tab

Switches the browser's focus to a different open tab. Can match by Title, URL, or simply switch to the currently active page (useful after a popup or new window opens).

• Use "Active Page" to switch to a popup or new window that just opened — no text matching needed.
• Use "By URL" for a more reliable match if tab titles aren't unique or change frequently.
• The match is a "contains" check, so you only need part of the title or URL.

Match By: Active Page

Close Tab

Closes a browser tab based on its Title or URL. It will not close the last remaining tab.

• Use this to clean up tabs opened during the automation (e.g., via "Click Link" -> new tab).
• Be specific with the match text to avoid closing the wrong tab.

Match By: URL
Text to match: "example.com/confirmation"

Browser Navigation

Performs standard browser navigation actions: Back, Forward, or Refresh.

• Use "Back" to return to a list after viewing details.
• Use "Refresh" if you're waiting for a status change (combine with a "Wait" step).

Action: Back

Upload File

Uploads a file to an input element of type "file".

• The selector should point to the input[type="file"] element. If it's hidden, select the visible "Upload" button instead — FlowsMatch will try to find the input or simulate a drag-and-drop event.
• The file you select is saved inside the flow, so it works without needing access to your local file system during execution.
• Maximum file size is 10 MB.

Selector: input[type="file"]
(Select a file using the button)

Download File

Triggers a file download, either by clicking a download button on the page or by fetching a direct URL.

• Use "Click Download Button" mode if the download is triggered by a button that runs page logic before the file starts downloading.
• Use "Download from URL" mode if you have a variable containing the direct download link.
• Enable "Auto-save to Downloads folder (skip dialog)" to suppress the OS Save As dialog. This intercepts the download before the dialog appears and re-triggers it silently; it does not work for POST-based downloads (dynamically generated files requiring a form submission).
• Use "File Name" to override the saved filename — the original file extension is always preserved.

Mode: Click Download Button
Selector: #export-csv
File Name: report_{{loop_index}}
Auto-save to Downloads folder: checked

Solve Captcha

Helps handle CAPTCHA challenges on the page — either by pausing for you to solve it yourself, or by auto-clicking the "I'm not a robot" checkbox and verifying it actually passed.

• Auto-Click Checkbox: Finds and clicks the "I'm not a robot" checkbox. reCAPTCHA and hCaptcha are detected automatically; an optional Selector (with Inspect support) handles custom captchas.
• After clicking, the step verifies the captcha actually passed (checking the solved state for up to ~8 seconds) instead of blindly continuing. If it's already solved, the step succeeds immediately without clicking.
• If a visual challenge popup appears instead of instant verification, the step automatically falls back to manual solve mode — an on-page prompt asks you to finish the challenge, then the flow resumes. If no checkbox can be found at all, the step fails with a clear error instead of silently continuing.
• Wait for Manual Solve: Pauses the automation and shows an on-page "Action Required" box; click "I have solved it" to resume. If solving the captcha auto-submits the page (common on login forms), that navigation counts as solved and the flow continues instead of erroring.
• In headless mode, a desktop notification alerts you that a captcha needs attention; clicking it brings the automation window forward so you can solve it.
• Use "Max Wait for Manual Solve" (1–60 minutes, default 10) to cap how long the flow waits for a human before failing the step. This applies to manual mode and to the auto-click fallback.

Type: Auto-Click Checkbox
Max Wait for Manual Solve: 10 minutes

Network

HTTP Request

Sends an HTTP request to a specified URL. Powerful for interacting with APIs directly, without needing a web page.

• Store the response in a variable to use the data in later steps (e.g., api_response).
• The response variable is an object containing body, status, and headers.
• Access nested JSON data with dot notation: {{api_response.body.data.id}}.
• Headers must be valid JSON, e.g., {"Authorization": "Bearer {{api_token}}"}.

Method: GET
URL: https://httpbin.org/get
Store response in variable: http_response

Send Webhook

Posts a message to a Slack, Discord, or Microsoft Teams channel — or any custom webhook endpoint. No API keys or sign-in required: you paste a webhook URL that you create once in the target app.

• Slack: sends {"text": message} for Slack Incoming Webhooks. Setup: add the "Incoming Webhooks" app to a channel and copy the URL (hooks.slack.com/services/…).
• Discord: sends {"content": message}. Setup: channel settings → Integrations → Webhooks → New Webhook, copy the URL.
• Microsoft Teams: sends an Adaptive Card. Setup: use the Workflows app with the "Post to a channel when a webhook request is received" template and copy the HTTP URL it generates. Microsoft has retired the older "Incoming Webhook" connector — the Workflows route is the current method.
• Custom JSON: sends your exact JSON body (the "Body" field, shown only for this format) to any endpoint — Zapier, Make, n8n, or your own server. The body is validated as JSON before sending.
• Both "Message" and "Body" support variables (e.g., {{row_count}}).
• Very long messages are automatically truncated to each platform's limit (Slack ~40k characters, Discord 2,000, Teams ~25k) rather than failing the flow.
• The step fails with a clear error if the message/body is empty after variable substitution, if the custom JSON is invalid, or if the endpoint returns a non-OK response.
• Use variables to report results, e.g. Scraped {{row_count}} rows from {{source_url}} ✅.
• Combine with Scheduled Runs for hands-off monitoring: the flow runs in the background and posts its outcome to your channel.
• Privacy: message content is sent to the webhook URL you provide — only include data you're comfortable posting there.

Format: Slack
Webhook URL: https://hooks.slack.com/services/T00/B00/XXXX
Message: Daily report finished — {{row_count}} rows saved ✅

Data & Variables

Loop Over Data

Iterates over a data source — rows from an uploaded CSV or Excel file, items in a list variable, or a fixed number of repetitions. Steps connected to the "Loop Steps" path run once per item.

• From Uploaded File (CSV / Excel): each row is one iteration; column headers become variables you can use inside the loop (e.g., {{column_name}}). Accepts .csv, .xlsx, and .xlsm files (for legacy .xls, re-save the file as .xlsx first).
• Excel workbooks: pick which sheet to use, and the data table is detected automatically — leading title rows, blank rows, and empty margins are skipped, and the first table row is treated as headers. You can switch sheets or adjust the range later without re-uploading the file.
• Custom range: if auto-detection doesn't match your layout, enter the range yourself: A3:F100, open-ended A3:F (down to the last data row), or a single start cell like A3 (to the end of the data). Untick "First row contains headers" for headerless tables — columns are then named column_A, column_B, etc.
• Excel values keep their meaning: formulas are read as their calculated results, and dates arrive in YYYY-MM-DD form (with a time when one is set).
• From Variable: the variable must be a list (e.g., ["a", "b", "c"], or a list produced by another step such as a "Declare Variable — List" extraction).
• Fixed Number of Times: repeats the branch a fixed number of times; use {{loop_index}} to track the current cycle.
• Inside the loop, access the current item with {{item}}. If you looped over a top-level variable (e.g., {{my_list}}), that same name also refers to the current item inside the loop, as a shorthand for {{item}}.
• The current iteration number (starting from 1) is always available as {{loop_index}}.
• Maximum of 5,000 iterations per loop, to keep runs performant.
• Use "Break Loop" inside an "If/Else" branch to stop iterating early once a condition is met.

Mode: From Data Source
Source: Uploaded File (CSV / Excel)
File: products.xlsx
Sheet: Q3 Catalog
Data Range: (auto-detected: B4:F129)

// Inside the loop, a "Type Text" step:
Selector: #search-box
Text: {{product_name}}

// Types the "product_name" column's value for each of the 125 rows.

Declare Variable / Set Variable

"Declare Variable" creates a new variable; "Set Variable" updates one declared in a prior step. Both support the same three sources of data.

• Value / Expression: a manual value, or a simple expression using other variables, e.g., {{my_var}} + 1.
• From Web Element: scrape data from the page. Choose "Single Value" for one item, "List" for a full column of repeated elements, or "Table" to capture an entire grid at once.
• Table mode: use "+ Add Column" to define your data structure, naming each column and using the ⌕ Inspect button to pick the matching element in the first row — the rest of the rows are captured automatically without a loop.
• Active URL text: stores the current page address, useful for logging or later navigation.
• Variable names should contain only letters, numbers, and underscores (e.g., user_id, product_list).

Variable Name: api_endpoint
Set Value From: Value / Expression
Value: "https://api.example.com/data"

// Or, to capture the current page:
Variable Name: source_url
Set Value From: Active URL text

Logic & Control Flow

If/Else Condition

Executes different branches of the flow based on logical conditions, with support for multiple criteria and a common exit path.

• Combine multiple conditions with AND (all must match) or OR (any can match).
• Use the "True" and "False" branches for conditional logic, and the "Next Step" branch for actions that should run after the condition block finishes, regardless of outcome.
• Use the "+ Insert" button to add variables like {{my_variable}} or {{csv_column}} into comparison fields.
• Make sure comparison operators (equals, contains, greater than, etc.) match the expected data type of your variables.

Condition 1: {{status_code}} equals 200
Logical Join: AND
Condition 2: {{body.success}} is true

// Goes to "True" only if both match, then proceeds to "Next Step".

Try / Catch

Wraps a series of steps so that a failure doesn't stop the whole flow. If any step on the "Try Steps" branch fails, the error is caught and logged in the Handled Errors panel, and execution continues from the main path after the block.

• Use this for actions that might not always succeed, like closing an optional pop-up or interacting with an element that doesn't always appear.
• Also useful around a "Run Flow" step when the sub-flow is optional or might fail, so the parent flow keeps going.

No parameters needed. Place steps that might fail on the "Try Steps" path.

Break Loop

Immediately exits the current loop and continues execution from the step connected to the loop's exit path.

• Use this inside an "If/Else" condition within a loop to stop processing once a criteria is met (e.g., "stop after finding the first matching item").
• Inside a "Run Flow" sub-flow, this breaks the nearest enclosing loop — which can be a loop in the calling flow if the sub-flow itself has none.

No parameters needed.

Stop Flow

Immediately stops the flow and generates results — a clean, planned exit rather than aborting with the UI "Stop" button.

• Use this to create custom exit points based on logic (e.g., inside an If/Else).
• Enable "Keep browser tabs open" to perform manual verification or further actions after the automation finishes.
• Enable "Return focus to FlowsMatch" to immediately view execution logs and download results once the flow stops.
• Unlike clicking "Stop" in the UI, this still generates your output files (screenshots, spreadsheets, etc.).

Keep browser tabs open: checked
Return focus to FlowsMatch: checked

Run Flow

Runs a saved template as a step inside another flow — a reusable sub-flow. The template's steps execute right at that point in the flow, sharing the calling flow's variables, browser tabs, and spreadsheets. When the sub-flow finishes, execution continues with the next step of the calling flow.

• Variables are shared both ways: the sub-flow can read variables declared before the "Run Flow" step, and any variables the sub-flow declares remain available to the steps after it. There is no separate variable scope.
• Same browser context: the sub-flow uses the flow's current tab(s). It doesn't need its own "Go To URL" step if the calling flow has already navigated somewhere — and a sub-flow that does navigate leaves the calling flow on that page, which is often exactly what you want (e.g. a "Login" sub-flow).
• Spreadsheets are shared too: a sub-flow can write into a spreadsheet the parent declared, or declare one the parent uses afterward.
• Nesting is supported — a template can itself contain "Run Flow" steps, up to 8 levels deep. Cycles are blocked: a template calling itself, directly or through another template, fails before the run starts with a clear "cycle detected" error.
• Errors propagate to the parent: if a step inside the sub-flow fails, the whole flow fails at that point — unless the "Run Flow" step is wrapped in a Try / Catch in the calling flow, which catches the sub-flow's error and lets the parent continue.
• Full visibility: while the sub-flow runs, its "Run Flow" step shows as running and accumulates the sub-flow's total execution time (like a "Loop Over Data" step does). The execution log lists every sub-flow step, prefixed with the template name (e.g. Login to Portal › Type Text).
• Works with Scheduled Runs: scheduled templates that contain "Run Flow" steps expand and run their sub-flows normally.
• Renaming or deleting a template breaks flows that call it — validation warns about a missing template before the run starts. An empty template (just a Start node) is skipped as a harmless no-op.
• Perfect for reusable building blocks: save a "Login", "Accept cookies", or "Open report page" sequence once as a template, then call it from every flow that needs it — fix it in one place, and every flow that uses it is updated.
• Combine with "If/Else Condition" to choose between different sub-flows based on a condition.
• Wrap the step in "Try / Catch" when the sub-flow is optional or might fail, so the parent flow keeps going.
• Caveat: a "Break Loop" step inside a sub-flow breaks the nearest enclosing loop — which can be a loop in the calling flow if the sub-flow itself has none.

Template to Run: Login to Portal

Spreadsheet & Reporting

Declare Spreadsheet

Defines an output spreadsheet for the flow to write to, on one of three platforms.

• Local Excel (.xlsx): generated on your machine; supports formatting and inserted screenshots.
• Local CSV: highly compatible (e.g., with Linux tooling), but does not support screenshots or formatting.
• Cloud Google Sheet: always creates a new, unique spreadsheet in your Google account during execution — for security, FlowsMatch cannot access or verify spreadsheets created manually in Google Drive.
• Provide a simple name; the correct extension (.xlsx/.csv) is added automatically for local files.
• Place this before any "Update Spreadsheet Cell" or "Insert Screenshot to Spreadsheet" steps.

Platform: Cloud Google Sheet
Spreadsheet Name: Monthly Report

Update Spreadsheet Cell

Writes a value to a previously declared spreadsheet — either to a specific cell, or as a whole appended row.

• "Target File" must match the name defined in a "Declare Spreadsheet" step.
• Specific Cell mode: use variables in the "Cell" and "Value" fields — very useful inside a loop (e.g., Cell: A{{loop_index}}, Value: {{csv_column}}). A live preview under the Cell field shows what the expression resolves to while you edit.
• Append Row mode: skips cell addressing entirely — each execution writes one row (one value per column, starting at column A) directly below everything written so far in that sheet. Write your headers first with a "Specific Cell" step, then append inside the loop: one row per iteration, no {{loop_index}} arithmetic needed.
• Real value types: plain numbers (42, -3.14), true/false, and ISO dates (2026-07-18, optionally with a time) are written as actual numbers, booleans, and dates — so SUM(), sorting, and charts work on the output. Start a value with an apostrophe ('007) to force literal text.
• Formulas: start the value with = to write a formula, e.g. =SUM(A1:A10) or =HYPERLINK("https://example.com","link"). Formulas are calculated by Google Sheets / Excel when the file is opened. (Not supported for CSV, which stores plain text.)
• Formatting panel: style what you write — bold, italic, text color, highlight (background) color, and a number format: Number (1,234.56), Currency ($), Percent, or Date. Works for Google Sheets and local .xlsx; CSV is plain text and ignores formatting. Percent follows the spreadsheet convention: a value of 0.42 displays as 42.00%.
• Fast in loops: Google Sheets updates are batched behind the scenes (about 25 cell writes per API call), making long loops much faster and avoiding quota errors. Buffered writes are always delivered when the flow finishes, fails, or is stopped.

Mode: Append Row
Target: report
Row Values:
  A: {{product_name}}
  B: {{price}}
  C: =HYPERLINK("{{url}}","view")

Insert Screenshot to Spreadsheet

Takes a screenshot and inserts it into a cell range. Not supported for CSV files.

• The "Cell" parameter must be a range (e.g., A1:K20) to define the size of the inserted image.
• Use this inside a loop to build reports with visual evidence for each item.
• An "Append Row" step placed after the screenshot automatically starts below the image, so appended data never lands on top of it.

Target File: report
Sheet Name: Sheet1
Cell: B2:J25

Organization

Add Note

Adds a freeform comment box to the canvas for documenting your flow (e.g., explaining why a section exists, or leaving reminders for future edits).

• Notes are not connected into the execution path and have no effect on the flow's behavior.