Data Format

Generate repeatable synthetic test records from a field recipe and seed, with format-aware output and checks for blanks or normalized fields.

Generate a static Ansible INI or YAML inventory from host rows and groups with checks for value typing, duplicate variables, and secrets.

Compare released and proposed Avro schemas locally, find writer-reader blockers, and review compatibility before a registry release.

Convert one integer from binary or other common bases, then inspect Base36 output plus exact signed-width and bit-field interpretations.

Compare two CSV or TSV exports by selected keys and review schema and record changes, including duplicate keys and rejected rows, without uploading data.

Validate CSV or TSV imports against column types and required values, including ranges and uniqueness, with safe pattern checks and row-level findings.

Convert CSV-like text into structured formats, review row alignment and column completeness, and keep sensitive source data in your browser.

Convert one DOCX locally into portable web or document formats, with structure checks and controls for embedded images and review notes.

Turn reviewed HTML, Markdown, or plain text into an editable DOCX that preserves safe structure and clearly warns about unsupported content.

Convert ENV text into common configuration formats with controlled expansion, duplicate-key handling and secret-like value checks before deployment.

Compare required environment variables with ENV, JSON, or YAML inventories and find missing, blank, placeholder, duplicate, or extra entries.

Convert epoch seconds, milliseconds, or a wall-clock date into UTC and selected-zone timestamps with explicit offset and precision rules.

Turn XML into structured JSON or record-based tables with local parsing, record-path selection, whitespace controls, and schema checks.

Turn images and text sources into local PDF output while preflighting Office files for renderer needs, layout risks and fidelity limits.

Generate Go structs from representative JSON or one PostgreSQL or MySQL table definition, with explicit field mappings and review notes.

Format GraphQL operations and schema SDL locally, with readable or compact output, definition inventory and lexical checks for review.

Convert Terraform-style HCL into JSON or flat configuration text, with path and type checks that expose lossy handoffs before reuse.

Compare two HTML documents or fragments as parsed DOM trees and review path-level changes with explicit whitespace and attribute rules.

Check pasted or local HTML in document or fragment mode with line-aware findings and strict review signals without executing code in your browser.

Turn HTML or SVG into reviewable JSX with local parsing, React attribute mapping, style policies, and warnings for copied event code.

Validate values.yaml against values.schema.json, separate blocking schema errors from hygiene warnings, and inspect root-key coverage before CI.

Convert INI or CFG into structured or flat configuration text with explicit duplicate handling, type inference, and skipped-line review.

Turn an image into Base64 or a Data URI in your browser, preserve the original bytes or optimize the image, and judge whether inline use fits.

Convert JSON or JSON Lines into tables and handoff text with record-path selection, flattening controls and warnings for sparse or risky data.

Compare JSON as parsed structures with configurable array matching and ignored paths, then review exact changes through path and patch evidence.

Format JSON for review or transport, inspect its structure and byte size, and flag duplicate keys or precision risks before reuse.

Turn malformed JSON-like text into strict JSON locally, with selectable repair modes and clear warnings for inferred changes and data risks.

Compare released and proposed JSON Schemas to find contract-breaking validation and reference changes before clients or stored data are affected.

Turn sample JSON into a draft-aware JSON Schema with explicit inference choices and review warnings for assumptions that need broader test data.

Sort JSON and clean JSONC in your browser with repeatable key rules, duplicate-name warnings, and optional record-array ordering.

Validate strict or human-friendly JSON locally, catch syntax and interchange risks, and produce a reviewable strict JSON artifact for handoff.

Turn JSON or JSON Lines into spreadsheet-ready CSV or TSV with controlled record selection, nested-value shaping and formula-risk warnings.

Turn representative JSON into reviewable Dart model classes with configurable null safety, exact key mappings and actionable inference warnings.

Turn JSON or JSON Lines samples into TypeScript declarations with configurable null and optional-property policies plus array inference and runtime guards.

Generate page-matched JSON-LD for common article, product, organization and FAQ pages with a property audit and copy-ready script tag.

Test JSONPath expressions on local JSON, inspect matched values with paths and pointers, and distinguish empty results from syntax errors.

Convert INI, Java properties, and dotenv text into reviewable structured or line-based configuration with path and duplicate checks.

Turn delimited rows into LaTeX table source with quoted-field parsing, special-character escaping, and warnings for uneven data.

Turn delimited text into clean Markdown tables with automatic header and alignment choices plus parsing warnings for ambiguous or uneven rows.

Edit and preview MathML locally with native notation menus, complete markup checks, source and image exports, and supported LaTeX or AsciiMath conversions.

Compress one local file into a compatible archive or stream and review size change with split delivery plus SHA-256 integrity before downloading.

Convert a PDF locally into editable text or page-faithful images with page-range checks, document handoffs and no source-file upload.

Split a PEM bundle into complete certificates, requests, and keys while preserving line spans and adding SHA-256 evidence through local file handling.

Decode PHP serialized data into a local typed tree with byte offsets, reference checks, and binary-safe display without object instantiation.

Convert Java properties into structured or line-based configuration with decoded escapes, scalar handling, and clear duplicate-key checks.

Rewrap an existing RSA key for PKCS#1, PKCS#8 or SPKI consumers with optional encrypted output and local public-identity checks.

Validate RSS 2.0 or Atom 1.0 XML locally with format detection and line-aware errors plus empty-feed warnings and clear repair guidance.

Convert SSH public keys among OpenSSH, SSH2 and PEM locally while verifying key identity through matching SHA-256 fingerprints and safety checks.

Extract a supported SSH public key locally, verify its SHA-256 fingerprint, and assemble a reviewed authorized_keys entry from key material.

Convert PEM/DER/P7B/PFX certificates in your browser and inspect chain expiry plus private-key requirements before downloading.

Decode X.509 certificate text or files locally and review validity, DNS coverage and key details alongside fingerprints and chain entries.

Convert foot length or a regional shoe label into cross-system sizes with adjustable allowance, retail rounding, and fit-drift guidance.

Extract page and child-sitemap URLs from XML, text files or a public source and produce a normalized crawl list with row-level audit evidence.

Turn same-host URLs or paths into sitemap XML with normalization and exclusion checks, then review protocol limits before publishing.

Convert TOML into structured or flat configuration text with parse checks and warnings when the target cannot preserve types or nesting.

Convert TSV and delimiter-separated text into typed table formats with local processing plus clear header, row-width and column-profile checks.

Convert pasted or local table data into clean documents with repaired headers and row previews while checking missing cells and spreadsheet formulas.

Re-encode a local text file as UTF-8, UTF-16, or Windows-1252 with BOM and line-ending controls plus recorded replacement details.

Convert measurements across 21 categories with auditable base-unit formulas, flexible precision, and checks for temperature and fuel economy.

Convert a legacy XLS workbook to XLSX in your browser with structural verification and clear warnings about formulas, macros and visual fidelity.

Convert one Excel worksheet to CSV in your browser, choose formula and hidden-data handling, and review warnings before download.

Compare XML as parsed structure with keyed or positional node matching, namespace and whitespace policies, and exact path-level change evidence.

Validate XML against a supplied XSD 1.0 Core schema with namespace-aware findings and blocked external resource resolution in your browser.

Test XPath against XML or HTML in your browser, verify namespaces and result types, and inspect matched nodes before copying runtime code.

Convert YAML locally into structured JSON or normalized YAML and flat configuration text, with path and type checks that expose lossy transformations.

Compare two YAML documents as parsed data with schema-aware scalar types and sequence matching, then review path-level changes and ignored paths.

Format YAML for review or stable diffs and inspect its document structure while catching comments, aliases or directives that may change.

Validate YAML locally with selectable scalar schemas, strict duplicate-key checks, and bounded path evidence for single or multi-document input.