Txtly

Text Tools Guide

Power Text Tools Guide

Getting Started β€” start using Text Tools in 5 minutes
API & Scripts β€” API documentation | creating scripts

UI Overview

Basic Operations

Interface Structure

The interface uses a single editor zone where text is entered, processed, and results are displayed:

  • Editor β€” a single field for text input, uploading files, and viewing operation results
  • Toolbar β€” operation categories and action buttons (Find & Replace, Scripts)
  • Undo/Redo β€” step back and forth through your operation history (Ctrl+Z / Ctrl+Shift+Z)
  • Footer β€” statistics (lines, words, characters) and undo/redo history depth

Function Categories (Tabs)

At the top of the interface are tool categories:

  • `Text Processing` β€” main category containing basic operations
  • `Text Formatting`
  • `Text Cleaning`
  • `Case Conversion`
  • `JSON Operations`
  • `YAML Operations`
  • `Encoding/Decoding`
  • `Generators`
  • `Sorting and Filtering`
  • `Data Extraction`

Each category contains specialized function buttons (e.g., "Replace Quotes", "Split Lines", etc.).

Common Functions

Find and Replace

  • Available via the "Find and Replace" button in the toolbar
  • Allows searching and replacing text by pattern (possibly with regex support β€” not shown but assumed)

Scripts

  • Available via the "Scripts" button in the toolbar
  • Allow executing custom operations on text (see section 2)

Selected Text Operations

  • In the "Editor" zone there is a checkbox:

    Selected text only

  • When checked, all operations (including scripts) apply only to the selected text fragment, not to the entire editor field content

Data Management

File Upload

  • "Upload" button β€” allows loading text from file (supports text formats: `.txt`, `.csv`, `.log`, etc.)

Clear

  • "Clear" β€” removes all text from the editor and resets the undo/redo history

Copy Output

  • "Copy" button in the editor header β€” copies text to clipboard

Using Scripts

Running a Script

  • Click the "Scripts" button in the toolbar
  • A modal window with available scripts list opens
  • Select the required script and click the arrow β†’ to run

Script Information

In the scripts list, the following is displayed:

  • Name
  • Type: `custom` β€” user script
  • Creation date: e.g., `07.01.2026`
  • Version: `v1`, `v2`, etc.
  • Size: number of characters in code (`285 chars`, `1215 chars`)

Adding New Scripts

Opening Script Manager

  • In the "Scripts" window, click "Script Management" (gear icon)
  • A management panel opens with all scripts list

Creating a New Script

  • Click the "+ Create Script" button

  • An editing form opens:

    • Script name β€” required field

    • Description (optional) β€” add explanations

    • Custom tags β€” for grouping/searching

    • Script code β€” required field. Hint:

      // Write your script here
// Use "input" as input text
// Set "output" as result

Scripts are written in JavaScript. The `input` variable contains source text, the `output` variable must be set as result.

Important: The `output` variable is pre‑defined by the system. Do not re‑declare it (e.g., with `let`, `const`, or `var`), as this will cause the script to fail. Simply assign the result to `output`.

  • After writing, click "Save"

Managing Existing Scripts

In "Script Management" mode, the following actions are available for each script:

  • Edit β€” modify name, description, or code
  • Export β€” save script to file (possibly in JSON or .js format)
  • Delete β€” delete script

Global actions are also available:

  • Export all scripts β€” download all user scripts
  • Import scripts β€” load previously exported scripts
  • Delete all custom scripts β€” mass deletion

Text Tools – Navigation & Finding Operations

How to Use Navigation

All operations are grouped into categories. You can navigate using the sidebar or directly access a category using its dedicated URL:

Categories Overview

This guide lists the main categories available in Text Tools and highlights key operations within each. For the full list of operations, visit the tool and select the desired category.

  • Text Processing: Change and prepare raw text. Includes operations like converting tabs to spaces, normalizing line endings, replacing quotes, converting number systems, joining and splitting lines.
  • Formatting: Adjust the structure and presentation of text, often related to delimiters or markup. Includes operations like word wrap, formatting as tables (CSV, Markdown), converting HTML to text/Markdown, adding commas to numbers, counting string occurrences, and adding line numbers.
  • Text Clear: Basic cleaning and sanitization of text. Includes removing HTML tags, emojis, diacritics, empty lines, duplicates, control characters, extra spaces, cleaning LLM output, and "Find and Replace".
  • Text Case: Transform the capitalization and character representation of text. Includes operations like converting to uppercase/lowercase, title case, sentence case, camelCase, kebab-case, creating slugs, reversing text, and normalizing Unicode.
  • JSON Operations: Manipulate JSON data, including formatting, minifying, extracting values, converting to/from other formats (CSV, XML, YAML, TOML) and validating JSON syntax.
  • YAML Operations: Work with YAML data. Includes validating YAML syntax, converting YAML to JSON with configurable indentation, and formatting YAML for consistent output.
  • Encoding/Decoding: Encode or decode text using common schemes. Includes operations like URL encoding/decoding, HTML entity encoding/decoding, Base64 encoding/decoding, and JWT decoding/validation.
  • Generators: Create new text content or add generated elements. Includes operations like generating Lorem Ipsum, random numbers, sequences, timestamps, UUIDs, and password hashes.
  • Sort & Filter: Organize text lines or data based on specific criteria. Includes operations like shuffling lines, selecting random lines, sorting lines alphabetically, numerically, by length, or by word count.
  • Data Extraction: Identify and pull out specific pieces of information from text. Includes operations like extracting phone numbers, emails, IP addresses, URLs, code blocks, specific regex patterns, and comparing texts for differences.

Practical Regex Usage

Regex-Based Replacement

The Find and Replace operation with regex support allows for complex text transformations.

Practical Example: Changing date format from "31.12.2023" to "2023-12-31"

Find: (\d{2})\.(\d{2})\.(\d{4})
Replace with: $3-$2-$1

Another Example: Extracting email addresses from text

Find: .*?([\w.-]+@[\w.-]+\.\w+).*?
Replace with: $1\n

Splitting Text with Regex

The Split Lines operation allows using regular expressions as delimiters.

Practical Example: Splitting text on various punctuation marks

Delimiter: [.,;!?]+
Text: "Hello,world!How are you?"
Result: ["Hello", "world", "How are you"]

Example for CSV data: Splitting with quoted values

Delimiter: ,(?=(?:[^"]*"[^"]*")*[^"]*$)

Validating Text with Regex

Use the Extract with regex operation to check if text matches a specific pattern.

Practical Validation Examples:

  1. Email validation:
Pattern: ^[\w.-]+@[\w.-]+\.[a-zA-Z]{2,}$
  1. Phone number validation (Russia):
Pattern: ^\+7\s?\(?\d{3}\)?[\s-]?\d{3}[\s-]?\d{2}[\s-]?\d{2}$
  1. Password validation (min 8 chars, letters and digits):
Pattern: ^(?=.*[A-Za-z])(?=.*\d)[A-Za-z\d@$!%*#?&]{8,}$

Grouping and Backreferences in Replacement

Regular expressions support grouping with parentheses `( )` and backreferences `$1`, `$2`, `$3`, etc. in the replacement string.

Practical Examples:

  1. Formatting full names: "Ivanov Ivan Petrovich" β†’ "I.I. Petrovich"
Find: ^(\w+)\s+(\w)\w*\s+(\w+)$
Replace with: $2.$1. $3
  1. Swapping date and time in logs:
Find: (\d{4}-\d{2}-\d{2}) (\d{2}:\d{2}:\d{2})
Replace with: [$2] $1
  1. Extracting domain from URL:
Find: https?://(?:www\.)?([^/]+)
Replace with: Domain: $1

Special Features and Escape Sequences

The replacement string supports the following escape sequences:

Sequence Result
`\n` New line
`\t` Tab
`\r` Carriage return
`\f` Form feed
`\v` Vertical tab
`\\` Backslash

Example: Creating a Markdown list from plain lines

Find: ^(.+)$
Replace with: - $1\n

Regex Cheatsheet Reference

For a deeper dive into regular expressions, refer to the Power Text Tools docs, which includes:

  • Complete regex syntax reference
  • Ready-made patterns for common tasks
  • Usage examples for different professions
  • Solutions for frequent issues and errors

Refer to the Power Text Tools documentation for a deeper dive into regular expressions.

Detailed Category Descriptions

Text Processing (`?category=text-processing`)

Focuses on changing, transforming, and preparing raw text.

  • Count Statistics: Provides counts for lines, words, characters, sentences, and paragraphs.
  • Keep Only Duplicates: Filters the text to show only lines that are duplicated elsewhere.
  • Split Lines: Splits the input text into individual lines based on a delimiter.
  • Replace Quotes: Converts various types of quotation marks (smart quotes, angle quotes, etc.) to a specified type.
  • Tabs to Spaces: Converts tab characters (`\t`) into a specified number of spaces.
  • Spaces to Tabs: Converts sequences of spaces into a single tab character.
  • Pad String: Adds padding (spaces or other characters) to the beginning or end of each line.
  • Convert Number System: Converts numbers within the text between different bases (e.g., decimal to hexadecimal).
  • Join Lines: Combines all lines into a single line, separated by a specified character.
  • Find and Replace: Searches for a specified string or pattern and replaces it with another string.

Formatting (`?category=formatting`)

Adjusts the presentation, structure, or markup of text, often related to tables, lists, or specific delimiters.

  • Add Commas to Numbers: Adds thousands separators (commas) to numbers in the text.
  • Count String Occurrences: Counts how many times each unique string appears in the text.
  • HTML to Markdown: Converts HTML content into Markdown syntax.
  • HTML to Text: Extracts the plain text content from an HTML string, removing all tags.
  • Add Line Numbers: Prepends line numbers to each line of the text.
  • Word Wrap: Inserts line breaks after a specified number of characters or at the next space before that limit.
  • Center Align: Centers each line of text by adding appropriate leading spaces.
  • CSV to Markdown: Converts a CSV-formatted string into a Markdown table structure.
  • Format as Table: Formats selected text into a table structure (e.g., Markdown, CSV).
  • Wrap Lines: Wraps text at a specific column width.
  • Find and Replace: Searches for a specified string or pattern and replaces it with another string.

Text Clear (`?category=clear`)

Focuses on basic cleaning and sanitization of text content.

  • Strip HTML Tags: Removes all HTML tags from the input, leaving only plain text.
  • Remove Emojis: Strips all emoji characters from the text.
  • Remove Diacritics: Removes diacritical marks (accents) from characters (e.g., Γ© -> e).
  • Remove Empty Lines: Deletes lines that contain only whitespace or are completely empty.
  • Remove Duplicate Lines: Removes lines that are exact duplicates of other lines in the text.
  • Remove Adjacent Duplicates: Removes duplicate lines only if they occur consecutively.
  • Remove Control Characters: Strips non-printable control characters from the text.
  • Remove Extra Spaces: Collapses multiple consecutive spaces into a single space and trims leading/trailing whitespace.
  • Clean LLM Output: Attempts to remove common artifacts like introductory phrases or trailing comments often found in Large Language Model outputs.
  • Find and Replace: Searches for a specified string or pattern and replaces it with another string.

Text Case (`?category=case`)

Applies various capitalization and character format transformations.

  • Create Slug: Converts text into a URL-friendly slug (e.g., "Hello World!" becomes "hello-world").
  • Reverse Text: Reverses the order of characters in the entire text.
  • Uppercase: Converts all letters to uppercase.
  • Lowercase: Converts all letters to lowercase.
  • Title Case: Capitalizes the first letter of each word.
  • Sentence Case: Capitalizes the first letter of each sentence.
  • Change Text Case: Offers various options for changing the case of the text.
  • Normalize Unicode: Normalizes Unicode characters to a standard form.
  • Find and Replace: Searches for a specified string or pattern and replaces it with another string.

JSON Operations (`?category=json`)

Provides tools for parsing, formatting, and transforming JSON data.

  • Extract JSON: Attempts to find and extract JSON objects or arrays from the text.
  • Escape JSON: Escapes special characters in a string so it can be safely included in a JSON string.
  • Unescape JSON: Unescapes a JSON-escaped string.
  • Validate JSON: Checks if the input string is valid JSON syntax.
  • Convert JSON to YAML: Transforms a JSON object/array into a YAML structure.
  • Convert JSON to CSV: Transforms a JSON array into a CSV format.
  • Convert JSON to XML: Transforms a JSON object/array into an XML structure.
  • Convert JSON to TOML: Transforms a JSON object/array into a TOML structure.
  • Format JSON: Pretty-prints JSON data with indentation for readability.
  • Minify JSON: Removes all unnecessary whitespace from JSON data, making it compact.
  • JSONPath Query: Uses a JSONPath expression to extract specific values from the JSON structure.
  • Find and Replace: Searches for a specified string or pattern and replaces it with another string.

YAML Operations (`?category=yaml`)

Provides tools for parsing, validating, and converting YAML data.

  • Validate YAML: Checks if the input string is valid YAML syntax.
  • YAML to JSON: Converts YAML content into formatted JSON with configurable indentation.
  • Format YAML: Parses and re-serializes YAML for consistent formatting and readability.
  • Find and Replace: Searches for a specified string or pattern and replaces it with another string.

Encoding/Decoding (`?category=encoding`)

Handles common text encoding and decoding schemes.

  • Normalize Unicode: Normalizes Unicode characters to a standard form.
  • Base64 Encode: Encodes the input string using Base64.
  • Base64 Decode: Decodes a Base64 encoded string.
  • URL Encode: Encodes special characters in a string for safe use in URLs.
  • URL Decode: Decodes URL-encoded strings back to their original form.
  • HTML Encode: Converts special characters to their corresponding HTML entities.
  • HTML Decode: Converts HTML entities back to their corresponding characters.
  • Decode JWT: Decodes a JWT (JSON Web Token) header and payload without verifying the signature.
  • Validate JWT: Validates the structure and signature of a JWT token.
  • Encode/Decode: Generic operation for encoding or decoding text.
  • Find and Replace: Searches for a specified string or pattern and replaces it with another string.

Generators (`?category=generator`)

Creates new text content or adds generated elements to existing text.

  • Generate Number Sequence: Inserts a sequence of numbers (e.g., 1, 2, 3...) into the text.
  • Generate GUID: Creates a random GUID (Globally Unique Identifier).
  • Generate Password: Generates a secure password based on specified criteria (length, character types).
  • Generate Numbers: Creates a list of random numbers.
  • Generate Timestamp: Adds the current date and time.
  • Find and Replace: Searches for a specified string or pattern and replaces it with another string.

Sort & Filter (`?category=sort`)

Organizes text lines or data based on defined rules.

  • Shuffle Lines: Randomly rearranges the order of the lines.
  • Select Random Lines: Randomly selects a specified number of lines from the input.
  • Sort Lines: Sorts lines alphabetically, numerically, by length, by word count, or using other methods (ascending or descending).
  • Find and Replace: Searches for a specified string or pattern and replaces it with another string.

Data Extraction (`?category=extract`)

Identifies and extracts specific types of data from the input text.

  • Extract Emails: Finds and lists email addresses.
  • Extract URLs: Finds and lists web URLs.
  • Extract Hashtags: Finds and lists hashtags (e.g., #example).
  • Extract Phone Numbers: Finds and lists phone numbers matching common patterns.
  • Extract IP Addresses: Finds and lists IPv4 and IPv6 addresses.
  • Extract Dates: Finds and lists dates.
  • Extract Numbers: Finds and lists numerical values.
  • Extract MAC Addresses: Finds and lists MAC addresses.
  • Extract Markdown Links: Finds and lists links formatted in Markdown syntax.
  • Extract Mentions: Finds and lists mentions (e.g., @username).
  • Extract with Regex: Uses a custom regular expression pattern to find and extract matching substrings.
  • Find and Replace: Searches for a specified string or pattern and replaces it with another string.

Tips

  • Check related categories: Some operations might fit well into multiple categories.
  • Break complex tasks into steps: Combine operations from different categories sequentially β€” each operation is added to the undo history.
  • Use Undo/Redo to compare: Step back and forth (Ctrl+Z / Ctrl+Shift+Z) to quickly compare the before and after of any operation.
  • Search by keyword: Try searching for specific terms in the tool's search bar.
  • Check the docs: More detailed guides and examples are available in the main documentation.
  • Use regex effectively: For complex transformations, study the find and replace operations which cover all regex capabilities.
  • Test regex step by step: Start with simple patterns and gradually make them more complex.
  • Keep the original text: Always save a copy of the original text before performing complex replacements.
  • Use capture groups for complex transformations: `$1`, `$2`, `$3` allow you to rearrange parts of the text during replacement.