Academy

Unit 4 · Make Basics: Data

Data structures

10 min read Updated May 21, 2026

Unit introduction

Welcome to the fourth and final unit of this course.

Within this unit you will explore data structures.

In this short piece of content, you will:

  • discover what are data structures
  • learn how this relates to data types
  • understand how data structures are created

Data structure example

In the previous units you have learned about basic data types, collections, and arrays.

These can be combined together; a collection can contain simple data types, but also other collections; which can contain arrays, which in turn contain collections, etc.

When you want to call an API you always need to know what it expects as the input, and what it returns as an output. For example, does it need a single text data type with the ID of the contact you want to retrieve? Or does it need a complex “Contact” collection containing first name, last name and email if you want to create a new contact?

To describe the format of the data you send or receive, you need a data structure. The data structure description is the format of the information you send or receive, so that every app/module is able to correctly interpret it.

Let’s visualize this with an example. Let’s imagine information about a company and its employees.

Example Data

Contact: Acmake
  Name: Acmake
  Date of creation: 2024/01/01
  Yearly Income: 20.000.000
  Address:
    Street: 10th Main Road
    Postcode: 767777
    City: New-York
    Country: USA
  Employees:
    [
      First name: Jane
      Last name: Doe
      Date of birth: 1975/01/01
      Role: General Manager
    ]
    [
      First name: John
      Last name: Doe
      Date of birth: 1986/01/01
      Role: Sales Manager
    ]

Data Structure Description

Contact (Collection)
  Name: (text)
  Date of creation: (date)
  Yearly Income: (number)
  Address: (Collection)
    Street: (text)
    Postcode: (text)
    City: (text)
    Country: (text)
  Employees: (Array of Collections)
    [
      First name: (text)
      Last name: (text)
      Date of birth: (date)
      Role: (text)
    ]

Real life example

Let’s look at an example of where else a data structure may be used:

Ben wants to send Paul a parcel containing cheese. In order to send the parcel itself, there is a specific format Ben has to follow so the postal service knows where to send the parcel.

The postal company has a pre-defined format that he must use. This may be something like:

First and last name Street address Address Zip Code City Country

The postal service provided the data structure of an address, so that they understand who to deliver the parcel/letter to. And if Ben doesn’t follow this structure, there is a chance the delivery never arrives! No cheese for Paul!

Data structures are used outside Make as well (they are also called schemas) and they define the format of any data that is shared when providing or consuming a service. Different apps need a specific format to be able to communicate together.

What is a data structure? Why is it important?

When you want to use a module—e.g., Weather or Google Sheets—you have to understand the type of information the module needs and the type of information it returns. In the previous example of sending a parcel, you would need to know which fields are required for the parcel to be shipped to Paul.

That’s where data structures are used. They help describe what is required to exchange any information. Make uses data structures everywhere to allow you to map your items and to be able to transform the data into a different format if needed.

Collection

This is a collection called < Address >. You can recognize a collection thanks to the down arrow ↓ that appears to the left of Address. This collection contains multiple fields—< City >, < Street >, < Country >, etc.

Array

This is an Array. You can recognize an Array based on the [] which appear to the right of Employees. In this specific example, because of the down arrow ↓ you can identify that it’s an < Array of Collections >, that contains different fields such as < Role >, < First Name >, etc.

When you map a field contained in an Array, you can see the [ ]. It allows you to specify the index of the element you want to map. For instance, if the array contains 10 items, you can type [5] to obtain the 5th item. If you don’t type any number, Make will automatically pick the 1st item.

Individual Field

This is an individual field. It can be any simple data type, e.g., < text >, < number >, < date >, < boolean >.

How are data structures created?

You know now that in most instances, Make will automatically determine the Data Structure for you.

However, there are use cases where you may need to create the data structure yourself. For example, when you are using a data store within Make, or connecting to an external API.

Data structures are covered much later in the Make learning path in our advanced course, but it’s worth knowing what they are before you continue. If you want to learn more about data structures, view the content on Data Stores and Data Structures in Make Advanced.

Definition: An API is a service that is provided by SaaS applications (a software you access and use online without needing to install it on your device) to interact with them in a simple way. This is what Make uses to add a row to your Google Spreadsheet for example! Many APIs are already handled by Make (more than 1800 when this course was written), but some APIs are not known yet by Make, and in that case you have to build the data structure yourself.

Data Structure Automatically Generated by Make

Let’s look at an example of transferring information where the data structure is defined by Make – you don’t need to build this! The aim of this scenario is to Get a record from Salesforce which contains user data, and use this information to Create a contact of the same user within Google Contacts.

The output from Salesforce looks like a collection containing records with attributes such as Id, isDeleted, MasterRecordID, AccountID, LastName, FirstName, Salutation, Name, and Email. The data structure has been automatically provided by Make. You can directly map the fields from Salesforce with the next modules.

To create the contact, you need to map the relevant fields. For example, FirstName from Salesforce maps to First Name in Google Contacts, and LastName maps to Family Name. Even if the highlighted fields have different names, they represent the same data.

As data is being transferred from one app to another within Make, no data structure needs to be created or modified in any way. Make handled it for you; you just have to map fields from the Salesforce output to the Google → Create a Contact input.

Data Structure Manually Defined by the User

Let’s look at another example. Here we want to call the service of an application for which Make doesn’t have a proper App and Module. It requires us to directly call its API. You can learn more about this much later in the Make learning path in the API calls with HTTP modules course.

You already know the format of the Contact object coming from Salesforce, but Make can’t guess the format expected by the other application. You have to help Make know its data structure before you can do any transformation.

In this example, the destination application is not available in Make – meaning there is no apps or modules. But it does have an API available. In this case the destination is an online address book for a made up company called “Makebook”. Since Make doesn’t provide any App/Module for “Makebook”, you have to use the HTTP modules. This topic will be covered greater depth in Make Intermediate.

In order to create a new contact in “Makebook”, its API requires a specific format of data – usually you can find details of this in their online documentation. (Note: Makebook doesn’t exist, so you won’t find this in our documentation!) There is a 100% chance that this format is different than the one used by the Salesforce API. In that case, you have to manually create a new data structure that fits the format the “Makebook” API requires.

Let’s look at the data structures for Salesforce → Get a Record and how this compares to your “Makebook” data structure. The Salesforce output includes fields like LastName, FirstName, and Email. The “Makebook” Contact (Collection) might expect first name, middle name, last name, professional email, personal email, and country.

You have seen that the “Makebook” data format is quite different from the Salesforce data format. Once you have created the new data structure for “Makebook”, you can use the Create JSON module to map fields from the Salesforce output to the “Makebook” input. The transformed data is then sent to the “Makebook” API where it’s used to create a new contact. Without the new data structure, it would not have been possible to do any mapping to Makebook. In the first course of Make Advanced, you will learn how to create a new data structure.

Comparison

  • Automatic

    • Make is able to automatically determine the data structure of the output of any API endpoint/external service.
    • The Make team has already worked on the most common applications and services to define the data structure they expect or return. It means that you don’t need to build them manually.
    • The data structure automatically determined by Make can’t be manually modified. However, if you test a module when building a scenario, and if the format of the data has changed, Make will automatically adapt the corresponding data structure.

  • Manual

    • Even if a data structure is not available in Make, you can create as many as you want.
    • You can create a new data structure for any type of text document. For example, it can be for a CSV file where you define the column names, or it can be for the input of an external service, as seen in the comparison in this interaction.
    • Manual data structures can be modified anytime.

What does it look like in the Scenario builder? (1/2)

In the previous example, if you want to configure a new module, Make shows you a pop-up with all fields you can get from the response of the previous modules (A), and all the fields that are expected by the module you are configuring (B). From this pop-up, you can easily map all the fields you need.

In order to provide you with all this information, it uses data structures. Without them, you wouldn’t be able to do any mapping!

Most of the data structures are automatically handled by Make.

What does it look like in the Scenario builder? (2/2)

For most Make apps and modules, you don’t need to worry about their data structures. But there are cases when you need to create your own: for example, an external service that does not exist within Make, but has its own API.

This would require you to define your own data structure in order to transfer data to it.

The “Add data structure” panel shows:

  • Data structure name: company
  • Specification:
    • Name: Name

      Name of the property.

    • Type: Text
    • Default:

      Default value.