The Rename Keys operation changes the names of keys in JSON objects according to a mapping you provide. Each mapping entry uses the existing key as its name and the desired key name as its value. For example, a mapping such as {"firstName":"first_name","lastName":"last_name"} changes matching keys while leaving other keys unchanged. The values associated with the keys are preserved; the operation changes key names rather than changing the data stored under them.
Provide a JSON object as the mapping for the Rename Keys operation. The mapping must contain string keys and string values, and mapping values cannot be empty. For example, {"name":"fullName","age":"years"} tells the operation to rename name to fullName and age to years. After the mapping is parsed, Lamuki applies it to the JSON file. Keys that do not appear in the mapping keep their original names.
Yes. A single mapping can contain multiple key-renaming rules, so several JSON keys can be renamed during the same operation. For example, {"name":"fullName","email":"emailAddress","phone":"phoneNumber"} defines three changes that can be applied to matching keys. This is useful when standardizing field names, adapting JSON data to another naming convention, or preparing several fields for a different structure.
Yes, when the Recursive option is enabled. With recursive processing enabled, the operation examines objects nested inside other objects as well as objects contained in arrays. The same mapping is applied at each object encountered during the traversal. This allows matching keys to be renamed throughout a nested JSON structure rather than only at its outermost object level.
When Recursive is disabled, Rename Keys processes only the current JSON object. Keys belonging to nested objects are not renamed, and arrays are not traversed. If the JSON value itself is an object, its keys can be renamed according to the mapping while nested values remain otherwise unchanged. If the top-level JSON value is an array, the array is returned without recursive processing when Recursive is disabled.
When Recursive is enabled, arrays are traversed so that objects inside them can also have their keys renamed. The operation does not rename array elements themselves because array elements do not have object key names. Instead, it continues into each array item and applies the mapping whenever an item is an object or contains another traversable structure. This makes recursive processing suitable for JSON containing lists of objects.
Keys without a corresponding mapping entry remain unchanged. The operation checks each key and uses its mapped name when one exists; otherwise, it keeps the original key. This means you do not need to provide a complete mapping for every key in the file. You can target only the names you want to change while preserving the rest of the JSON structure and key names.
The operation detects key collisions and reports an error instead of silently overwriting data. A collision occurs when multiple keys in the same object would produce the same resulting key. For example, mapping both firstName and givenName to name would create a conflict if those keys occur together in an object. This behavior protects the resulting object from losing one value because of duplicate output keys.
No. The operation is specifically concerned with object key names. The values associated with those keys are retained while their names are changed when a mapping applies. Numbers, strings, booleans, null values, arrays, and nested objects are not otherwise transformed by the operation. With recursive processing enabled, nested objects are processed for key renaming, but their contained values remain intact.
The mapping must be valid JSON representing an object. Its property names must be strings, and its property values must also be strings. Mapping values cannot be empty strings. A mapping such as {"oldKey":"newKey"} is valid, while a mapping whose value is a number, boolean, array, or object is not valid. The operation reports an invalid mapping error when these requirements are not met.
Yes. Renaming keys is useful when JSON data uses inconsistent or unwanted field names. You can define a mapping that converts selected names into a consistent naming convention, such as changing user_name to username or createdAt to created_at. When recursive processing is enabled, the same naming rules can be applied across nested objects and objects inside arrays, making the operation useful for larger JSON structures.
The operation expects the file content to contain valid JSON. If the JSON cannot be parsed, the operation catches the error and reports it rather than producing a renamed result. The same applies when the file content cannot be read as expected. Valid JSON and a valid mapping are therefore required before key renaming can be completed.
Yes. When Recursive is enabled, the supplied mapping is reused as the operation moves through nested objects and arrays. A key matching an entry in the mapping can therefore be renamed wherever that key occurs in the traversed JSON structure. The operation does not require a separate mapping for each nesting level.
The important consideration is the resulting key name within each individual object. If renaming would cause two keys in the same object to have the same output name, the operation raises a key collision error. This can also matter with a mapping that indirectly conflicts with an existing key. Checking the intended mapping against the structure of your JSON can help avoid collisions before processing.
Rename Keys can be useful for developers, analysts, data workers, and anyone who needs to adjust JSON field names without manually editing every occurrence. Common situations include adapting exported data to an expected field naming scheme, standardizing selected properties, preparing JSON for another application, or updating nested records consistently. The recursive option is particularly useful when the same key names occur throughout a structured JSON document.
Yes. Rename Keys is part of Lamuki's JSON workspace, where users can work with multiple files and apply operations to selected files. Lamuki supports unlimited batch processing, making it possible to process multiple files as part of a larger JSON workflow. Individual files can also be uploaded when only one file needs to be processed.
Lamuki supports entire folder uploads in its workspaces where applicable, allowing users to bring multiple files into a workspace instead of selecting them individually. Within the JSON workspace, files can then be selected for processing. This can be useful when a key-renaming task needs to be repeated across a collection of JSON files.
Yes. Lamuki provides a complete workspace for working with files, including applying operations and reviewing computed results. After Rename Keys processes a JSON file, the resulting JSON is stored as formatted JSON with two-space indentation. You can review the processed file within the workspace before downloading the files you need.
Yes. Rename Keys can be part of a longer workflow in the JSON workspace. After the operation completes, you can select another operation from the workspace's operation interface and continue working with the same files. You do not need to manually download and re-upload the files between operations just to continue the workflow.
Lamuki processes files directly in the user's browser. The Rename Keys operation parses the JSON, applies the supplied mapping, and updates the processed file within the workspace. The file contents are not transferred to a remote server for processing. This browser-based approach lets users work with their JSON files without sending the file contents to a remote processing service.
No account or login is required to use Lamuki. The Rename Keys operation is part of the JSON workspace and is available as part of Lamuki's free browser software. Users can work with their files directly in the browser without creating an account or sending their file contents to a server for processing.
Yes. Lamuki is free to use, and its workspaces and operations are available without a paid subscription. Lamuki also provides unlimited batch processing, so users can process multiple files without a separate batch-processing charge. Rename Keys can therefore be used as part of a broader JSON workflow without requiring a paid plan.
The operation produces the JSON data with matching object keys renamed according to the mapping. The resulting content is serialized as formatted JSON with two spaces of indentation. If a key collision, invalid mapping, unreadable file, or other processing error occurs, the operation reports an error instead of treating the failed operation as a successful renamed result.
Top-level key renaming affects the keys of the JSON's current object. Nested key renaming requires Recursive to be enabled so the operation can traverse into nested objects and arrays. For example, if a JSON object contains a profile object with a name key, a non-recursive operation can rename a matching top-level name key but will not enter profile. With Recursive enabled, the nested name key can also be renamed.
Start by defining the exact old-to-new key mapping you need, making sure every mapping value is a non-empty string. Decide whether the changes should apply only to the current object or throughout nested objects and arrays. Then select the JSON files you want to process and run Rename Keys in the workspace. Review the computed results for the expected key names and check for collision errors. If further processing is needed, select another operation from the workspace interface and continue with the same files.
Structured JSON often contains objects at several levels, including objects inside arrays. Renaming only the outermost keys would leave matching names deeper in the document unchanged. Recursive processing addresses this by traversing nested objects and arrays and applying the same mapping throughout the structure. It is useful when a field name needs to be standardized wherever that field occurs in the JSON data.
