How to use Notion in Make - the ultimate guide (Integromat/Make)

Technology

Nov 17

I have worked as a Notion certified consultant and Make partner for a few years and used the Notion app in Make and the Notion API extensively. There are some core principles that are useful to know when it comes to using Notion in Make for automating your workflows. This essay explores those key principles without going into excessive details about the Notion API or each specific endpoint available in Make but providing frameworks on how to think about those, which you can then apply to automation more generally.

Make is a visual software that enables you to create automation without the need to use code. Automation can be valuable to your business and personal life if there are actions that you repeat and can be automated, hence freeing up time for other high-leverage activities. On the other hand, automation processes may require some maintenance over time as APIs may evolve or servers crash once in a while. So, documenting the automation you create can be a core principle to keep in mind, because this will benefit your future self significantly.

In this guide, we are delving into the world of Make by focusing on Notion. Notion is only one of the hundreds of tools you can integrate with Make (or other automation tools like Zapier, Pipedream, IFTTT, etc.). This is the main advantage of Make and similar tools—that you can merely choose the apps you want to use from a vast menu and do the bare minimum technical work to create automation.

Authentication and connection access

The first thing to know about using Notion in Make for automating your workflows is how to create a connection between the Notion workspace you intend to use and Make. Each connection can only access one Notion workspace. In this post, I am using “connection” and “integration” interchangeably. To create a connection between Notion and Make, you can follow these steps:

In your Notion workspace, navigate to “Settings & members” on the left sidebar menu
Open the “Connections” tab
Scroll down and select “Develop or manage integrations” (at this link). Here you will find all the integrations you have ever created in Notion, across all workspaces. That’s because integrations in Notion are tied to the user who creates them.
Click on “New integration”
Select the associated workspace you would like the integration to access. You need to be a workspace owner to be able to do this.
Give a name to the integration. Make sure it is a well-recognizable name for future-proofing your connection visible in the workspace. For example, if you know you will use this connection only for accessing Notion through Make, you may call it “Make bot” or similar.
Upload an image (optional)
Then submit the integration, show and copy the internal integration token
Navigate to the “Capabilities” tab and allow comments and user information access (unless you think you do not need those—you can always update these capabilities in the future).
Open Make
In the “Scenarios” tab, click “Create new scenario”
Click the “+” button and type “Notion”
Select the Notion app and one of the available modules depending on your needs (any module is okay at first if you don’t know what trigger you will use yet).
In the module, select “Add” next to the connection option
Paste the internal integration token in the dedicated box and save
You are done! Now, head over to the Notion workspace and ensure the integration has access to every database you will use in your automation. You can do so from the “Connections” option in the three dots at the top right corner of any Notion page/database.

Modules

Once the authentication process is established, you are ready to use the Notion app in your automated workflows in Make as needed. Before creating your scenario (the term used for “automation” in Make), it is beneficial to map out the process you intend to automate and the steps involved. This can be in the form of a text-based list of steps and conditions or drawn up in a diagram. This essay does not discuss this aspect of workflow automation as it only focuses on using the Notion app in Make. So, next, we are analyzing the available Notion modules in Make. Modules are API endpoints that you will also find in the Notion documentation. They can be divided into triggers (retrieving data) and actions (searching, creating, updating, or deleting data).

Triggers

Triggers are used for retrieving data from Notion databases/pages as there is a change. The change can be the creation of a page or an update of a page. In general, triggers can be of two types: webhooks, or polling triggers. Webhooks receive data instantaneously when there is a change in the object you are retrieving. Polling triggers receive data at specific intervals (e.g., every 5 minutes), bundling multiple data in one execution cycle and processing each one separately in the subsequent actions. The data not processed in one cycle will be stored and processed in the following execution cycle.

The trigger type depends on the API of the tool used. Not every API supports webhooks. This is the case for the Notion API too at the moment. Notion triggers only support polling data at a specified frequency as of November 2023. The minimum polling frequency in Make is every 1 minute for paid plans and every 15 minutes for free plans.

When opening the Notion app in Make, you will see all the trigger options grouped under the dedicated heading. The most frequently used trigger for the Notion API is “Watch database items”. This module enables you to retrieve data from a specific database at the creation or update of its pages. You can select whether you want to retrieve new or updated pages from the dedicated dropdown in the module in Make.

Actions

Actions can involve searching data in a database, retrieving blocks on a page, creating, updating, or deleting pages/blocks. Each action has a dedicated API endpoint and corresponding module in Make. Actions happen one at a time for each bundle of data processed by the trigger and preceding modules in the scenario. Two of the most used Notion action modules in Make include “Create a database item” and “Update a database item”. The former creates new pages in a database, while the latter updates pages in a database (i.e., updating property values for the pages specified). When using an action module in Make, you can map its values dynamically from previous modules (triggers or other actions). When using the “Update a database item” module, you will often use the “Search object” module right before it. This action module allows you to query a Notion database/page and retrieve its current data, including the page ID, which you need when using the “Update a database item” action module.

Using custom API calls referencing the API documentation

Sometimes you get to perform API calls that are not supported in the native Make modules but exist in the API of the tool. In such a case, you will use the “Make an API call” module, which is available in any app in Make. This “universal” module provides you with total freedom in making your custom API calls to the app of interest. For Notion, for example, there is no native “Delete a page” module in Make. As a consequence, should you develop a scenario that requires a page deletion, you will use the “Make an API call” module and follow the dedicated Notion API documentation to set up the API call. The advantage of this module is that the authentication process is already done, as it is connected to the Notion connection described in the first section of this essay.

This is the most vital information you need to know about using Notion in Make for automating workflows. You can then explore each specific trigger and action module on your own to delve deeper into the world of APIs and automation. To watch a specific use case of using Notion in Make, click here. For any questions or ideas on further topics I can write about, get in touch here.