Academy

Unit 1 · Make Intermediate: JSON and Arrays

Importing JSON into a scenario

8 min read Updated May 21, 2026

Unit introduction

Welcome to the first unit of the Make Intermediate learning path.

Let’s make a start on exploring a new set of concepts, shall we?

In the first unit, you’ll explore:

  • what is JSON
  • how to create an array

And a really important module that you will use for the rest of the Learning Path: Parse JSON.

As the aim of this course focuses around iterators and aggregators within Make, you need to be able to create your own custom array. The Parse JSON module will help you with that!

JSON

What is JSON?

To put simply, JSON (JavaScript Object Notation) is a data format used for exchanging and storing information between different systems. It provides a simple and organized structure to represent information.

A variable in JSON is like a container that holds related data together. Variables are stored between { and }.

JSON is composed of key-value pairs, where each key is a label and each value is the data. An easier way to remember this is:

  • key = property
  • value = property value

Think of a variable a single piece of fruit (an apple) which has numerous keys (calories, taste, seeds) each having a value (52, sweet, true).

"apple": {
  "outerColor": "red",
  "innerColor": "white",
  "hasSeeds": true,
  "calories": 52,
  "taste": "sweet"
}

An example

For example, an individual’s information can be represented like this using JSON:

{
  "name": "Bruno",
  "age": 25,
  "driver's license": true
}

In this example, the variable represents a person. The key represents the label of the data: name / age / driver's license. The value represents the data: Bruno / 25 / true.

A quick note about data types

  • A string will always use quotes (" ") and will output a text data type.
  • Numbers do not require quotes to be parsed, and will output a number data type.
  • Using true/false (lowercase) without quotes will output a boolean data type.
  • If however you type "true" or "True" within quotes, this will output a text data type.

Data types were covered in unit 1 of An introduction to data types and data structures.

Do I need to learn how to code?

No! This is why Make is a great tool, it will do a lot of the work for you!

The main reason to discuss JSON is for bundles.

JSON - in particular the Parse JSON module, can be used to create bundles that contain custom arrays.

If you are unsure what an array is, you should first complete A brief introduction to Data Types.

JSON in Make

Make uses JSON to pass information between modules - when you download/upload a blueprint, it’s composed of JSON, and when you produce a bundle, this too is composed of JSON.

Over the next few courses you’re going to build custom bundles, and then use various modules within Make to manipulate these bundles.

We’ll provide you with some JSON to put into your module, which will be used as the basis throughout this entire course.

Element - text / text and image (Portrait) - LARGE

The module that you will use to create sample data is called Parse JSON.

Parsing is the process of analyzing and understanding the structure of data, and then arranging that data in an understandable and usable way.

Let’s look at an example: you have a JSON file that represents information about a person:

  • name
  • dietary restrictions
  • musical preferences

Parsing JSON will enable these fields to be usable and easier to work with in Make.

This means that when you insert an array of JSON into this module, Make will output an array of bundles based on the amount of objects within the array, so that it will be more usable in Make.

For example if you have 1 variable in your input JSON array, this will equal 1 bundle. If you have 3 variables = 3 bundles, and so on.

Name Michael Dietary_ restriction none musical_ preference Rap

{ "name": "Michael", "dietary_restriction": "none", "musical_preference": "Rap" }

Parsing your first JSON

The aim of this scenario is to create an array of guests for a party you are hosting.

To parse your first JSON, you will use the Parse JSON module. In its configuration, you’ll see a Data structure option, which you can ignore for this exercise. Instead, click within the JSON string field and paste the following JSON string:

{"all guests": [ { "name": "Paul", "dietary preference": "vegan", "preferred music": "indie" }, { "name": "Ivana", "dietary preference": "none", "preferred music": "rap" }, { "name": "Lukas", "dietary preference": "vegetarian", "preferred music": "rock" }, { "name": "Noona", "dietary preference": "vegetarian", "preferred music": "rock" } ] }

Once the JSON string is pasted, click OK to save the module configuration. Then, run the scenario once by clicking Run once.

After running the module, view your output bundle from the Parse JSON module. You will notice that it has produced an organized array. This array is named all guests. The array contains 4 collections, each representing a guest with their name, dietary preference, and preferred music.

The output bundle will look like this:

Bundle 1: (Collection)
  all guests: (Array)
    1 (Collection)
      name: Paul
      dietary preference: vegan
      preferred music: indie
    2 (Collection)
      name: Ivana
      dietary preference: none
      preferred music: rap
    3 (Collection)
      name: Lukas
      dietary preference: vegetarian
      preferred music: rock
    4 (Collection)
      name: Noona
      dietary preference: vegetarian
      preferred music: rock

This concludes the exercise for this unit. Next, let’s examine the output in more detail.

Parsing your first JSON (using a template)

Work through each stage of this activity before you continue.

To begin, open a predefined template for this exercise. Click +Use this scenario.

This loads a template containing a single module: JSON → Parse JSON. Click the Parse JSON module to view its contents.

This is how the JSON string within your module will look:

{
  "all_guests": [
    {
      "name": "Paul",
      "dietary_preference": "vegan",
      "preferred_music": "indie"
    },
    {
      "name": "Ivana",
      "dietary_preference": "none",
      "preferred_music": "rap"
    },
    {
      "name": "Lukas",
      "dietary_preference": "vegetarian",
      "preferred_music": "rock"
    }
  ]
}

It doesn’t make much sense right? Let’s explore what happens when you run this module. Click OK, and then right click the module, and select Run this module only.

View your output bundle from the Parse JSON module. Notice that it has produced an organized array.

This array is named all_guests. The array contains 3 collections. Open each collection to reveal a name, dietary preference, and preferred music. The output bundle will look like this:

Bundle 1: (Collection)
└── all_guests: (Array)
    ├── 1 (Collection)
    │   ├── name: Paul
    │   ├── dietary_preference: vegan
    │   └── preferred_music: indie
    ├── 2 (Collection)
    │   ├── name: Ivana
    │   ├── dietary_preference: none
    │   └── preferred_music: rap
    └── 3 (Collection)
        ├── name: Lukas
        ├── dietary_preference: vegetarian
        └── preferred_music: rock

Great! This concludes the exercise for this unit.

Parsing your first JSON

Work through each stage of this activity before you continue.

Let’s get started! Create a new scenario and name it Make Intermediate 1-1. The aim of this scenario is to create an array of guests for a party you are hosting. Click on the add module (+), search for the JSON module, and then select Parse JSON.

Under Data structure you have the option to add your own data structure – ignore this. Instead, click within the JSON string field. Copy the following JSON and paste it into the JSON string field: {"all_guests": [ {"name": "Paul", "dietary_preference": "vegan", "preferred_music": "indie"}, {"name": "Ivana", "dietary_preference": "none", "preferred_music": "rap"}, {"name": "Lukas", "dietary_preference": "vegetarian", "preferred_music": "rock"} ]}

This is how your module should look. Let’s explore what happens when you run this module. Click OK, and then right-click the module, and select Run this module only.

View your output bundle from the Parse JSON module. Notice that it has produced an organized array. This array is named all_guests. The array contains 3 collections. Open each collection to reveal a name, dietary preference, and preferred music.

The output bundle will show:

  • all_guests (Array)
    • 1 (Collection)
      • name: Paul
      • dietary_preference: vegan
      • preferred_music: indie
    • 2 (Collection)
      • name: Ivana
      • dietary_preference: none
      • preferred_music: rap
    • 3 (Collection)
      • name: Lukas
      • dietary_preference: vegetarian
      • preferred_music: rock

Great! This concludes the exercise for this unit. Next, let’s examine the output.

Input vs Output

Let’s compare part of the JSON string (input) and the array (output).

Your input JSON string opens and closes with { and }, and the array definition is contained within quotation marks “like_this”. In the output bundle, all_guests is the definition of the array.

As covered in An introduction to Collections and Arrays, an array is a list of objects.

The beginning and end of the array are contained between [ and ], and the collection boundaries (or the variable) are defined between { and }. For example: {"array title": [{"collection"}, {"collection"}, {"collection"}]}. This collection contains several properties and property values, which in this example define a user’s name. Thinking back to key and value from earlier, the key is “name”, and the value is “Paul”.

In both the input and output, each key and value are divided by a colon (:). For example “dietary preference” : “vegan”. Each subsequent key/value in the collection is separated using a comma (,), for example “key1”:“value 1”, “key2”:“value2”, “key3”:“value 3”.

As ‘preferred_music’ is the last key-value pair, the collection is closed with }. This structure forms the basis for a single collection: {"array title":[{"collection":{"key":"value","key":"value"}}]}.