Edit Scenario Data Structures in Make.com

In make.com, editing the input and output structure of a scenario is essential when apps change their data, when fields appear missing, or when you need to control how bundles are mapped. This guide explains step by step how to refresh, edit, and remap your data structure safely.

Understanding Scenario Structures in Make.com

Every module in a scenario on make.com works with a defined input or output structure. This structure tells the platform which fields are available, what types they are, and how they are organized.

You typically need to edit the structure when:

An app or service updated its API and added, removed, or renamed fields.
A custom webhook or custom app changed the payload format.
You imported a blueprint where modules show missing or broken mappings.
Your scenario reports structure-related errors while running.

Instead of rebuilding modules, you can adjust the structure directly from within the scenario editor.

How to Access Structure Editing in Make.com

You always edit the structure from the module that sends or receives the data. The options you see will differ slightly between input and output modules, and between normal modules and webhook-based modules.

Open your scenario in the scenario editor.
Click the module whose input or output structure you want to adjust.
In the right panel, look for the section that shows input or output fields.
Locate the icon or link that allows you to edit the data structure (typically labeled with Data structure or similar wording).

From this view, you can refresh the structure from the app, edit it manually, or manage stored structures used by multiple modules.

Refreshing Output Structure from Apps in Make.com

Many modules on make.com automatically obtain their output structure from the connected app using API calls.

To refresh an output structure:

Open the output module in your scenario.
In the output field list, click the option to Refresh or Re-determine the structure.
Confirm the action so the module can fetch the latest field definitions from the app.

When the structure is refreshed:

New fields in the app become available for mapping.
Removed fields may disappear from the structure.
Renamed fields might appear as new fields, while old mappings may break.

After refreshing, always check mappings in all downstream modules to ensure there are no missing fields or warnings.

Manually Editing Output Structures in Make.com

Sometimes you cannot or do not want to refresh from the source app. For example, you may be working with a static webhook payload or a custom API where you control the format. In that case you can manually edit the structure.

To edit an output structure manually:

Open the module whose output you want to change.
Open the structure editor from the module settings.
Add new fields by specifying:
- Field name
- Data type (text, number, boolean, array, object, date, etc.)
- Whether the field is required or optional
Remove fields that will no longer be sent by the module.
Reorder fields if necessary for clarity.

When you save, the updated structure is stored in make.com and becomes available for mapping in later modules.

Editing Webhook and Custom App Structures in Make.com

Webhook modules and custom app modules on make.com often rely on user-defined data structures. You may capture a sample payload or design the structure manually.

Capturing a Sample Webhook Structure in Make.com

Open the webhook module in the scenario.
Switch it to a mode that waits for a sample request (if available).
Send a test request from the source system.
Allow make.com to parse the payload and create a draft structure.

After capturing, you can refine the structure in the editor:

Rename fields to more readable names.
Adjust types if a field should be treated differently.
Remove fields that you do not want to expose for mapping.

Designing Custom Structures for Webhooks or Custom Apps

If you cannot send a sample, you can design the structure directly:

Open the module’s structure editor.
Create top-level fields according to your expected JSON keys.
For nested objects or arrays, define sub-structures inside parent fields.
Save the structure to make it reusable for other modules or scenarios.

This approach lets you work with consistent, predictable structures even before real data arrives.

Managing Input Structures on Make.com Modules

Input structures define what data a module expects. They are particularly important when mapping from variables, other modules, or data stores.

Typical cases where you edit input structures include:

Custom connector modules that accept complex JSON bodies.
Transform tools that require arrays or collections as input.
Scenarios where you load data from a data store with dynamic keys.

To edit an input structure:

Open the target module.
Find the body, payload, or input data section.
Open the data structure editor.
Define fields, types, and nesting that match your upstream data.

Once saved, the module will display clear, named fields in the mapping panel, making complex mappings easier and more reliable.

Working with Shared and Saved Structures in Make.com

Some modules can reuse saved data structures. This is especially useful when the same payload format appears in multiple scenarios.

To use shared structures:

Open the structure editor from any compatible module.
Select an existing saved structure from the list, if available.
Apply it so the module uses the same field definitions.

To update a shared structure:

Edit it from any module that uses it.
Save the changes so they propagate where applicable.
Verify that all scenarios using the structure still run correctly.

This method reduces duplication and keeps your data definitions centralized.

Best Practices for Editing Scenario Structures in Make.com

When adjusting input or output structures, follow these guidelines to avoid runtime issues:

Document changes: Keep notes on what fields were added, removed, or renamed.
Update mappings immediately: After changing a structure, open each dependent module and confirm that mappings still point to valid fields.
Use clear field names: Avoid cryptic keys when you define custom structures so other users can understand the mapping easily.
Test with real data: Always run the scenario with representative data to confirm the structure matches what the app actually sends or expects.
Version your structures: When making major changes, consider creating a new structure instead of editing the old one, then gradually migrate modules.

Troubleshooting Structure Issues in Make.com

When structures and mappings are out of sync, scenarios may fail or produce unexpected results. Common symptoms include:

Fields marked as missing in the mapper.
Scenario run errors mentioning unknown or invalid fields.
Incomplete data in your target system.

To resolve problems:

Identify the module where the error occurs.
Check its input or output structure and compare it with the live data from the app or webhook.
Refresh or manually edit the structure so it matches the real payload.
Review and update mappings downstream.
Run the scenario again and inspect bundles to confirm that all fields are present.

Additional Resources for Make.com Users

To deepen your understanding of editing structures in make.com and related topics, review the official documentation at this help article about editing scenario input or output structures. For broader automation strategy and consulting around integrations, automation architecture, and optimization, you can visit Consultevo.

By mastering input and output structures in make.com, you gain precise control over how data flows through every module, making your scenarios more robust, maintainable, and ready for future changes in the apps you connect.

Need Help With Make.com?

If you want expert help building, automating, or scaling your Make scenarios, work with ConsultEvo — certified workflow and automation specialists.

Get Help

Edit Scenario Data in Make.com