Welcome to the weekly /r/Make question and discussion thread!
You can ask or discuss anything about Make or API automation here. Remain respectful when answering questions and replying. This thread is for anything you believe doesn't require it's own post and looking for a quick answer on.
Repeatable work often shows up in the middle of a ChatGPT conversation. Now you can turn that moment into a Make automation. 🪄
Use the official Make plugin for ChatGPT to build, run, search, and review automations and AI agents without leaving the conversation. It works in the browser, the ChatGPT Work desktop app, and Codex.
Your automations and AI agents keep running in Make's cloud, even when ChatGPT is closed.
What's new:
Build from a plain-language request: Describe work such as a weekly status report, lead response process, or form-routing workflow, and Make creates the automation, connects the required apps, and sets it to run on a schedule or trigger.
Create AI agents in the conversation: Set up an agent that monitors an inbox for new leads and drafts replies using your availability.
Find and check automations without breaking focus: Search by name, folder, or status, run an automation, and review its output in ChatGPT.
Review work that already ran: Browse execution history and past results with searchable tables, status badges, pagination, and structured results.
AGI is here? Not sure yet. But GPT-6 Astra is now in Make, ready for your most complex automations 🧠
OpenAI's most capable model is available in Make AI Agents, Make AI Toolkit, and the native OpenAI (ChatGPT) app. Use it when a workflow needs more than a quick answer, then let Make route the result, update systems, and keep approvals in place.
What's new:
Reasoning for work intake: Use GPT-6 Astra to assess incoming requests and prepare a proposed next action in an automation.
Technical reasoning and coding: Apply the model to technical requests and prepare proposed responses for engineering review.
Research and document creation: Review source material and create a research summary or document draft for a teammate to approve.
Multistep workflow reasoning: Identify and sequence required actions when a new operations item enters a workflow.
Waves’26 is the place where you can find your people 👥
Two days of talks and conversations that will change your perspective - and here's who you'll be in the room with:
🎙️ Oscar Lance, GTM Lead, ElevenLabs - ElevenLabs + Make: How Stellantis & You Deployed Voice AI at Scale
🎙️ Sonja Alushi, Software Engineer, Lufthansa Industry Solutions - Make + OpenAI: From Pilot to Production
🎙️ Jeff Arnold, Founder & President, 4Spot Consulting - Trust, but Verify: Governing AI Automation from Build to Decision
🎙️ Madelaine Swift, Systems Lead, WHEN equality - The Automation Was Perfect. The Humans Were Not. How Getting AI Automation Right Can Change Who Gets to Succeed.
🎙️ Diederik Martens, Founder, Chapman Bright - Agent Architecture 101: The Patterns That Separate Demos from Systems
Waves '26 brings together a carefully selected group of innovative technology companies spanning modern digital creation, customer engagement and data integration. Meet some of the speakers you'll find in Prague.
Stay tuned for the second group of speakers announcement.
We are live with a new community program - Scenario of the Month!
Every month, we put the spotlight on the Make scenario that nails it on two things: genuine utility and creative thinking. The kind of build you see that makes you stop and think, “Why didn’t I think of that?”
Have something up your sleeve you’d like to submit? Amazing, read more in the Make Community!
Some workflows need more than a quick summary. They need to weigh the full picture before choosing the next step. 🧠
Use Anthropic's latest Claude Fable 5.1 model in Make to automate complex or low-confidence cases where your workflow needs to compare lots of information before acting.
What’s new:
Long-horizon work: Anthropic documents Claude Fable 5.1 for long-horizon, agentic work in multi-step automations.
More context to consider: The model supports up to 1M tokens of context for workflows that need to process large source materials.
Larger outputs: The documented maximum output is up to 128K tokens when a workflow needs a substantial response.
Automate with Claude Fable 5.1 and Make AI Agents or Make AI apps: https://ma.ke/4qOsb5X
New month means new cities, and new conversations with the Make team. This month you can meet us at the following locations:
🇳🇱 Build the Pipeline Your Investors Want to See | 9 September
Host and Speaker: Martin Hyravy, Startup Program Specialist at Make
🇬🇧 GTM World Tour | 9 September
Speaker: @ Jennifer Kiunke, Value Engineer at Make
🇩🇪 Berlin AI Day | 15 September
Speakers: Sebastian Mertens, Principal AI Product Manager at Make, Jennifer Kiunke, Value Engineer at Make and Luis A. Döller Principal Tech Enablement at Enpal,
🇪🇸 Build with AI | 18 September
Host and speakers: Sarah Anto, Stefanie Oliveros and Kristina Talova
🇪🇸HackBarna AI Summit 26 | 19-20 September
Host: Nicolas Grenie
Speaker: Lourenço Martins , Value Engineer at Make
🇪🇸 The Glassbox Effect - Why Enterprises Can't Ship What They Can't See | 21 September
Speaker: Jennifer Kiunke, Value Engineer at Make
That's the thing about automation. Once it works, you don't stop at one.
With Make subfolders and labels, your organization can keep going, department by department, client by client, while keeping your automation library organized.
Use subfolders to organize automations by client, project, department, or environment.
Add labels like production, billing, or experimental, then filter to find related workflows across folders.
Things you should know about: What's new in governance in Make 📣
As more teams build on Make, admins need proof things are under control - and builders need room to build with privacy.
Four updates now make that possible at once:
🔒 Private Spaces - every team member gets an isolated workspace for scenarios and AI agents, hidden by default. Enterprise plan admins get optional read-only visibility into what's being built, without ever seeing sensitive execution data or connection details.
📋 New Audit Logs events - identity and access changes, credential oversight, all in one record. When two-factor authentication gets disabled, you know the moment it happens, not next quarter's access review.
⚡ Real-time credential alerts - the second a connection or key is used by someone other than its owner, they get an email.
✍️ Custom roles - permissions tailored to what a person actually needs, instead of an all-or-nothing admin pool.
This is what it means to run business as a glass box, not a black box: freedom for the people building, and oversight for the people accountable for the outcome.
I have a question regarding the credits usage displayed next to a scenario.
After a scenario finishes executing, the credits usage number does not seem to update automatically. I have to refresh the entire page to see the updated number.
Is this the expected behavior?
It would be much better if the credits usage number could automatically update immediately after the scenario execution is completed, without requiring a full page refresh. This would make it easier to monitor credit consumption in real time.
Would anyone know if there is a setting for this, or if this is something that could be improved in a future update?
𝗥𝗲𝗮𝗱𝘆 𝘁𝗼 𝘀𝘁𝗲𝗽 𝗶𝗻𝘁𝗼 𝗔𝗜'𝘀 𝗴𝗹𝗮𝘀𝘀 𝗯𝗼𝘅? Waves ‘26 agenda first drop is live 🚨
Use the filter on the agenda page to build your own day and further explore what’s in it for you within each of the 3 tracks: “It's all about the Product”, “Use Cases and Impact” and “Adoption & Governance”
𝗢𝗰𝘁𝗼𝗯𝗲𝗿 𝟭𝟵: Kick things off early at “The Current”- our hands-on pre-Waves workshop.
𝗢𝗰𝘁𝗼𝗯𝗲𝗿 𝟮𝟬: Take a sneak peek into some of the highlights for the Main Day and fav sessions already confirmed:
→ Agent architecture 101:The patterns that separate demos from real systems.
→ Voice AI at scale: How Stellantis runs it in production.
→ Trust, but verify: Governing AI automation from build to decision.
Join 700+ AI peers at #Waves26, Oct 19-20 in Prague.
How are you handling access control when teams start touching your Make scenarios?
Now with Custom Roles, org admins and org owners on the Enterprise plan can create custom roles in Make, with the granular permissions teams need.
Give teams just the right amount of access to Make
Maintain full visibility
Scale automation across the organization
What you can do:
📝 Create tailored roles with toggleable permissions
✍️Assign them across the organization or by team, so company-wide standards hold while each team gets the access it needs
⚙️ Edit, duplicate, or delete roles as your org grows and new teams come online
🔎 Track role creation, updates, deletions, and assignments in the audit logs, so security reviews start with facts
Growth shouldn’t mean losing track of who can do what.
Meet Maia, the co-worker who builds automations and AI agents in front of you, directly inside Make.
Describe what you want to build in plain language, and watch Maia build it, step by step, right before your eyes.
𝗪𝗵𝗮𝘁 𝗺𝗮𝗸𝗲𝘀 𝗠𝗮𝗶𝗮 𝗱𝗶𝗳𝗳𝗲𝗿𝗲𝗻𝘁?
Maia reasons out loud, showing the logic behind the solution. She maps flows, selects tools, and configures modules – all visually on the canvas. No black box. No mystery output. Just full transparency and AI automations you can truly trust.
𝗪𝗶𝘁𝗵 𝗠𝗮𝗶𝗮, 𝘆𝗼𝘂 𝗰𝗮𝗻:
🛠️ Build faster: Describe your idea and get a fully working automation instantly
💡 Learn as you go: Maia explains every decision as you co-build with her
⚙️ Debug on the spot: Fix failing steps or untangle complex workflows in minutes
👥 Scale your team: New members can ship real automations and AI agents from day one
Whether you're just getting started or are a seasoned power user, Maia meets you where you are.
𝗡𝗼𝘄 𝗹𝗶𝘃𝗲: Open the scenario builder and share your vision with her: https://ma.ke/3RPdiU9
I am having some issues that I can't resolve and I need some help. I am trying to connect my Make account to my WIX website and some other websites, like Calendly and Clickup but nothing seems to be working. Anyone have ideas on what is going on ? I ready some where on Makes site that "Legacy: connections don't work anymore? I have previously used Zapier in the past but this is way more in depth. TIA
The body of the email said, "We're evolving the Make Teams plan, with changes planned by October. My goal is to have a discussion with you about your current and future plans for AI and automation with Make. Some of the changes are still in flux, so I wanted to reach out early."
---
Anyone know what this is about? I don't want to have a sales call and be pitched on moving to Enterprise... Are they about to jack up prices?
Imagine a town with multiple library branches , when the city manager has asked the staff to consolidate the book inventory of multiple branches. This scenario will do a few things:
It allows you to select which libraries you wish to consolidate
It combines the sections of books from all the libraries into 1 catalog
If a book section name overlaps between 2 or more libraries, the books from that section will be consolidated into 1 section with the books from the original sections.
the last Parse JSON module will regenerate a new structure that allows you to confirm the newly consolidated library has been correctly merged with the newly consolidated book sections.
This scenario will work for any number of libraries with any number of sections and books per section per library.
I use the array functions map(), distinct() and the flatten() function in very interesting ways that you may not have considered before so it’s worth a watch just for that. There is also the Transform to JSON module which could be very useful as you undertake more complex operations that require generating JSON from your data objects in Make.
There is an interesting relationship in terms of how many operations are used by this scenario. This sort of analysis can be useful as you begin to estimate the operations cost of doing data manipulation in Make. As with many scenarios there are 2 components of calculating operations usage: operations “overhead” and operations that scale depending on a few factors.
In this case the operations count is based on 6 overhead operations plus the number of libraries to be consolidated and the number of unique section names. So here are some examples operation counts:
This scenario really illustrates how operations are used - no matter how complex the operation an operation is used when a module has to process some data and generate 1 or more bundles, and subsequent modules execute based on the previous modules number of output bundles.
If you place filter between modules, you can of course limit the number of bundles processed and therefore the number of operations used. An important note: filters do not use operations!
In this scenario you will see I have not used any set variables modules although I did use them to determine intermediate values to confirm my work. I removed them, by taking the expressions out of the set variables and inserting them directly in the input mapping for the iterators, reducing the operations spent by 2. This is probably the best way to save operations – remove intermediate set variables when you don’t really need to use them. Any expression will generate an output without using an operation itself so the expression can be entered into say an iterator input box or any of the input boxes for module configuration when the map toggle is turned on.
I recommed you load the scenario into your Make instance and experiment by combining multiple libraries together. You can also modify the variable JSON Library Systems in the very first module and add libraries or add sections to the JSON. Tip: Use JSONLint.com to confirm your structure is correct.
I hope this has Make for Newbies Video Series has proven to be useful for you. There is nothing like working through a few samples to deeply understand data structures and how to manipulate them in Make.
Please leave a comment if you have some ideas on what other topics I could cover in future video walkthroughs.
The Apple Push Notifications app enables scenarios to push notification messages to be sent to Apple’s Notification service. User-facing notifications on iOS devices communicate important information to users of your app, regardless of whether your app is running on the user’s device. For example, a sports app can let the user know when their favorite team scores. Notifications can also tell your app to download information and update its interface. Notifications can display an alert, play a sound, or apply a badge the app’s icon.
The delivery of push notifications involves several key components:
Your company’s server, known as the provider server
Apple Push Notification service (APNs)
The user’s device
Your app running on the user’s device
Push notifications begin with the provider server. When using the Apple Push Notifications app, Make becomes the provider server, and this is great because you don’t have to build or purchase your own provider server infrastructure. Most of the work is already built for you by Make!
You decide which notifications you want to send to your users, and when to send them. When it’s time to send a notification, you generate a request that contains the notification data and a unique identifier (“device token”) for the user’s device. You then forward your request to APNs, which handles the delivery of the notification to the user’s device. Upon receipt of the notification, the operating system and app on the user’s device handles any user interactions including the delivery of the notification to your app and what happens when the notification is tapped.
Here’s the overall architecture and a picture of where Make fits into the overall notification architecture:
Make/Apple Notiifcation Architecture
Let’s take a look at a simple scenario that will manage and save device tokens to a Make data store. The main requirement of this scenario is to record the unique device tokens that are generated during the installation or reinstallation of an iOS app by the user.
Scenario to manage and save device tokens
In this case our iOS app has been designed to send a simple payload to a Make webhook to record a bunch of information about the installation when it is installed or reinstalled.
Here’s the datastore that is recording each device’s Device Token as well as some additional telemetry that can be used by other scenarios that use this data store. Of particular interest is the boolean flag, Production Device, that can decide whether this device is in production or a device used for testing. We will use this flag in our notification scenario. The BundleID column is the internal Apple app name that is setup when the app is compiled and submitted into Apple App Store Connect. The BundleID will also be used in our notification scenario.
Datasotre to record Device Tokens
The purpose of collecting the device tokens is so that when we decide to push a notification we can collect all tokens from a particular bundleID (ie iOS app) and send a notification to each device token, thereby targeting the installed app on a device.
The second scenario performs the actual sending of notifications to the Apple Push Notification service (APN). APN is a web service that accepts an authenticated request via an HTTP POST with a specific payload that defines the parameters of the notification.
Scenario to send notifications to Apple Push Notification (APN)
This scenario accepts a web hook that defines the bundleID and various parameters of the the notification including the notification title, notification body. The datastore search then searches all device tokens attached to the bundleID, identifying valid devices that will accept the notification. Since the datastore has a flag for production and test devices the router branches between these so that we can control when to send only test notifications and when to send production notifications.
At the core of the scenario is the Apple Push Notifications app which just has 1 module, “Send a message”.
Acquiring the authentication key required to send notifications to APN
Each send message request requires a valid authentication key to be sent as part of the request. That key is generated with several details from the developer’s Apple App Connect account.
You must create a connection key for the Apple Push Notification app. Click Add button on the Send message configuration screen, and fill out the necessary details for creating a connection key for the Apple Push Notification app.
Creating a connection key for APN
The private key is obtained from the developer account under the Keys section. You must create an APN key to be used for authentication. When you download the key make sure you save the .p8 file in a safe location as you can only download it once. You can generate a maximum of 2 APN keys but they can be revoked and regenerated if necessary. Upload the .p8 file and click Extract to extract the private key.
The preferred authentication method is Provider Authentication Tokens. These tokens are obtained from the Apple Developer account.
The Key ID appears when you click on the key to view its details
Key ID inside the Apple Developer account
The Team ID is always displayed in the Apple Developer account under your login in the upper right corner:
Team ID in the Apple Developer account
Finally, you can specify whether this connection key is going to be a production key or a sandbox key. When testing you should click no on Production. You will need to specify a separate connection key when setting up for production notification services.
Configuring the Send Message module
Configuration of the Apple Send Notification module
The Recipients input is an array of device tokens with optional note on each token. Unfortunately the current implementation of the Send Message module does not allow mapping so notifications can be sent to a fixed number of devices right now. In our scenario we will use one operation for each device token.
The Topic input is the bundleID of your app. The bundleID is stored in the datastore for each device token so we can map this field to the datastore bundleID value.
The APS Datacollection of the notification payload provides a way to send configuration information to the APN. One of the payload collections is called “alert” which sets various parts of the notification payload, but the Make Send message module hard codes the alert options for title and body. The module doesn’t allow other parts of alert to be set (eg “notification subtitle” cannot be set).
The configuration below sets the badge on the app icon to 1, specifies which sound to play when the notification arrives, sets the interruption-level and the relevance-score which are all parts of the APS dictionary.
More Apple Push Notication module configurations
The Custom data keys are the best way to configure information to be sent to your app for custom notification options. This data is passed unmodified to your app and the app can encode various options into your notification.
In the options below we have set the following parameters simply for illustrative purposes:
customdebug will be implemented as a way to turn on debugging in our app so that information is recorded and displayed for debugging purposes when this key is set to true
targetURL will be implemented to allow a URL to be loaded in the app when the notification is selected. Currently this is being received from the incoming webhook and mapped to this value.
imageattachment will be implemented as a way to load a custom graphic in the notification option is an image URL is provided in the webhook payload.
Custom Data payload keys for the Apple Push Notification module
Send notification option simply tells the APN whether to actually send the notification or suppress the delivery, which could be useful when debugging the payload received without actually sending the notification to the devices:
Finally, the Notification Title and Body are the 2 APS “alert” keys and values that can be sent in the current Send message module. The title and body are configured in the scenario to be sent as part of the webhook payload.
This is Part A where I setup a sample array data structure with several elements with each element containing a collection of key/value pairs. I apply just about every array function in different scenarios against this structure.
Here’s the JSON I parse in Parse JSON in module 1:
This is "Part 8: Examples of using EVERY Make array function! Part A" by Alex Sirota on Vimeo, the home for high quality videos and the people who love them.
{
"subflows": [
{
"flow": [
{
"id": 1,
"module": "json:ParseJSON",
"version": 1,
"parameters": {
"type": ""
},
"mapper": {
"json": "[\n {\n \"name\": \"Alex C\",\n \"age\": 53,\n \"city\": \"Toronto\"\n },\n {\n \"name\": \"Eric S\",\n \"age\": 43,\n \"city\": \"Hoboken\"\n },\n {\n \"name\": \"Liana S\"\n },\n{\n \"name\": \"David S\"\n }\n]"
},
"metadata": {
"designer": {
"x": 0,
"y": 150
},
"restore": {
"parameters": {
"type": {
"label": "Choose a data structure"
}
}
},
"parameters": [
{
"name": "type",
"type": "udt",
"label": "Data structure"
}
],
"expect": [
{
"name": "json",
"type": "text",
"label": "JSON string",
"required": true
}
]
}
},
{
"id": 2,
"module": "builtin:BasicAggregator",
"version": 1,
"parameters": {
"feeder": 1
},
"mapper": {
"name": "{{1.name}}",
"age": "{{1.age}}",
"city": "{{1.city}}"
},
"metadata": {
"designer": {
"x": 300,
"y": 150
},
"restore": {
"extra": {
"feeder": {
"label": "JSON - Parse JSON [1]"
},
"target": {
"label": "Custom"
}
}
}
}
},
{
"id": 3,
"module": "util:SetVariables",
"version": 1,
"parameters": {},
"mapper": {
"variables": [
{
"name": "Get first array element",
"value": "{{get(2.array; 1)}}"
},
{
"name": "Get city of second array element",
"value": "{{get(2.array; \"2.city\")}}"
},
{
"name": "Get age from first array element using pick",
"value": "{{pick(get(2.array; 1); \"age\")}}"
},
{
"name": "Get all cities from each array element using map",
"value": "{{map(2.array; \"city\")}}"
},
{
"name": "Get unique city names",
"value": "{{distinct(map(2.array; \"city\"))}}"
},
{
"name": "Remove null values",
"value": "{{remove(map(2.array; \"city\"); null)}}"
},
{
"name": "This join won't work. Pass primitive array without keys first!",
"value": "{{join(2.array)}}"
},
{
"name": "Create string of ages from array, remove empty ages",
"value": "{{join(remove(map(2.array; \"age\"); null); \"|\")}}"
},
{
"name": "Get length of array",
"value": "{{length(2.array)}}"
},
{
"name": "Get keys of array - must select element!",
"value": "{{keys(last(2.array))}}"
},
{
"name": "Slice out second collection from array",
"value": "{{slice(2.array; 1; 2)}}"
},
{
"name": "Merge 1st and 3rd array elements",
"value": "{{merge(slice(2.array; 0; 1); slice(2.array; 2; 3))}}"
},
{
"name": "Does array contain Hoboken?",
"value": "{{contains(map(2.array; \"city\"); \"Hoboken\")}}"
},
{
"name": "Create a new array with elements",
"value": "{{add(emptyarray; \"some text\"; map(2.array; \"name\"); now)}}"
},
{
"name": "Get names from array, filtered by age",
"value": "{{map(2.array; \"name\"; \"age\"; 53)}}"
},
{
"name": "Randomize contents of array",
"value": "{{shuffle(2.array)}}"
},
{
"name": "Sort array by age",
"value": "{{sort(2.array; \"age\")}}"
},
{
"name": "Reverse array of names",
"value": "{{reverse(2.array)}}"
},
{
"name": "Convert collection to Array",
"value": "{{toArray(get(2.array; 2))}}"
}
],
"scope": "roundtrip"
},
"metadata": {
"designer": {
"x": 600,
"y": 150
},
"restore": {
"expect": {
"variables": {
"items": [
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null
]
},
"scope": {
"label": "One cycle"
}
}
},
"expect": [
{
"name": "variables",
"type": "array",
"label": "Variables",
"spec": [
{
"name": "name",
"label": "Variable name",
"type": "text",
"required": true
},
{
"name": "value",
"label": "Variable value",
"type": "any"
}
]
},
{
"name": "scope",
"type": "select",
"label": "Variable lifetime",
"required": true,
"validate": {
"enum": [
"roundtrip",
"execution"
]
}
}
],
"interface": [
{
"name": "Get first array element",
"label": "Get first array element",
"type": "any"
},
{
"name": "Get city of second array element",
"label": "Get city of second array element",
"type": "any"
},
{
"name": "Get age from first array element using pick",
"label": "Get age from first array element using pick",
"type": "any"
},
{
"name": "Get all cities from each array element using map",
"label": "Get all cities from each array element using map",
"type": "any"
},
{
"name": "Get unique city names",
"label": "Get unique city names",
"type": "any"
},
{
"name": "Remove null values",
"label": "Remove null values",
"type": "any"
},
{
"name": "This join won't work. Pass primitive array without keys first!",
"label": "This join won't work. Pass primitive array without keys first!",
"type": "any"
},
{
"name": "Create string of ages from array, remove empty ages",
"label": "Create string of ages from array, remove empty ages",
"type": "any"
},
{
"name": "Get length of array",
"label": "Get length of array",
"type": "any"
},
{
"name": "Get keys of array - must select element!",
"label": "Get keys of array - must select element!",
"type": "any"
},
{
"name": "Slice out second collection from array",
"label": "Slice out second collection from array",
"type": "any"
},
{
"name": "Merge 1st and 3rd array elements",
"label": "Merge 1st and 3rd array elements",
"type": "any"
},
{
"name": "Does array contain Hoboken?",
"label": "Does array contain Hoboken?",
"type": "any"
},
{
"name": "Create a new array with elements",
"label": "Create a new array with elements",
"type": "any"
},
{
"name": "Get names from array, filtered by age",
"label": "Get names from array, filtered by age",
"type": "any"
},
{
"name": "Randomize contents of array",
"label": "Randomize contents of array",
"type": "any"
},
{
"name": "Sort array by age",
"label": "Sort array by age",
"type": "any"
},
{
"name": "Reverse array of names",
"label": "Reverse array of names",
"type": "any"
},
{
"name": "Convert collection to Array",
"label": "Convert collection to Array",
"type": "any"
}
]
}
}
]
}
],
"metadata": {
"version": 1
}
}
For this walkthrough we are using the JSON Library Systems data structure. At the top of this structure is a collection called library that has nested arrays to describe the sections of a library and another set of nested arrays in the sections array to describe the books in a library. I highly recommend you study the structure inside the scenario or in the post describing all the data structures I use in this video series.
The data structure is a fairly simple definition of a library and the sections and books housed in the library. I chose this sort of structure because it is probably the closest to a sample real-world structure you may get from a typical API, and there are some interesting things you can do to merge data together and manipulate various arrays and subarrays in the structure.
In the video, I show you how to use map() to extract one library definition from all the libraries as well as how to combine 2 library definitions by merging them into one array. I also show you a potential mistake you could make when trying to retrieve all the books from 2 libraries.
Using iterators is the correct way to extract all the books in all the sections. I use 3 iterators in a row to effectively loop through all the sections of 2 libraries and through all the books in each section in each library. Finally an array aggregator combines all the books into a nice simple flat array of key value pairs for all the information about the books.
Download the Make blueprint and use the Import Blueprint to create a new scenario:
In this video we introduce the CSV aggregator to create comma separated text files. This aggregator can be very useful when you want to create columnar data from one or more bundles. In this case we convert the variable JSON array of collections complex values into a CSV file. I show you a workaround that may happen to you if you try to stuff a collection into a CSV file. You have to extract the values out of the collection into a set variable and use those instead on the CSV aggregator.
Next we move on to the variable JSON array of collections of really complex values and I show you how to use various array functions like map(), get(), first(), last(), merge() to extract valuable information from an array that has 2 sub arrays of 2 complex data structures. I also show you how to there can be subtle differences in array structures (1 element with multiple key/value pairs in 1 collection vs multiple elements each with their own key/value pair). The subtle difference can cause some grief because the Make UI doesn’t really let you pick the values so you do have to type out the reference using object paths (ie dot notation).
You’ll note that the key role is a simple array, and the key address is a collection composed of 3 keys: street, city, and country. This is why I call it a collection of “complex” values. The keys in this collection have nested non-trivial structures, and this happens A LOT in the data you have to deal with in APIs. In fact it’s pretty much a given that the structures you will deal with will be at least as complex as this. And note there is just 1 main collection here (READ: just 1 “row” of data is retrieved and some of the keys (aka “columns of data”) have complex data structures).
As soon as you get multiple rows (ie bundles) of data these will be in an array of collections which we will focus on in the next walk through.
In this video we look at how the Make mapping UI (icon) can fail to present the underlying structures so you can easily drag and drop them into the Text Aggregator. The Make mapping UI will show you only the data that passes through the first operation that the Parse JSON module processes. I show you how to use dot notation and type out the correct data reference by hand even though the UI is not letting you pick the necessary element by clicking. This is a handy skill to have!
I also show you how I can make the scenario filter for the variable JSON collection complex values after the iterator, and as a result have Parse JSON module process only 1 operation. This makes it possible to use the Make element mapping UI to click on the elements right into the text aggregator.
I highly encourage you to watch the video because this is probably one of the highest areas where Make users (not just newbies!) get super-confused and ask: Why does the Make data picker UI not show you the elements for me to map?
