DataLensia uses a component-based architecture to process data. Connect these components on a visual canvas to build complex, automated pipelines that transform, validate, and visualize your data entirely in the browser.

📥 Source Components

JSON Input: The entry point for manual JSON entry or pasting raw data.
Schema Data Generator: Generate validated mock records from a JSON Schema with a repeatable seed.
API Ingest: Connect to external REST/GraphQL endpoints with support for dynamic URL templating and custom headers.
File Upload: Import local JSON or CSV files directly into your workflow.

🔄 Transform Components

Builder: Visual field mapping and transformation chains powered by the Transform Builder.
Filter: Prune records based on complex logical conditions and regex.
Limit / Offset: Constrain the number of records or skip a specific amount for pagination.
Sort: Reorder data based on field values with numeric-aware sorting.
Deduplicate: Remove duplicate records based on one or more composite keys.
Flatten: Unnest arrays and spread fields to normalize nested data structures.
Group By: Aggregate and summarize data into categorized groups.
Validator: Enforce data integrity using JSON Schema (Draft 7 or 2020-12).
JS Script: Write custom JavaScript logic in a sandboxed environment for complex edge cases.
Merge: Combine multiple data streams using object merge, deep merge, or array concatenation strategies.

📤 Output Components

Mock API: Generate a live, shareable REST endpoint from your transformed data.
Export: Download your results in various formats (JSON, CSV, YAML, etc.).

📊 View Components

Notes: Markdown annotations with optional connected data in previews and .md exports.
Table View: Interactive spreadsheet-like view for data inspection.
Mermaid: Automatically generate flowcharts and diagrams from JSON structures.
Flow Diagram: Explore data hierarchies through an interactive visual explorer.

🚀 Advanced Features

To streamline your workflow, the Pipeline environment includes several powerful productivity features:

⚡ Auto-run Engine

Located in the toolbar, the Engine toggle (Zap icon) enables automatic execution. When active, the pipeline re-runs instantly whenever you add nodes, change connections, or update configurations, providing immediate feedback on your changes.

👁️ Live Preview

Toggle the Preview mode to open a resizable data explorer at the bottom of the canvas. Selecting any node will instantly display its current output data, allowing you to inspect results without leaving the workspace.

📁 Workspace Integration

DataLensia pipelines can bidirectionally sync with the rest of the platform. By dragging Workspace Nodes (Data, Transform, or Mock) from the palette, you can create pipelines that directly read from or update your primary workspace configuration.

🔁 Continue from a standalone tool

The standalone Schema Generator offers Open in pipeline for the complete example → schema → generated data flow. It copies your source JSON or NDJSON and inference settings; running the flow infers the schema again, so manual edits in the standalone schema output are not included. No output nodes are added automatically: run the flow, inspect the result, then connect Table View, Export or Mock API as needed.

The standalone JSON Editor offers three contextual workflow recipes under Build workflow:

Explore data: one JSON or NDJSON input branching to Table View, Mermaid, UML and Flow Diagram. Mermaid and UML start with a suggested best-fit diagram; any type you choose is remembered in the pipeline.
Create mock API: the current document connected to a GET Mock API output.
Process and export: the current document connected to an editable Transform node and a JSON Export node.

These are temporary, editable starting points. They copy the current document into the pipeline and never update the standalone Editor automatically. Save the pipeline explicitly when it is ready to keep it.

The standalone JSON Schema Fake Data Generator offers three recipes under Open in… → Build rerunnable workflow:

Generate and inspect: the current schema and generation settings connected to Table View.
Generate and mock: the current schema and generation settings connected to a GET Mock Output node.
Generate and export: the current schema and generation settings connected to a JSON File Export node.

These recipes keep the current schema, record count, seed, default array size, and optional-field setting in the Schema Data Generator node. They generate fresh records whenever the pipeline runs, so downstream views and outputs always use the node's current configuration. The generated records themselves are not copied into the pipeline manifest.

The standalone JSON Validator offers schema-aware recipes under Build validation workflow when JSON Schema mode is active and a schema is configured:

Validate and inspect: the current JSON or NDJSON → Validator → Table View.
Validate and export: the current JSON or NDJSON → Validator → JSON File Export.
Validate and mock: the current JSON or NDJSON → Validator → GET Mock Output. By default, a schema failure stops the pipeline before it reaches the mock output; the Validator's pass-through-errors option can be enabled in the pipeline.

These workflows copy the current input and schema into an editable pipeline. A syntax-only validation does not offer a pipeline recipe because it adds little beyond parsing the input. The standalone Validator session is not modified by pipeline edits.

The standalone Mock API offers two recipes under Open in Pipelines when its response body is valid JSON or NDJSON:

Transform and mock: JSON or NDJSON Input → Transform → Mock Output. The Transform node starts with mappings that preserve the current fields.
Script and mock: JSON or NDJSON Input → Script → Mock Output. The script starts by returning its input unchanged.

Both recipes copy the current HTTP method, status, content type, delay, response headers, default params, and interpolation template. The Mock Output is set to serve the latest pipeline result, so its endpoint reflects Transform or Script changes after each run. Dynamic placeholders are still evaluated for each HTTP request. Each generated endpoint URL is a snapshot; old URLs keep their earlier data. Raw XML, HTML, and plain-text templates are not offered as structured pipeline input.

The standalone Transform Builder offers three recipes under Build workflow once you have valid source data and at least one mapping:

Transform and inspect: JSON or NDJSON Input → Transform → Table View.
Transform and export: JSON or NDJSON Input → Transform → JSON File Export.
Transform and mock: JSON or NDJSON Input → Transform → GET Mock Output. Rerun the pipeline after changing input or mappings to refresh the mock data.

Each recipe copies the current source document and complete mapping configuration, including transformation operations and nested mappings. The Transform node applies those rules when you run the pipeline. Editing the pipeline does not change the standalone Transform Builder's source or mappings.

All recipes are temporary, editable starting points. They never update the originating standalone tool automatically. The pipeline is marked Temporary: changes survive refreshes in the current tab and leave your saved standalone pipeline untouched. Save this pipeline copies the current workflow into your saved standalone pipeline; if one already exists, Pipelines asks for confirmation before replacing it. Later changes still belong to the temporary tab session until you save again. Closing the tab ends that session. Share pipeline shares a copy of the workflow and input data, rather than the live tab session or generated results.

Schema Data Generator also offers direct transfers of validated generated records to Editor, Converter and a standalone Mock API snapshot when you need a one-off result instead of a rerunnable pipeline.

🛠️ Professional Inspector

The Node Inspector uses a tabbed layout to separate Identity (labels and execution strategy) from Config (node-specific logic). This keeps the interface clean while providing deep control over every building block.

↔️ Collapsible Palette

Maximize your workspace by collapsing the Node Palette on the left. This provides more room for complex diagrams while keeping all components just a click away.

⚙️ Pipeline Orchestration

DataLensia's pipeline engine is built on several key principles to ensure reliable and efficient data processing:

Directed Acyclic Graphs (DAG)

Pipelines are modeled as DAGs. This means data flows in one direction from sources to outputs without cycles. The engine performs a Topological Sort to determine the exact execution order, ensuring that all dependencies for a node are met before it runs.

Multi-Input Processing

Nodes like Merge and JS Script can accept multiple inputs from different upstream nodes. The engine waits for all parent nodes to complete successfully before triggering the child node.

Error Handling & Pass-Through

By default, if a node fails, the pipeline execution stops for that branch. However, most nodes support an Error Pass-Through mode. When enabled, the node will pass the original input data to the next node even if its own operation fails, allowing for more resilient workflows.

Browser-Side Execution

All processing happens within your browser's memory. This ensures maximum privacy (your data never leaves your machine) and high performance for small-to-medium datasets. For very large datasets, we recommend using Limit nodes early in the pipeline.