Elysia Tools
Navigation
Workflow Playbook
Operate on JSON structure with a record of every cut — inventory the key paths before touching anything, address nodes precisely with RFC 6901 pointers or flexibly with JSONPath, rename keys by rule instead of by hand, apply RFC 6902 patches as an auditable operation sequence, and flatten to travel with a lossless way back.
New to this workflow? Follow the steps in order, starting with the first tool below. Already know what you need? Jump straight to the matching step — every tool in this workflow is listed in the comparison table.
First tool: JSON Key Extractor
Hubs
| Tool | What it does | Category |
|---|---|---|
| JSON Key Extractor | Extract all keys from JSON objects with multiple output formats. Perfect for analyzing JSON structure, documentation generation, and understanding complex nested objects. | Data Processing |
| JSON Pointer Tool | Navigate and extract values from JSON using JSON Pointer (RFC 6901) | Converter |
| JSON Path Extractor | Query JSON with JSONPath or JMESPath-style expressions, inspect matched paths, and highlight extracted values in the original document | Data Processing |
| JSON Key Renamer | Batch rename JSON object keys with support for patterns, rules, and transformations. Perfect for API response formatting and data normalization. | Data Processing |
Hubs
| JSON Patch Tool |
| Apply JSON Patch operations to JSON data (RFC 6902) |
| Converter |
| JSON Flattener | Flatten nested JSON objects into key-value pairs with customizable delimiters and flattening strategies | Data Processing |
| JSON Unflattener | Convert flattened key-value pairs back to nested JSON objects with support for different key formats and data type inference | Data Processing |
Surgery begins with imaging. A JSON document of any depth hides its structure from casual reading — the same key at two levels means two different things, an array where an object was expected breaks the rule you were about to write — and the key inventory turns that hidden terrain into a list on paper. Every path appears once, surprises surface before rules are written against them, and the inventory becomes the baseline for everything after: regenerate it after each operation and the diff between inventories is the operation's honest receipt.
JSON addressing comes in two registers, and confusing them is the common beginner tax. The pointer — RFC 6901 — is an exact address: /data/items/0/price names one node, resolves or fails, and is the dialect JSON Patch itself speaks. The path query — JSONPath or JMESPath style — is a search: wildcards, filters, and projections that return sets of nodes and cost nothing to try. The discipline that keeps them straight is simple — explore with paths, operate with pointers — because an operation that names its target precisely is an operation whose result can be predicted.
Editing a JSON file directly produces a result; applying an RFC 6902 patch produces a result and a record. The patch is an ordered sequence of named operations — add, remove, replace, move — each targeting a pointer, which makes it readable before it runs, reviewable as a diff, replayable on fresh inputs, and archivable as the audit trail of what was done to the data and in what order. Renaming follows the same logic at the key level: a rule that matches a pattern applies everywhere the pattern lives, and nowhere else — no forty-first manual edit discovered missing after the fortieth looked fine.
Flat key-value rows are the lingua franca of spreadsheets, diff tools, and half the data pipeline world; nested JSON is the native tongue of APIs. The flattener bridges out — nesting collapsed into delimiter-joined keys — and the unflattener bridges back. The guarantee that matters is the round trip: flatten, unflatten, deep-compare against the original, and the structure is proven intact. The one precondition is the collision check — a key containing the delimiter will not survive the trip, so the separator is chosen against the key names actually present, not by habit.
This page reshapes structure and proves the reshape — it does not query for values, convert between formats, or certify a shape. Pulling data out of JSON by query is the extraction and transformation workflow; formatting, validating, and merging documents are the utility workflow's health checks; converting JSON to YAML, CSV, or BSON is the conversion workflow; and turning a structure into TypeScript types or a schema is the typed-code and schema-inference workflows' business. Cut here, verify the round trip, and hand the document to the neighbor that owns the next question.
Workflow playbook
Extract every key path from the document so the structure is visible on paper before any operation, and keep the inventory as the baseline the later acceptance checks regenerate and compare against.
Pinpoint exact nodes with RFC 6901 pointers for surgical single targets, and explore set selections with JSONPath or JMESPath-style expressions when the operation concerns a pattern of nodes rather than one address.
Rename keys across the document by pattern and rule instead of one-by-one editing, and express additions, removals, replacements, and moves as an RFC 6902 patch sequence that names each target with a pointer.
Collapse nesting into delimiter-joined key-value pairs for tools that eat flat rows, and restore the nested structure losslessly on the way back — verifying the round trip with a deep comparison.
A direct edit is right for one-off fixes nobody will revisit, while an RFC 6902 patch is an ordered, named operation sequence that can be reviewed before it runs, replayed on similar inputs, and diffed afterward — choose the patch whenever the change must be accountable.
A JSON Pointer names exactly one node — /data/items/0 — and is the addressing dialect JSON Patch itself uses, while JSONPath and JMESPath-style expressions select sets with wildcards and filters — use the pointer to operate, the path to explore.
The separator decides whether the round trip survives — dots read naturally until a key contains a dot, slashes mirror pointer syntax until a key contains a slash, and a rare custom separator avoids both at the cost of unfamiliar output — pick one your key names cannot contain.