How to Import JSON Into Make (Formerly Integromat)
Make is one of the most powerful visual automation platforms available, and JSON is the data format that powers most of the web's APIs and services. Knowing how to import and work with JSON in Make unlocks a huge range of automation possibilities — from syncing data between apps to processing webhook payloads and building complex workflows.
Here's what you actually need to know.
What "Importing JSON" Means in Make
Make doesn't treat JSON as a file you drag and drop into a scenario. Instead, JSON is parsed, mapped, and consumed within modules as data flows through your automation. When people say they want to "import JSON into Make," they usually mean one of three things:
- Parsing a raw JSON string into a usable data structure
- Receiving JSON via a webhook and working with its fields
- Reading a JSON file from cloud storage and extracting its contents
Each of these has a distinct path inside Make.
Method 1: Using the Parse JSON Module
The most direct route is the built-in Parse JSON module (found under the Tools app in Make).
This module takes a raw JSON string as input and converts it into a structured data object whose fields you can map to other modules downstream.
How it works:
- Add the Parse JSON module to your scenario
- In the JSON string field, paste your raw JSON or map a value from a previous module that outputs a JSON string
- Use the Data structure field to define the schema — this tells Make what fields to expect
- Once the structure is defined, Make surfaces each field as a mappable variable
The Data structure step is where many users get stuck. You can either:
- Build the structure manually using Make's visual schema editor
- Use the Generate button and paste in a sample JSON payload — Make will infer the structure automatically
This is almost always the fastest approach for well-formed JSON.
Method 2: Receiving JSON via Webhooks 🔗
If your JSON is coming from an external system — a form, an app, a third-party service — the Custom Webhook module is the right entry point.
When a webhook receives a JSON payload, Make automatically parses it and makes the fields available for mapping, provided you've run a test call to teach Make what the payload looks like.
The process:
- Create a Custom Webhook trigger module
- Copy the generated webhook URL
- Send a real or sample POST request to that URL with your JSON body
- Make captures the payload and prompts you to confirm the data structure
- All JSON fields become mappable throughout the rest of your scenario
This method requires no manual parsing — Make handles it automatically as long as the request uses Content-Type: application/json.
Method 3: Importing a JSON File From Storage
If your JSON lives in a file — in Google Drive, Dropbox, OneDrive, or another storage service — you'll need to retrieve the file contents first, then parse them.
General flow:
- Use the relevant storage module (e.g., Google Drive > Download a File) to retrieve the file
- The output is typically raw file data or text content
- Feed that content into the Parse JSON module as the JSON string input
- Define or generate the data structure as described above
One important variable here: file encoding and formatting. JSON files must be valid, well-formed JSON — trailing commas, unquoted keys, or other common formatting issues will cause the parse step to fail. Tools like JSONLint can validate your file before you bring it into Make.
Working With Nested and Array JSON Data
Not all JSON is flat. Deeply nested objects and arrays require additional handling in Make. 📋
| JSON Structure | Make Handling |
|---|---|
| Flat key-value pairs | Mapped directly after parsing |
| Nested objects | Accessed using dot notation in mapping (e.g., address.city) |
| Arrays | Requires an Iterator module to process each item individually |
| Arrays of objects | Iterator + downstream modules to handle each object's fields |
When your JSON contains arrays — for example, a list of orders or contacts — the Iterator module breaks the array into individual bundles, each processed separately by the rest of your scenario. This is a foundational Make concept worth understanding before working with complex data structures.
Variables That Affect How This Works for You
The right method depends on several factors specific to your setup:
Where is your JSON coming from? A live API call, a webhook trigger, a manually built string, or a stored file each require a different starting module.
How complex is the structure? Simple flat JSON is trivial to parse. Deeply nested or highly dynamic schemas require more careful data structure definition and possibly multiple Iterator modules.
How often does the schema change? If the JSON structure changes between runs, hardcoded data structures may break. Make does allow flexible structures, but this adds complexity to your mapping logic.
Your familiarity with JSON itself matters too. Users comfortable reading raw JSON will find the data structure generator intuitive. Those newer to JSON may need to spend time understanding how objects, arrays, and nesting work before the Make interface makes full sense.
API or webhook authentication and headers can also affect whether JSON payloads arrive correctly formatted — a common source of silent failures that look like parsing problems but are actually delivery problems.
How smoothly all of this comes together depends directly on the specifics of your data source, your scenario's structure, and how predictable your incoming JSON tends to be. 🔧