Every node, what it does, and one worked example

A small table you type or paste straight into the node — your own column names, types and rows — used as a data source like any file.

Reads one tabular file — on your own computer, in My files on FlowDoo, or in Google Drive — and turns it into rows for the pipeline.

Reads one sheet of an Excel workbook (.xlsx or .xls) — or just a cell range of it — from your computer, My files on FlowDoo or Google Drive, and turns it into rows.

Reads a delimited text file and works out the awkward parts itself: the delimiter (comma, semicolon, tab or pipe), whether the first row is a header, and the text encoding.

Reads a PDF — on your own computer, in My files on FlowDoo, or in Google Drive — and returns one row per page with that page's text.

Reads an uploaded Word document and returns its text as one row per non-empty line.

Reads a whole table from a saved MySQL connection into the pipeline.

Reads a whole table or view from a saved Microsoft SQL Server connection.

Lists every file of one type in a folder — on your own computer, in My files on FlowDoo, or in Google Drive — one row per file.

Reads a whole table or view from a PostgreSQL database — on your network or hosted (RDS, Azure, Supabase, Neon…) — and turns it into rows.

Reads a whole table or view from an Azure SQL database (yourserver.database.windows.net) and turns it into rows.

Runs a SQL query with DuckDB over one local file — Parquet, CSV, JSON (the view data) or a DuckDB database (its own tables) — and turns the result into rows.

Reads a whole table or view from an Oracle database and turns it into rows — Thin mode, so no Oracle Client needs installing on the server.

Reads documents from a MongoDB collection — optionally filtered and narrowed to some fields — one row per document, nested fields flattened to dot paths.

Reads a whole table or view from Snowflake and turns it into rows.

Runs a read-only standard-SQL query in Google BigQuery and turns the result into rows, every page of it.

Reads a whole table or view from a Databricks SQL warehouse (Unity Catalog or hive_metastore) and turns it into rows.

Reads a whole table or view from an IBM DB2 database (LUW or Db2 on Cloud) and turns it into rows.

Reads a whole table or view from Teradata Vantage and turns it into rows.

Reads a whole table or view from any database that has a JDBC driver — Informix, SAP HANA, Sybase ASE, H2, Firebird and more.

Reads a whole table or view through ODBC — a DSN set up on the FlowDoo server, or a connection string naming an installed driver.

Adds details of the file each row names — whether it exists, its name, extension, size in bytes and last-modified time — reading files on the server, in My files, in Google Drive or on a computer sharing through the desktop agent.

Copies the file each row names into another folder — on the server, in My files, in Google Drive or on a computer sharing through the desktop agent.

Moves the file each row names into another folder: copied there, then removed from where it was.

Renames each file in its own folder from a pattern: {name} is the old name without its extension, {ext} the extension, {date} today, {time} the time, and {Column} a value from the row.

Deletes the file each row names, on the FlowDoo server or in My files.

Reads every file in a folder whose name matches a pattern — part-*.csv, *.xlsx — and stacks them into one table, with each row's source file in __source_file.

Adds the incoming rows to the end of a file — CSV, tab-separated text or JSON Lines — creating it, with a header line, the first time.

Reads a text file as one row per line — or, given a delimiter, splits each line into columns.

Re-saves text files in another encoding — for example Latin-1 or Windows-1252 exports as UTF-8 — in place, or into another folder.

Builds a file path per row from a template: {Column} takes the row's value, {date} today's date, {time} the time; characters a file name cannot hold become _.

Bundles files into one .zip — the files the rows name, or every matching file in a folder — and saves it to a folder in any location.

Unpacks a zip file and gives one row per file inside it — name, inner folder, size and path — ready for File Input or a Loop.

Reads one tab of a Google Sheet through a service account and returns it as rows.

Reads the files in a Google Drive folder, either as rows or as a list of files for another node to open.

Runs a SOQL query against a Salesforce org and returns the matching records as rows.

Reads records from PowerSchool SIS — a database table such as students or cc, or a named PowerQuery — and returns them as rows.

Calls a REST endpoint and turns the JSON it returns into rows.

Reads messages from your own mailbox over IMAP — one row per message, or one per attachment saved as a file — filtered by folder, sender, subject, date and unread.

Reads the files under a prefix in an S3-compatible bucket (Amazon S3, Cloudflare R2, MinIO, Wasabi…) — merged into rows, or as one row per downloaded file.

Reads the files in a folder of an FTP, FTPS or SFTP server — merged into rows, or as one row per downloaded file.

Reads the files in a SharePoint document library folder through Microsoft Graph — merged into rows, or as one row per downloaded file.

Reads the files in a Dropbox folder — merged into rows, or as one row per downloaded file.

Runs a Google Analytics 4 report — dimensions and metrics over a date range — and turns it into rows, one per combination of dimensions.

Reads the records of a ServiceNow table — incidents, changes, CMDB items, users — through the Table API, optionally filtered by an encoded query.

Reads the records of a Dynamics 365 CRM (Dataverse) table — accounts, contacts, opportunities, custom tables — through the Web API.

Adds a fingerprint of each row — or of each picked column — made with MD5, SHA-1, SHA-256 or SHA-512, so two tables can be compared row by row without moving the data itself.

Will encrypt a column with AES-256-GCM using a key held in FlowDoo's secret store, or decrypt it back — e.g. an SSN column before an export leaves the building.

Encodes text as Base64, URL-safe Base64 or hex — or decodes it back to readable text.

Finds social security numbers, card numbers, phone numbers, emails — or your own pattern — in a column, even inside free text, and masks, redacts or tokenizes each one.

Adds each file's checksum — CRC-32, MD5 or SHA-256 — reading the files from any place the file nodes can read.

Will bring named secrets — a database password, an API token — into a flow as rows, so later nodes can use them without the secret being written in the flow.

Puts an apostrophe in front of cells that a spreadsheet would run as a formula — anything starting with =, +, -, @, a tab or a carriage return.

Tests each row against conditions on one or more columns, linked with AND / OR, and sends matching rows out the True output and the rest out the False output.

Keeps the rows whose coordinates fall inside an area you paste (GeoJSON, WKT or a list of points) — or outside it, or keeps all rows and marks them.

Renames one or more columns while keeping their position and values.

Removes one or more columns from every row.

Keeps only the columns you tick and drops everything else.

Reorders columns and can rename them at the same time through an alias.

Puts both tables' columns side by side, keeping a column that appears in both only once.

Keeps only the columns both tables have, dropping everything either one lacks.

Keeps table A's columns, without any column table B also has.

Inserts new columns at chosen positions, each holding fixed text, a value worked out per row, or nothing.

Adds a column whose value is worked out per row from a formula.

Replaces literal text inside one column using an ordered list of find and replace rules.

Replaces text in one column using a regular expression applied to every match in the cell.

Removes leading and trailing whitespace from the values in one column.

Drops rows whose key values were already seen, keeping the first occurrence of each.

Replaces null, undefined and empty values in one column with fixed text or a value worked out from the row.

Summarises every column — how many blanks, how many distinct values, the smallest and largest value and the commonest pattern — as a table with one row per column.

Checks that the columns you expect are there, that their values can be read as the right type, and that columns that must be filled have no blanks — and stops the run (or warns) when they do not.

Checks every row against your rules — required, not-empty, range, regex and in-set. Rows that break a rule leave on the Fail pin with the broken rules written in a reason column; the rest leave on Pass.

Measures the share of blank cells in each column and stops the run (or warns) when any column is blanker than the threshold. The rows pass through unchanged.

Finds values far from the rest of a numeric column — by z-score, by IQR fences or by percentile — and adds a column flagging (or scoring) each row.

Groups values that are spelled alike — Jon and John, Acme Inc and ACME Inc. — and writes each row's group number, or the group's first spelling, into a new column.

Rewrites one column in a standard form: phone numbers as +<country><number>, emails in lower case, names in Proper Case, or addresses with USPS abbreviations.

Groups rows that share their match keys — exactly, or fuzzily — and keeps one survivor per group: the most complete row, the longest, or the first.

Will verify postal addresses against a geocoding service and append latitude and longitude — plus, optionally, the verified address and how well it matched.

Rewrites the values of one column as upper case, lower case or title case.

Joins two or more columns into a single new column with a separator, removing the originals.

Splits one column on a delimiter and adds the parts as new columns named after the original.

Takes characters by position — from a start, the first few or the last few — or pads text to a fixed width, like 123 → 000123.

Finds where a piece of text first appears (its position, 0 when absent), or pulls out the text between two markers such as ( and ).

Splits text into words, lines or n-grams — one row each — or counts the words in a column.

Scores from 0 to 1 how alike a column is to another column — or to one fixed value — with Levenshtein, Jaro-Winkler or Soundex.

Adds the Soundex code of a name — a letter and three digits for how it sounds — so Robert and Rupert both become R163.

Writes one text per row from a template: {Column} placeholders are filled from the row, $Variables from the flow — e.g. a personalised email body for every customer.

Title case that knows names: O'Neil, McDonald and hyphenated parts come out right, small words like of and van stay lower case, and the acronyms you list stay upper case.

CSV-quotes, URL-encodes or HTML-escapes a column — or undoes it — so values survive the trip into a feed, a link or a web page.

Turns JSON held in a column into ordinary columns — every value gets its own column named by its path (customer.city) — or picks out one value by path.

Makes one row per item of a JSON list in a column: an order with three lines becomes three rows, each item's fields as columns.

The reverse of JSON to Rows: writes rows out as JSON — one list of every row, one list per group, or one object on each row — into a column.

Pulls values out of XML held in a column into new columns, one XPath per column — or one row per repeating element such as an order line.

Reads HTML — from a column, or fetched from page URLs in a column — and returns a table as rows, or one row per matching element with its text or attributes.

Splits text into new columns with a regular expression: each capture group becomes a column after the one it reads.

Gives each item of a list held in one cell — "red; large; sale" — its own row, copying the rest of the row onto each.

Splits log lines into fields — IP, time, method, path, status, bytes and more — with a ready-made Apache / Nginx access-log format or your own pattern.

Reads contacts from vCard text, or events from calendar (.ics) text, held in a column: one row per contact or event.

Adds a File Type column — csv, pdf, json, xlsx, … or unknown — to a list of files, from your own name rules, the extension and the file's first bytes.

Rewrites a date, date-time or timestamp column from one format into another; the result is a date, a date-time or a timestamp depending on the To format.

Reads a column of dates that may be written in several formats — Oct 15, 26 in one row, 03/11/2026 in the next — and rewrites them all in one format.

Adds columns holding parts of a date — its year, quarter, month name or number, ISO week, weekday, day, whether it is a weekend, hour or Unix time.

Adds or subtracts days, weeks, months, years or smaller units to a date — a fixed amount or a number from another column — and can round the result down to the start of a period.

Works out how many days, weeks, months, years, hours, minutes or seconds lie between two dates, as a new column.

Converts date-times from one time zone to another — UTC server logs to Berlin time, say — writing the result as YYYY-MM-DD HH:mm:ss.

Declares the inputs a flow runs with — a customer id, an as-of date — and hands them on as one row with a typed column per parameter.

Holds the rows for a set time — up to five minutes — and then passes them on unchanged.

Stops the run with your own message as soon as any row meets a condition — the rows go no further and later steps do not run.

Runs the step before it again when that step fails — a flaky API batch, a database that drops the odd connection — waiting between attempts, then passes its rows on.

Catches a failure of the step before it (or of any step before it) so the run carries on: the rows that step was working on leave by the Error pin, with Failed Step and Error columns; rows from steps that worked leave by OK.

Runs a saved flow once for every file in a folder that matches a pattern, with $file_path and $file_name set for each run, and stacks what the runs produce.

Runs a saved flow once for every row, with the row's values set as $variables and Parameter Input values by column name, and stacks what the runs produce.

Uses a saved flow as a single step: these rows go into its first step (with columns renamed if you say so), and whatever it produces comes back out.

Transforms the rows with your own JavaScript or Python, run in a sandbox with no file, network or process access, a time limit and a memory limit.

Runs a program an administrator approved — a legacy scoring tool, a vendor's converter — on your own computer through the FlowDoo desktop agent, with the rows as CSV on its input, and reads back what it prints.

Starts the flow when another system calls its own web address — an order system POSTing each new order, say — with the call's body as the first rows.

Shows, as one row, what started this run and the schedule that starts the flow: a master schedule that runs it comes first, otherwise the flow's own Schedule settings.

Starts the flow whenever a file arrives (or changes) in a folder — on the server, in My files, in Google Drive, or a folder your computer shares through the desktop agent — with the file's path as $file_path.

Stops the run and asks a person to approve before it carries on — for example before a step that writes to production. Approved, the steps after the gate run with the rows it held; rejected, the run ends there.

Numbers the rows in order and writes the result into a column, with an optional prefix and zero padding.

Makes a series of dates from a start date, one interval at a time, up to an end date or a count you set.

Makes a series of codes: a pattern that counts through letters and digits, or a list of your own values that repeats.

Adds a SQL RANK() column: rows are numbered by the order you choose, tied rows share a number, and the next number skips the ties.

Adds a SQL DENSE_RANK() column: tied rows share a number, and the next number follows on with no gap.

Adds a SQL ROW_NUMBER() counter: every row gets its own number, with no ties, restarting for each partition.

Adds a warehouse surrogate key: a counting number, a pattern you write, or a UUID — a key that belongs to your warehouse rather than to the source system.

Puts the columns of several tables side by side in one wide table, lining rows up by position.

Summarises rows into a pivot table, the way Excel does: fields down the side, fields across the top, and a summary of one column in every cell.

Duplicates each row a fixed number of times, or as many times as a column says.

Puts rows in order by a column — A to Z, Z to A, smallest to largest or the reverse.

Keeps only the first or the last so many rows and drops the rest.

Takes a smaller, representative subset of the rows: a random percentage, a random fixed number, or simply the first or last rows.

Adds the number of rows as a column on every row, and can stop the run when the count is not the one you expect.

Keeps one row per key — or the first few — and drops the other rows that share that key, even when their other columns differ.

Turns columns into rows: each picked column becomes its own row, holding the column's name and its value beside the columns you did not pick.

Turns repeating groups of columns — Phone1, Phone2, Phone3, or Child1Name, Child1Age, Child2Name, Child2Age — into one row per occurrence, numbered.

Runs several calculations per row in one node: each line is Name = formula, and later lines can use what earlier lines worked out.

Adds a column telling a database load what to do with each row: I to insert, U to update, D to delete.

Keeps a dimension table's history: Type 1 overwrites old values with the latest, Type 2 adds a dated version row for every change and marks which version is current.

Changes the type of one or more columns: text to a number, a number to text, text to a date, a date to text, and so on.

Matches rows from its Left and Right inputs on a key column and combines them into one table.

Looks each row up in a reference table by one key and copies the matching columns across — a zip code becomes a city and state, a product code becomes its name and price.

Stacks two tables and keeps each row once, the way SQL UNION does.

Keeps only the rows both tables have, each once, the way SQL INTERSECT does.

Keeps the rows of table A that table B does not have, each once — SQL's MINUS (EXCEPT), or the left-hand crescent of a Venn diagram.

Stacks the rows from all of its inputs into one table without matching or removing anything.

Draws the incoming data as a chart in the preview panel and passes the charted rows on to the next node.

Groups rows by one column and returns a single row per group holding the group value and one aggregate.

Groups rows and works out several summaries at once — total, average, median, distinct count and more — one output column for each.

Counts (or sums, averages…) one field against another: the Rows field's values go down the side, the Columns field's values go across the top.

Adds a statistic for each picked numeric column, in a new column beside the data: a z-score, a percentile rank, a running total or a moving average.

Puts each number into a labelled range — equal-width bins, bins with the same number of rows, or edges you choose such as 0-100, 100-500, 500+.

Groups rows into k clusters of similar values across the numeric columns you pick, and writes each row's cluster number (1…k) in a new column.

Fits a least-squares line that predicts a number from one or more other columns, and adds the prediction to every row — including rows where the value to predict is blank.

Fits a logistic model that gives the probability of a yes/no outcome from other columns, plus a 1/0 prediction at the threshold you choose.

Grows a CART decision tree that predicts a class (Gini) or a number (variance) from other columns, and writes the prediction and the readable rule behind it.

Sends a random share of the rows out of the Test pin and the rest out of Train, reproducibly from a seed, and labels each row in a Split column.

Applies a model made by Linear Regression, Logistic Regression or Decision Tree to new rows, writing the prediction (or probability, or class) in a new column.

Measures how strongly each pair of the picked numeric columns moves together, from −1 to 1, as a matrix with one row per column.

Projects a dated measure forward — the next weeks, months or quarters — with Holt-Winters (level, trend, season) or a seasonal naive forecast.

Scores each row's value against the rest (z-score or IQR) and routes unusual rows to the Alert pin and the others to Normal, with an optional quiet period after each alert.

Reduces many numeric columns to a few principal components — new columns PC1, PC2… that keep as much of the variation as possible.

Scores text from −1 (negative) to 1 (positive) with a built-in English word list, and labels it Positive, Neutral or Negative.

Pulls people, organisations, money amounts and dates (and optionally email addresses and phone numbers) out of text by pattern, one column per kind.

Adds the great-circle (haversine) distance between each row's coordinates and a fixed point, or a second pair of coordinate columns, in km, miles, metres or nautical miles.

Turns each row's coordinates into a place: the full label, street, city, postcode and country, from OpenStreetMap data (Nominatim or Photon).

Runs a SQL statement over the incoming data using an in-memory SQLite engine and returns the result as the node's rows.

Runs a branch of the pipeline once for every incoming row.

Holds a single value that other nodes can reference as $Name.

Routes each row by ordered rules: the first rule whose conditions the row meets sends it to its pin, Match or Default; rows no rule matches go to Default.

Splits rows in two on conditions: rows that meet them leave on the True pin, the rest on the False pin. Both streams carry on in the flow.

Loads a Word (.docx) template and lists the <<tag>> placeholders it holds — in the body, headers and footers — one row per tag.

Fills the template's <<tags>> with each data row's values and makes one Word document per row.

Renders the Word documents on its rows — usually Template Merge output — as PDFs with the page size, orientation, margins and image compression you choose.

Reads tabular data out of PDF files using either the built-in pdf.js engine or Tabula, and turns the detected tables into rows.

Converts the selected pages of each incoming PDF to greyscale and writes a new file for the rows to carry on.

Extracts the text of each upstream PDF and returns one row per page.

Combines the PDF on its Top input with the PDF on its Bottom input into one file per bottom document.

Splits each PDF into parts — every N pages, by page ranges such as 1-3; 4-10, or one part per top-level bookmark — one row per part.

Turns pages of each PDF 90°, 180° or 270° clockwise, on top of any rotation they already have.

Stamps large diagonal text — CONFIDENTIAL, DRAFT — or an image across the middle of each page, at the opacity you choose.

Stamps page numbers on each page — Page 3 of 120, or your own format with {n} and {total} — in the corner or centre you choose.

Makes PDFs smaller without touching how they look: objects are repacked into compressed streams, raw streams are compressed and unused objects dropped; High also removes metadata and thumbnails.

Password-protects each PDF with AES-256, and can limit what readers may do — print only, or only view.

Removes the password from protected PDFs — RC4 and AES, 40 to 256-bit — given the user or the owner password, so other PDF nodes can read them.

Fills a PDF form's fields from each row — text boxes, tick boxes, drop-downs and radio buttons — making one filled-in PDF per row.

Makes scanned PDFs searchable: each page is read with English text recognition and the words are laid over the page as invisible text, so it looks the same but can be searched, selected and extracted. The text also comes out in an OCR Text column.

Saves the pictures inside each PDF as their own files — one row per image with its page, size and path.

Writes the incoming rows into an existing SQL Server table and passes the same rows on to the next node.

Writes the incoming rows into an existing MySQL table and passes the same rows on to the next node.

Writes the incoming rows to a tab of a Google spreadsheet and passes the same rows on to the next node.

Inserts, updates, upserts or deletes Salesforce records, one per incoming row, and passes the rows on with the outcome of each: its Salesforce Id, Created/Updated/Deleted or Error, and the error message.

Sends the incoming rows to a VizzDoo project as a dataset with the name you give it, ready to use in a worksheet or dashboard, and passes the same rows on to the next node.

Writes the incoming rows to a .csv file in a folder you choose and passes the rows on unchanged.

Writes the incoming rows to a .json file in a folder you choose and passes the rows on unchanged.

Writes the incoming rows to an Excel .xlsx file in a folder you choose and passes the rows on unchanged.

Writes the incoming rows to a delimited .txt file in a folder you choose and passes the rows on unchanged.

Saves the PDFs produced upstream into a folder you choose, or renders the incoming rows as a PDF table when there are no PDFs.

Converts each .docx file coming from an upstream node into a PDF and adds the result's path and page count to the row.

Adds a title block — title, subtitle and a Generated line — as an HTML section that HTML Report and Email Send put at the top of the report.

Closes a report with totals of the columns you pick and a closing line, as an HTML section HTML Report puts at the bottom.

Lays the rows out as a styled HTML table — striped, compact or with grid lines — split into pages wherever Page Break says, ready for HTML Report or an email body.

Formats a column for reading — currency ($1,234.50), percent (12.50%), number (1,234.50) or date (15 Oct 2026) — in place or into a new column.

Shows a picture per row in an HTML report, from an https:// image address or a Base64 PNG, JPEG, GIF or WebP.

Starts a new report page whenever a column's value changes — a page per region — or every N rows, with the value as the page's heading.

Turns a column into QR codes, Code 128 or EAN-13 barcodes, as pictures in an HTML report — no outside service involved.

Assembles the report sections — headers, tables, footers — into one self-contained .html file and saves it to a folder; with no sections it lays the rows out as a table itself.

Sends the rows to an API or webhook as JSON — in batches as arrays, or one request per row — with bearer, basic or custom-header authentication.

Sends an email from your own email account — HTML or plain text, with attachments and your signature — as the last step of a flow.

Raises an alert with a severity — into the run's own log and preview, and optionally by email or to a Slack, Teams or other chat webhook — then passes the rows on.

Writes the rows that reach it into an existing PostgreSQL table, in one transaction, and passes them on unchanged.

Writes the rows that reach it into an existing Azure SQL table, in one transaction, and passes them on unchanged.

Writes the rows into an existing Oracle table — append, replace, or upsert on key columns — in one transaction, and passes them on.

Writes the rows as documents to a MongoDB collection: insert, replace the collection, or upsert by key columns.

Loads the rows into a Snowflake table — append, replace or upsert on key columns — in one transaction.

Appends the rows to an existing BigQuery table with streaming inserts.

Publishes the rows as one file (CSV, JSON, Excel or TXT, by the key's extension) in an S3-compatible bucket — or uploads the files a path column names.

Delivers the rows as a file — or the files a path column names — to an FTP, FTPS or SFTP server.

Files the rows as a document (CSV, JSON, Excel or TXT, by the name's extension) — or the files a path column names — in a SharePoint library folder.

Writes the rows that reach it into an existing Databricks (Delta) table, and passes them on unchanged.

Writes the rows that reach it into an existing IBM DB2 table, in one transaction, and passes them on unchanged.

Writes the rows that reach it into an existing Teradata table, in one transaction, and passes them on unchanged.

Writes the rows that reach it into an existing table of any database with a JDBC driver, in one transaction, and passes them on.

Writes the rows that reach it into an existing table through ODBC, in one transaction, and passes them on unchanged.

Saves the rows as a file (CSV, JSON, Excel or TXT, by the name's extension) — or the files a path column names — in a Dropbox folder.

Sends each row to a GA4 property as an event through the Measurement Protocol — the other columns become its parameters.

Creates records in a ServiceNow table, or — Upsert — updates the records whose key fields match and creates the rest, then passes the rows on.

Creates records in a Dynamics 365 CRM (Dataverse) table, or — Upsert — updates the records whose key columns match and creates the rest, then passes the rows on.

Makes every database write upstream of it one transaction: committed together when all of those steps worked, rolled back together otherwise.

Records what every step before it did to the data — rows in and out, columns added and removed, settings, timings and errors — as a table, and optionally as a .fdlog or .html report. It has two outputs: Success when every step before it worked, Failure when any of them failed.

Places a resizable, coloured note on the canvas to explain part of a pipeline.

Brings unstructured text into a flow — typed or pasted straight into the node, or read from a text, Markdown, log, HTML, Word or PDF file on your computer, in My files, on the server or in Google Drive.

Writes the text column to a file — every row into one file, or one file per row named after the file it came from.

Turn text that is broken into short lines into smooth sentences, while keeping your paragraphs if you want to.

Replace runs of spaces and tabs with a single space and trim the start and end of every line.

Keep only the first copy of each line in a list, without changing the order of what remains.

Remove symbols, emoji and other special characters so that only letters, numbers and spaces remain.

Remove every digit from your text, with optional clean-up of the gaps left behind.

Delete every blank line, including lines that only contain spaces or tabs.

Turn HTML code into readable plain text, with line breaks where paragraphs and list items were.

Remove spaces and tabs from the beginning and end of each line, while leaving the spacing inside lines alone.

Make text safe for older systems by keeping only the 128 basic ASCII characters.

Delete punctuation marks from your text while keeping letters, numbers, symbols and spacing.

Get an instant count of words, characters, sentences and paragraphs, plus estimated reading and speaking time.

See exactly how many characters your text has, with a breakdown of letters, digits, spaces and symbols.

Count your sentences and see how long they are on average, a quick check for readable writing.

Count the paragraphs in your writing and check how long each one tends to be.

List every word that appears more than once, sorted from most to least frequent.

Find the words you use most and see what share of your text each one makes up.

Turn every letter in your text into a capital letter.

Change every capital letter in your text to lowercase.

Capitalise the important words in a heading while keeping short words such as “and”, “of” and “the” in lowercase.

Switch between lowercase and uppercase letter by letter to create aLtErNaTiNg cAsE text.

Pull every email address out of a block of text and get a clean list with duplicates removed.

Find every web address in your text and list each unique link on its own line.

Pull every number out of your text and list them one per line, ready for a spreadsheet.

Write any text backwards, from the last character to the first.

Keep each word readable but put the words on every line in reverse order.

Put every line of your list into alphabetical order from A to Z.

Put every line of your list into reverse alphabetical order, from Z to A.

Repeat each line of your text a chosen number of times, keeping the copies next to the original.

Replace every occurrence of a word, phrase or pattern in one go.

Repeat a word, emoji or block of text as many times as you need.

Generate random strings with the length and characters you choose.

Put the lines of your list into a random order with a fair shuffle.

Convert text into percent-encoded form so it can be used safely inside a web address.

Convert percent-encoded text back into normal, readable characters.

Encode text as Base64, the standard way to carry data through systems that only accept plain characters.

Turn a Base64 string back into the original text.

Convert characters that have a special meaning in HTML into entities, so text displays exactly as written.

Turn HTML entities back into the characters they represent.

See how your text is stored by a computer, as a series of eight-bit bytes.

Decode binary bytes back into letters, numbers and symbols.

Apply the ROT13 letter substitution. Run it again to get the original text back.

Show the numeric code of each character in your text, in decimal or hexadecimal.

Translate a list of character codes back into readable text.

Convert page titles into short, readable URL slugs such as my-first-blog-post.

Make JSON readable with consistent indentation, and find out straight away if it is invalid.

Compress JSON onto a single line by removing all unnecessary whitespace.

Put a number in front of every line of your text.

Join the lines of a list into one line, separated by commas or any separator you choose.

Split comma separated text into a tidy list with one item per line.

Break long lines so that none is longer than the width you choose.

Reads audio files — .wav, .mp3, .flac, .ogg, .m4a and more — one row per file, with each file's format, sample rate, channels, bit depth, duration and size.

Records a clip from your browser's microphone (Web Audio) and hands it to the flow as an audio file.

Captures a window of a live stream — RTSP cameras and intercoms, HTTP or Icecast radio, HLS (.m3u8) — and hands it on as one clip.

Starts the flow when a new audio file arrives in a folder — on the server, in My files, Google Drive or a computer — or picks up what arrived in an S3 bucket since the last run.

Converts every clip to one sample rate with a band-limited (windowed-sinc) filter, so lowering the rate never folds high frequencies back as noise.

Mixes multi-channel audio down to one channel (the average, or just the left or right) — or to stereo, folding 5.1 down with the standard weights.

Finds where someone is speaking (or where there is loud sound) and drops the silence and background noise: one row and clip per segment, one clip per file with the gaps cut out, or just the list of segments.

Cuts each clip into fixed-length windows — overlapping if you like — one row and clip per window, the last one padded with silence to full length (or kept short, or dropped).

Brings every clip to the same level: its peak to a target (e.g. -1 dBFS), its average loudness (RMS) to a target, or a fixed gain — never clipping, and never raising near-silence into loud noise.

Turns each clip into a log-mel spectrogram — frequency bands over time, in dB — saved as a NumPy matrix (.npy) and as an image (.png) for image models such as CNNs.

Mel-frequency cepstral coefficients: a compact, low-dimensional description of each clip's timbre — summarised as the mean and spread of each coefficient, or one row per frame.

Runs each clip through a foundation model — Wav2Vec 2.0 for speech, CLAP for sounds and music — and returns one dense vector (768 or 512 numbers) per clip.

Names the sounds in each clip — glass breaking, dog barking, siren, engine knocking, speech, music — with the 527 AudioSet labels of the Audio Spectrogram Transformer, and a score for each.

Transcribes speech to text with OpenAI's Whisper (or another Hugging Face speech model): one transcript per clip, or one row per segment or word with its start and end time.

Works out who spoke when: one row per speaker turn (Speaker 1, Speaker 2…) with its start and end — or tags incoming rows, such as ASR segments, with the speaker talking at that moment.

Compares each clip's voiceprint with enrolled reference voices to name the speaker (or say Unknown), or to verify that it is the person a column claims.

Music information retrieval for each track: tempo (BPM), musical key, genre, mood, and emotional valence (sad…happy) and arousal (calm…energetic) on a -1 to 1 scale.

Saves each processed clip — resampled, trimmed, sliced or normalised — as WAV (16, 24 or 32-bit float), FLAC, MP3 or Ogg, on the server, in My files, Google Drive or a folder on a computer.

Brings the results back together: one row per original file, with that file's original details (format, sample rate, channels, bit depth, duration) and the extracted columns combined — text joined, numbers averaged — ready as JSON or CSV.