# Dot Object Transformer MCP > The Dot Object Transformer handles complex data structures by mapping nested JSON objects to simple dot-notation keys for spreadsheets, or reconstructing those flat records back into deeply nested API payloads. ## Overview - **Category:** developer-tools - **Price:** Free - **Tags:** json-transformation, data-mapping, dot-notation, data-serialization, object-manipulation ## Description When you pull data from an external source via an agent, the structure is almost always deep and hierarchical. But if your goal is a CSV export or populating a web form, that nesting gets in the way. That's where this MCP comes in. It figures out how to take complex JSON—like user profiles with nested addresses and arrays of items—and flatten it deterministically into readable columns using dot-notation keys (e.g., `user.address.zip`). Conversely, if you get a flat list of form fields but need to send that data to an API that expects a fully structured payload, this tool reconstructs the object perfectly. It's essential for building reliable pipelines; connecting it through Vinkius gives your agent access to industry-standard tools right alongside everything else. ## Tools ### transform_dot_object Flattens deeply nested JSON objects into dot-notation keys, or reconstructs a nested object from flat dictionary inputs. ## Prompt Examples **Prompt:** ``` Flatten this nested user profile JSON for CSV export. ``` **Response:** ``` Dot Object Result: 8 keys flattened. ``` ## Capabilities ### Flatten Nested JSON Transforms deep, multi-level JSON objects into a single set of flat keys using dot notation. ### Rebuild Complex Payloads Converts simple dictionaries with dot-notation keys back into fully nested and structured JSON objects for API calls. ### Preserve Data Integrity Maintains complex structures, including arrays and null values, during the transformation process. ## Use Cases ### Exporting User Data to a Spreadsheet A data analyst pulls user records from an internal API. The JSON is nested (e.g., `user.address.city`). They need this data in Excel. Instead of writing complex mapping code, your agent uses `transform_dot_object` to flatten the structure, giving clean columns like 'user.address.city' that can be loaded directly into CSV. ### Handling Multi-Form Submissions A user fills out a complex form with separate fields for billing and shipping addresses. The backend needs to send this data as one nested JSON object. By using `transform_dot_object`, the agent takes the flat input data and reliably reconstructs it into the required deep payload structure. ### Migrating Legacy APIs You're moving an old service that outputs simple, key-value pairs to a modern API that requires full nesting. You use `transform_dot_object` to take the flat keys (like `user.id`) and reliably convert them into the deep JSON object structure the new API demands. ### Pre-processing Chatbot Inputs A user provides a block of structured data within a chat conversation, but your downstream system requires it to be flat for database logging. You use `transform_dot_object` on the input JSON payload to generate simple dot-notation keys before passing it off. ## Benefits - Eliminates manual JSON mapping. You stop writing custom, brittle code every time a schema changes and just call `transform_dot_object`. - Guaranteed structural fidelity. It handles arrays and null values perfectly, so you don't lose data when moving between nested and flat formats. - Reliable API preparation. When your agent needs to send structured data, this tool reliably rebuilds the payload from simple inputs. - Seamless reporting prep. Exporting complex user records for a spreadsheet is now trivial; `transform_dot_object` flattens everything you need into columns. - Saves development time. Instead of writing bespoke serialization logic, you use this single point of truth for object manipulation. ## How It Works The bottom line is that this tool makes sure your data structure matches whatever system you're sending it to, without losing any information along the way. 1. You provide your agent with the input data—this could be a deeply nested JSON object or a flat dictionary of key-value pairs. 2. Your agent invokes `transform_dot_object`, specifying whether it needs to flatten the structure (for export) or reconstruct it (for API submission). 3. The MCP returns the output: either a clean, single-level data map perfect for CSVs, or a perfectly structured JSON payload ready for consumption. ## Frequently Asked Questions **How does transform_dot_object handle nested arrays?** It preserves array integrity during both flattening and unflattening. If an object contains a list of items, it keeps that list structure intact while mapping the keys. **Is the Dot Object Transformer bidirectional?** Yes, it's fully bidirectional. You can flatten nested JSON into dot-notation keys, and then convert those flat keys back into a complex, nested object. **When I run transform_dot_object, what happens if my input data contains null values or empty arrays?** It handles nulls and empty arrays without issue. The tool maintains the structure of these missing fields, so your output JSON payload remains accurate for downstream systems. **What should I do if transform_dot_object encounters malformed or incomplete dictionary data?** If you provide a corrupted input, the MCP will return an explicit error message detailing which part of the structure failed. This allows your AI client to catch the problem and adjust the payload before proceeding. **Does using transform_dot_object require any local dependencies or setup outside of Vinkius?** No, you don't need to install anything locally. Since this MCP is managed by Vinkius, your AI client simply connects and uses the tool directly through our standard protocol. **How scalable is transform_dot_object when dealing with extremely large JSON payloads?** It processes data efficiently, designed to handle complex structures up to typical payload limits. If you hit a size wall, the tool will report the limit and suggest chunking your data. **Is the data passed through transform_dot_object kept private when using it with my agent?** Yes, all data processing happens within the secure connection framework of Vinkius. We treat your input JSON and resulting transformed data as confidential. **Can I use transform_dot_object if my source data isn't strictly JSON format?** No, this MCP is specifically built to map standard JSON objects. You must feed it valid JSON; the tool cannot process formats like XML or YAML directly. **Does it preserve arrays?** Yes, arrays are flattened with numeric indices (e.g. "items.0.name") and restored perfectly on unflatten.