Unit introduction
You are now at the second unit of the “Introduction to HTTP” course within Make Intermediate.
In the previous unit you learned about the basics of HTTP.
Now you will start to build on that knowledge and put it into practice by exploring the GET request method, and building a scenario to show it in action.
Element - MCQ
Let’s start with a question - which of the following best describes what the GET request method does?
The correct answer is: Requests data from a server.
GET will: request data from a server. Make can then use this data to pass it to other modules. As we explored in the previous module, GET was used to list events in Google Forms, and export them to Airtable / Slack.
Scenario 1 - Use GET on a website
GET can retrieve the data of any site, but the data may not be usable within Make. Let’s create a scenario where you see what an output bundle from a website looks like.
To begin, create a new scenario and name it GET-Test. Search for the HTTP app and select the Make a request module. For the Authentication type, select No authentication. For the URL, type in https://www.google.com. For the Method, select GET. Click OK to save the module settings. Save your scenario, and click Run once. This action will send a GET request to https://www.google.com.
After running the scenario, view the output bundle. First, look at the status code. If you recall from earlier, a 200 status code means the server received and processed your request. Clicking Run once in your scenario was the equivalent of clicking a hyperlink or typing an address in your browser. Every time you make any kind of HTTP request, you will receive a status code in your output bundle to indicate the status of the request.
Next, expand the Data field. Notice that this is classified as a (Long String) rather than a (Collection) or an (Array)? This is because the data that you are retrieving is a single HTML string from the Google homepage. There isn’t too much you can do with data in this format, but it shows the output of a website using GET. When you run this module, it is the equivalent to clicking a hyperlink, or entering https://www.google.com into your web address bar. Your browser understands this HTML code and “translates” it into a visual webpage, while Make just outputs the raw code.
Let’s summarize this exercise: When Make does a GET request to an API, this information will appear vastly different, and will present you with data that you can use within your Make scenarios. When you use the GET method on a website as you did here, your data will be presented in a long string. When you use the GET method through API, your data can be presented as a collection / array.
Scenario 2 – Use GET to retrieve a collection/array
Let’s explore using HTTP GET to import data that you can use within your Make scenarios.
In this activity, you are going to import some familiar data using HTTP GET. If you have worked through course 2 (Using get() and map() functions), you will be using the same set of data, but instead of parsing it, you will use the GET method to retrieve this data.
Create a new scenario and name it Make Intermediate 3-2. Search for HTTP and select the Make a request module.
In the URL field, copy and paste the address. Ensure that under Method, you select the GET method. Click Parse response — this is really important, as the data that you retrieve will be converted into a presentable collection/array. Click OK and save your scenario.
Click Run once and open the input/output. Expand the Data + field. Did you notice that this time the data type is a (Collection), rather than the (Long String) that was on the previous example? This is because the data is in a JSON format, rather than a long HTML string.
Using GET here will import, parse, and then display the shopping_basket collection that was used in the previous course! This contains an array with several items.
Now you have an array of items, you can start to utilize these any way you want. It’s created a set of items that can be mapped within Make! These act like any other items that you map from app APIs, they’re just retrieved via a HTTP method.
To further process this data, add a Set multiple variables module. In this module, you can use the sort() function. Expand the data field and then expand the shopping_basket array. This should start to look familiar to the scenario in course 2 of Intermediate!
Type ; and "desc", and then "item_price". Your completed function should look like this:
sort(1.data.shopping_basket.items;desc;item_price)
Click Run once to execute your scenario. Open the output of your Set multiple variables module. You should see an array of clothing items that are sorted by price.
Scenario summary
Let’s break down and summarize what has happened in each scenario. This is a very basic overview of what the HTTP GET request method can do in Make.
Scenario 1
Scenario 1 uses the GET request on a website, which returns the HTML code. There isn’t much that you can do with this in Make, but it demonstrates that you can use this on any online resource. For example, you could use the GET request to import an image from a site, which can then be embedded as a part of a message.
Scenario 2
Scenario 2 has retrieved a set of data from a link that we have provided.
Note: This could be any app that does not exist in Make currently that has API capabilities.
Because you selected the parse data option, this has formatted your data so that it is in a format that you can use within Make: a collection containing array. If you are connecting to APIs there are a few more steps you would have to follow, such as security settings, which we will cover in Make Advanced qualification. But as a concept this will give you an idea of what the HTTP app can achieve.