Why We Picked JSONata for Workflow Data Transformation

Every automation platform has a data transformation problem. Your trigger sends one shape. The next step needs another. Somewhere in between you’re renaming fields, filtering arrays, formatting dates, or pulling a value out of a nested object. It’s the least glamorous part of building workflows, and it’s where most tools fall flat.

Most platforms force you into a false choice. Zapier gives you formatters. n8n gives you code. Neither works well when you need to do real work at agency scale. We built TaskJuice around JSONata, an open expression language for data transformation that AWS added to Step Functions in November 2024.[1] One JSONata expression replaces five Zapier Formatter steps. It’s built into every node in our editor. And when you genuinely need to write code, we ship a Code node for that too.

The False Choice Every Automation Platform Makes

Most automation tools handle data transformation the same way. They offer a small library of canned formatter steps for simple cases, and a code step for everything else. The gap between those two options is enormous, and it’s where every agency hits friction on real workflows.

Zapier’s Formatter actions are the cleanest version of this pattern. You get steps for text, numbers, dates, and lookup tables. Each one handles one job. Need to format a phone number? One step. Need to parse a date, convert it to a different timezone, and format it as a string? Three steps, chained. Formatter actions stopped counting against your task quota in 2024, but chaining them still adds latency, configuration overhead, and visual clutter to every workflow.

Make (formerly Integromat) gives you a proprietary function syntax with semicolon parameters and module-number references, like {{formatDate(1.date; "Do MMMM YYYY")}}.[11] Skills you build learning Make’s functions only work inside Make.

n8n uses single-line expressions wrapped in double curly braces. For anything beyond a single expression, the n8n docs recommend dropping into their Code node, which runs JavaScript or Python.[10] Technically you can cram multi-line logic into an expression via an immediately invoked function, but reading {{ (() => { /* complex code */ })() }} in a parameter field is exactly as painful as it looks.

Activepieces goes the other direction and leans on TypeScript code steps. That’s great if your agency is staffed with developers. It’s a problem when a client needs to edit a workflow and doesn’t know TypeScript.

What JSONata Actually Is

JSONata is an open source query and transformation language for JSON data. It was created by Andrew Coleman at IBM[5] and is inspired by the location-path semantics of XPath 3.1.[6] A single JSONata expression can filter arrays, extract nested fields, run conditional logic, and reshape objects into a new structure, without writing a function or importing a library.

The language is small and focused. If you can read a JavaScript property access like $.user.email, you can read most JSONata. What makes it different is how much it lets you do in one expression. You can filter and transform an array in a single line that reads naturally, without writing a map callback or a for loop.

JSONata has over a million weekly npm downloads[3] and 2.6k stars on GitHub.[4] The project is MIT licensed and has been in active development since 2016. AWS Step Functions added native JSONata support in November 2024. Node-RED uses JSONata in Change and Switch nodes.[7] Zendesk’s advanced AI agent builder uses JSONata to transform API responses.[8] Stedi built their mapping product on top of JSONata and maintain a public playground.[9]

We picked JSONata for TaskJuice because it sits in the middle of the productivity curve. It’s more capable than any formatter step. It’s more readable than raw JavaScript for the kind of data reshaping you do in workflows. And because it’s an open standard, the skills agencies build in TaskJuice transfer to every other platform that adopted it.

One Expression Versus Fifteen Lines of JavaScript

Take a list of Nobel laureates where each has a known name in multiple languages. You want to extract just the English names. In JSONata, that’s one expression:

laureates.knownName.en

The JavaScript equivalent needs map, filter, and optional chaining to handle the nullable fields:

input.laureates.map(l => l?.knownName?.en).filter(n => n)

Nearform ran this exact comparison in a benchmark study. Raw JavaScript wins on execution speed by orders of magnitude on hot paths. For integration work, Nearform concluded that development velocity matters more than microseconds.[12]

Here’s a more realistic workflow example. Your trigger sends an order object and you need to post a Slack summary like “John Smith spent $247.50 on 3 items”:

firstName & ’ ’ & lastName & ’ spent $’ & $string($sum(items.price)) & ’ on ’ & $count(items) & ’ items’

One line. In JavaScript it’s a template literal, a sum reducer, and a length check wrapped in a function. Both work. The JSONata version is shorter, has no syntax to remember for nullable fields, and can be typed directly into a parameter without wrapping it in a function body.

For something harder, filtering an array of subscribers down to active ones with non-gmail email addresses:

subscribers[status = ’active’ and email !~ /gmail\.com$/].email

One expression. Filter plus projection plus regex match. Try that in a Zapier Formatter step.

Every Node Has Output Mapping Built In

In TaskJuice, data transformation isn’t a separate step you add to your workflow. Every trigger, action, branch, and parallel node has a built-in JSONata output mapping field. You reshape the data where it’s produced, right as it leaves the node, before it flows to the next step.

This matters more than it sounds. In Zapier, if five nodes each need their output reshaped, you add five Formatter steps to your workflow. Your workflow editor goes from ten visible nodes to fifteen. In TaskJuice, the same transformations live inside the nodes that produced them. The workflow reads as what it does, not as what formatting it needs in between.

Our JSONata editor is more than a text field. It gives you autocomplete for every field available in context, including outputs from every upstream node by ID. Reference chips render as visual badges so $steps.`order-created`.data.customer.email looks like a clean inline token instead of a wall of syntax. Live validation catches errors as you type. A sample-value preview shows what your expression resolves to against real test data. You can drag a field from the Input panel and drop it directly into your expression.

The expression language in branch and switch nodes is also JSONata. Conditions like status = ’active’ or value > 100 use the same syntax you write in output mappings. One expression language across the whole platform means one mental model, not five.

AWS Picked JSONata. So Did Node-RED, Zendesk, and Stedi

JSONata isn’t something we invented. It’s an open standard with serious adoption across the platforms that handle production data transformation at scale.

AWS added native JSONata support to Step Functions on November 22, 2024 and positioned it as the recommended query language for new state machines.[1] The impact on Step Functions code is substantial. The previous JSONPath approach required five separate fields (InputPath, Parameters, ResultSelector, ResultPath, and OutputPath) to handle input and output transformation. JSONata collapses these into two fields, Arguments and Output.[2] State machines written in JSONata are shorter as a result, with less input/output plumbing scattered across state definitions.

Node-RED, the open source flow-based programming platform, has used JSONata in its Change and Switch nodes for years.[7] The official docs position it as the recommended way to transform message data declaratively, without dropping into a function node.

Zendesk’s advanced AI agent product uses JSONata to parse API response bodies and transform data within conversation flows.[8] Their docs call out JSONata’s shallow learning curve as the reason they chose it, making the integration builder usable by non-developers.

Stedi built their entire Mappings product on JSONata. They maintain a public JSONata playground and a detailed cheatsheet. Their documentation describes JSONata as the transformation engine that powers EDI-to-JSON conversions across their platform.[9]

elastic.io and HCL Workload Automation both ship dedicated JSONata components or plugins.[13][14] The pattern is clear. If you’re building a serious data integration platform in 2026, JSONata is where the industry has landed.

When You Need Code, We Have a Code Node

JSONata handles the vast majority of transformations you’ll write in a workflow, but it doesn’t cover everything. For custom logic, external library calls, or genuinely procedural code, TaskJuice includes a Code node.

The difference from n8n isn’t that we offer a Code node. It’s the threshold for reaching for one. In n8n, the Code node is the escape hatch for anything you can’t squeeze into a single-line expression. In TaskJuice, JSONata handles the kind of transformations that push you into code on other platforms: array filtering, aggregations, conditional reshaping, string composition, regex matching. The Code node is there when you actually need imperative logic.

We think of it as a layered approach. Output mapping with JSONata handles reshaping. Branch and switch conditions with JSONata handle routing. The Code node handles custom procedural logic. Each layer does what it’s good at. You don’t end up with a workflow where every other node is a code step because the expression language ran out of steam on line one.

JSONata Is a Transferable Skill

Skills you build learning TaskJuice work elsewhere. JSONata uses the same syntax across AWS Step Functions, Node-RED, Zendesk AI agents, Stedi mappings, and TaskJuice. The jsonata.org playground lets you test expressions in a browser. The language has a detailed reference on docs.jsonata.org and thousands of Stack Overflow answers indexed on Google.

Compare this to Zapier’s Formatter actions, Make’s function syntax, or n8n’s Tournament templates. All three are proprietary. Time invested in learning them is locked to that one platform.

For agencies hiring or training team members, a transferable expression language is a practical advantage. Your team’s time spent learning JSONata compounds across every tool that adopted it, including tools your clients might already be using.

Frequently Asked Questions

What is JSONata?

JSONata is an open source query and transformation language for JSON data. It lets you extract, filter, and reshape JSON in a single expression. Created by Andrew Coleman at IBM in 2016, it’s inspired by XPath 3.1 and used by AWS Step Functions, Node-RED, Zendesk, Stedi, and TaskJuice.

Is JSONata better than JavaScript for data transformation?

For workflow data transformation, yes. JSONata expressions are shorter, easier to read, and safer to execute than raw JavaScript. For complex procedural logic, external library calls, or heavy computation, JavaScript wins. That’s why TaskJuice offers both: JSONata for most transformations, and a Code node for the rest.

What is the difference between JSONata and JSONPath?

JSONPath is a query-only language. You can extract data with it, but you can’t reshape or transform the result. JSONata does both. AWS added JSONata to Step Functions specifically because JSONPath couldn’t handle the transformation workload that JSONata can.

Can I test JSONata expressions without TaskJuice?

Yes. The official playground at try.jsonata.org lets you paste a JSON document and test expressions against it in the browser. Stedi also maintains a public playground at stedi.com/jsonata/playground. Both are useful for learning the syntax before you start writing expressions in your workflow editor.

We didn’t pick JSONata because we wanted to be different. We picked it because it’s the right tool. Almost every serious automation platform has either adopted JSONata or is about to. It reads well for agency operators who aren’t full-time developers. It scales up to handle complex transformations without dropping into code. And it’s open, so your skills and your workflows aren’t locked to our platform.

If you’ve been working around the limits of Zapier Formatters or writing more Code nodes in n8n than you’d like, JSONata is the option you didn’t know you had.

Sources

[1] AWS Step Functions supports variables and JSONata, AWS What’s New: aws.amazon.com/about-aws/whats-new/2024/11/aws-step-functions-variables-jsonata-transformations

[2] Transforming data with JSONata in Step Functions, AWS Documentation: docs.aws.amazon.com/step-functions/latest/dg/transforming-data.html

[3] JSONata on npm: npmjs.com/package/jsonata

[4] JSONata GitHub Repository: github.com/jsonata-js/jsonata

[5] Andrew Coleman, Creator of JSONata: github.com/andrew-coleman

[6] JSONata Documentation: docs.jsonata.org

[7] Node-RED User Guide: Nodes: nodered.org/docs/user-guide/nodes

[8] Using JSONata with advanced AI agents, Zendesk Help Center: support.zendesk.com/hc/en-us/articles/8357756877466-Using-JSONata-with-advanced-AI-agents

[9] Stedi JSONata Playground: stedi.com/jsonata/playground

[10] Code node, n8n Documentation: docs.n8n.io/code/code-node

[11] Date and time functions, Make Help Center: help.make.com/date-and-time-functions

[12] The JSONata Performance Dilemma, Nearform: nearform.com/insights/the-jsonata-performance-dilemma

[13] JSONata Component, elastic.io Documentation: docs.elastic.io/components/jsonata

[14] Mastering Data Manipulation: JSONata Plugin for Workload Automation, HCL Software: hcl-software.com/blog/workload-automation/mastering-data-manipulation-jsonata-plugin-for-workload-automation