In FileMaker 2025 (v22) a powerful shift has happened that changes how we work with JSON in FileMaker. This shift, thanks to JSONParse, is a huge leap forward in JSON efficiency. For any developer who has fought performance bottlenecks when handling large JSON payloads, the speed improvements are like switching from a bicycle to a Formula One racing car.
Two functions give developers access to an internal-only data type in FileMaker that exists as a native JSON representation – we’ll refer to this as “parsed JSON”. This internal data type has been a part of FileMaker since version 16 when the JSON functions were first added. The JSON functions have historically worked by parsing text formatted as JSON into parsed JSON, performing calculations and converting it back into text. Various updates have made this process more efficient, but it has always been behind the scenes and unavailable to the developer. Until now...
What’s New in FileMaker v22?
JSONParse ( json )
This function takes a JSON-formatted text and creates a parsed JSON that is stored alongside the original text. The parsed JSON is never written to disk. It only lives in memory. This means it exists only in variables, script parameters, and calculations, but is lost if written to a field. Since it only lives in memory, when comparing a parsed JSON variable with the same JSON text that hasn’t been parsed, they will match.
When used as a parameter for other JSON functions like JSONGetElement, JSONListKeys, and JSONGetElementType, this parsed data structure enables a massive speed boost by skipping the time consuming parsing step on every function call.
JSONParsedState ( json )
This function lets you discover whether a given value has a parsed JSON representation stored with it. It returns:
- 0 if the value is only plain text (not parsed),
- -1 if the value contains invalid JSON,
- A positive integer corresponding to the element type
Performance Notes
You don’t need to call JSONParse every time to benefit from performance improvements. FileMaker v22 keeps a single parsed JSON structure in memory: the last JSON used. This means if you’re working with only one JSON object at a time, repeat access is already faster, even without calling JSONParse explicitly. This is referred to as “Cached” in the table below.
However, if you’re working with multiple JSON structures, FileMaker will only retain a parsed representation for the most recently accessed one. In that case, calling JSONParse ensures each structure is fully parsed and stored in memory when you need it.
Real-World Performance Gains
As real world test, we built a simple benchmark: a JSON array with 2,000 elements that’s ~2MB. We looped through the array, retrieving a few elements using JSONGetElement.
For FileMaker v22, we used 2 scenarios. One where we used the built-in caching and another where we reset the cache each time we accessed the JSON.
| FileMaker version | Reading from field | Reading from variable | Using JSONParse |
| v21 | 3m 30s | 38s | Doesn't exist |
| v22 (no caching) | 2m 54s | 0.50s | 0.15s |
| v22 (cached) | 3m 55s | 0.15s | 0.15s |
The result?
The process is 200x faster on average, for some use cases.
That’s not a typo. In the common use case of accessing the same variable multiple times in a row, the time to loop through the entire 2,000 index array dropped from 38 seconds to 0.15 seconds without any script changes just by upgrading from FileMaker v21 to v22.
This isn’t just a small optimization. This is the difference between “This script takes too long” and “This script feels instant.” And because the parsed state persists through parameters, you can now write modular scripts and custom functions that pass around high-performance JSON structures without worrying about degrading performance mid-pipeline.
Final Thoughts
FileMaker v22’s JSON parsing isn’t just a new function; it’s a new pattern that rewards developers who think about memory, parsing, and reuse.
It’s also a quiet affirmation that Claris is investing in performance improvements that matter, especially for those of us building systems that deal with large amounts of data.