How to Import JSON Data Into Make

What importing JSON into Make actually does

Importing JSON into Make means taking structured data from a JSON file or API response and feeding it into a Make workflow so your automations can read and act on it. Make (formerly Zapier's competitor, now its own platform) accepts JSON through a few routes: directly pasting it into a module, pulling it from a file stored in cloud storage like Google Drive or Dropbox, or receiving it from an API endpoint. The JSON arrives as a data object that Make's modules can then parse, filter, transform, or pass to other apps in your workflow.

Most people import JSON because they have data sitting in one place — a database export, an API response, a form submission result — and they need to move it somewhere else or act on it conditionally. Make doesn't store the JSON itself; it processes it as it flows through your workflow, so you're not creating a permanent database inside Make.

Key Takeaways

JSON enters Make through three main paths: pasted directly into a module, uploaded from cloud storage, or received from an API call that returns JSON data.
The JSON Parser module is the tool that converts raw JSON text into data Make's other modules can actually use and reference.
You reference parsed JSON fields in later steps using dot notation — if your JSON has a field called "customer_name", you reference it as data.customer_name in subsequent modules.
Make's built-in JSON functions (like parseJson() and stringifyJson()) let you transform JSON on the fly without a separate module if you're comfortable with formulas.

Importing JSON by pasting it directly into a module

The simplest route is to paste JSON text directly into a Make module when you're testing or working with small, static datasets. Open the module where you want the JSON to land, find the field that accepts data input, and paste your JSON string. Make will recognize it as text at first, so you'll need to parse it in the next step.

This approach works best for small files or when you're building a proof-of-concept. If your JSON is large or changes frequently, this becomes tedious and error-prone. Most workflows that run repeatedly use one of the other two methods instead.

Pulling JSON from cloud storage files

If your JSON lives in a file on Google Drive, Dropbox, OneDrive, or another cloud storage service, Make can fetch it directly. Add a module for your storage provider — Google Drive, Dropbox, etc. — and configure it to retrieve the file. Make will pull the file contents as text. From there, you pipe that text into a JSON Parser module, which converts it into structured data your workflow can use.

This method is reliable for workflows that run on a schedule or are triggered by a file upload. The file stays in your cloud storage as the source of truth, and Make reads it fresh each time the workflow runs. If the file changes, your workflow automatically works with the new data on the next run.

Receiving JSON from an API or webhook

Many workflows receive JSON from an external API or a webhook trigger. When an API returns JSON, Make automatically parses it in most cases — you don't need a separate JSON Parser step. You can reference the fields from that JSON response directly in your next module using the field names Make displays.

If Make doesn't auto-parse the response (which is rare), or if you receive JSON as a raw string that needs parsing, add a JSON Parser module and feed it the response. Webhooks work the same way: when an external service sends JSON to your Make webhook URL, Make receives it and makes the fields available to downstream modules.

Using the JSON Parser module to convert text to usable data

The JSON Parser module is Make's tool for turning raw JSON text into structured data. Add it to your workflow, paste or map your JSON text into the "JSON string" field, and run the module. Make parses it and outputs an object with all your fields accessible by name.

If your JSON is malformed or contains syntax errors, the parser will fail and stop your workflow. Before running a large workflow, test your JSON in a JSON validator (search "JSON validator" in your browser) to catch errors early. Once parsed successfully, you reference each field in later modules — a field called "email" becomes data.email, a nested field like "user.address.city" becomes data.user.address.city.

Referencing JSON fields in later workflow steps

After JSON is parsed, Make displays all available fields in a dropdown menu when you click into a field in the next module. Click the field you want to insert, and Make adds the correct reference automatically. If you're writing a formula or condition, use dot notation: data.fieldname for top-level fields, data.parent.child for nested fields.

Arrays in JSON (fields containing multiple items in brackets) appear as arrays in Make. If you need to loop through each item, use Make's Iterator module to split the array into individual items, then process each one. This is common when you import JSON containing a list of customers, orders, or other repeated records.

Transforming JSON with formulas instead of modules

For simple transformations, you can use Make's built-in JSON functions directly in a formula field instead of adding extra modules. The parseJson() function converts a JSON string to an object, and stringifyJson() converts an object back to a JSON string. These are useful when you need to manipulate JSON on the fly or combine multiple JSON sources.

For example, if you receive JSON from two different APIs and need to merge them, you can use formulas to combine the objects before passing them to your next step. This keeps your workflow leaner than adding multiple parser modules. However, for complex transformations, a dedicated module is usually clearer and easier to debug.

Frequently Asked Questions

What happens if my JSON has a syntax error?

Make's JSON Parser will fail and stop your workflow with an error message. Check your JSON in an online validator before importing. Common errors include missing commas between fields, unmatched brackets, or quotes around string values. Fix the JSON at the source, then re-run your workflow.

Can I import JSON from a URL or API endpoint directly?

Yes. Use Make's HTTP module to call the URL, set the method to GET, and the response will return JSON. Make auto-parses it in most cases, so you can reference the fields immediately in your next step. If the API requires authentication, configure that in the HTTP module's headers or auth section.

How do I handle JSON arrays with multiple objects?

Use Make's Iterator module after parsing. Set it to iterate over the array, and Make will loop through each object one at a time. In each loop iteration, you can reference the current object's fields and send them to other apps or modules. This is how you process a JSON file containing 100 customer records one by one.

Can I map JSON fields to a Google Sheet or database?

Yes. After parsing your JSON, add a module for Google Sheets, Airtable, or your database. Map the JSON fields to the columns or fields in your destination. Make will create or update records with the data from your JSON. This is a common way to import JSON data into a tool you can query and analyze later.

What's the difference between parsing JSON and stringifying it?

Parsing converts JSON text into an object Make can work with. Stringifying does the opposite — it converts an object back into JSON text. You stringify when you need to send data to an API that expects JSON, or when you want to store the data as a JSON string in a database or file.

This guide is for general information only and is not medical, financial, legal, or other professional advice. For decisions specific to your situation, consult a qualified professional. See our Editorial Policy.