
## What can I automate with Make?
Make has 1000s of integrations including Google Contacts, Airtable, Google Sheets and Excel. We've found it particularly good at integrating with the Microsoft 365 Office suite of apps and can also use the Microsoft Graph API. Make automation workflows can have many triggers and the custom Webhook and Mailhooks are particularly useful.

## How much does Make cost? 
Make has a free account that allows up to 1,000 operations a month. The other standard plans range from $9 - $29 (USD) per month (charged annually).

## How can I learn how to use Make?
You can learn with our Make tutorials below or join the [Make Community](https://community.make.com/).

Make.com is a web-based visual automation workflow builder that integrates with 1000s of your apps and services. Make.com was formerly called Integromat.

Make

## Overview
In this tutorial, we will demonstrate how to integrate your Outlook calendar events into Obsidian daily notes using Make and the Templater plugin. This powerful combination allows you to automatically populate your daily notes with meeting details and provides an efficient way to manage your schedule and notes all in one place

[How I get calendar events into my Obsidian Daily Note](https://www.youtube.com/watch?v=o2JH_jIKY_Q)

## Flow
[![](https://mermaid.ink/img/pako:eNplkm9PwjAQxr_KpYZ3SOJfzF6Y4GCKESFgNHH1RdkOaeh6S9uZELbvbjdgxPiq7d3vuXuu7Y4llCILWKezk1q6YMeZW2OGnAWcLYX1my4cYu_CSLFUaH0SPJgbmQmzDUmRafiz_kUURaO9xGJCOv2bjwZ34bDPWVVVnQ7XXH8bka_hZc71IJ4WThFtIBQKa-EXnJ_fl4PZuI6oEh7iidhgL6EMFglqb4a-uH5oqIsefOBy7eUlhHFYWOepQ6SFLnswkYkhSysHV7c3bSc4NRnGj-hg9IPa2VZ41YM3I7RdkcnAETwvpq8ljOJ6PWWEk6RbzXXrCOZoc9IWS4j2kmPAw4_xdGllKoVuxoWn-A2zXAmHBmaq-JZ1xaemYm2sdbx3CC1cwvh0PcfG9UhePm7k4ywn869CCc_xUEi1hVdytSHWZRn6YWTqf8WOa4DTj_Bbr9xwxnXluSJPfetRKh0ZFqyEsthlonC02OqEBc4UeISGUvinzloqF_qT6HiufgHrVtuC?type=png)](https://mermaid.live/edit#pako:eNplkm9PwjAQxr_KpYZ3SOJfzF6Y4GCKESFgNHH1RdkOaeh6S9uZELbvbjdgxPiq7d3vuXuu7Y4llCILWKezk1q6YMeZW2OGnAWcLYX1my4cYu_CSLFUaH0SPJgbmQmzDUmRafiz_kUURaO9xGJCOv2bjwZ34bDPWVVVnQ7XXH8bka_hZc71IJ4WThFtIBQKa-EXnJ_fl4PZuI6oEh7iidhgL6EMFglqb4a-uH5oqIsefOBy7eUlhHFYWOepQ6SFLnswkYkhSysHV7c3bSc4NRnGj-hg9IPa2VZ41YM3I7RdkcnAETwvpq8ljOJ6PWWEk6RbzXXrCOZoc9IWS4j2kmPAw4_xdGllKoVuxoWn-A2zXAmHBmaq-JZ1xaemYm2sdbx3CC1cwvh0PcfG9UhePm7k4ywn869CCc_xUEi1hVdytSHWZRn6YWTqf8WOa4DTj_Bbr9xwxnXluSJPfetRKh0ZFqyEsthlonC02OqEBc4UeISGUvinzloqF_qT6HiufgHrVtuC)

```mermaidignore
%%{init:{"theme":"base", "themeVariables": {"primaryColor":"#71FFFE", "secondaryColor":"#FA8CD7"}}}%%

  

graph LR

A[Outlook Calendar] -->|API Call| B[Make.com Scenario]

B -->|1. Webhook| C[Custom Webhook]

B -->|2. Microsoft 365 Calendar API Call| D[Get Events]

B -->|3. Transform to JSON| E[JSON Transformation]

B -->|4. Webhook Response| F[JSON Response]

G[Obsidian] --> H[Templater Plugin]

H -->|Get Calendar Events Templater| I[Make.com Webhook Call]

I -->|Import Calendar Events| J[Daily Note]
```

## How to recreate this automation
### Resources
- [Obsidian](https://obsidian.md)
- [Templater plugin for Obsidian](https://github.com/SilentVoid13/Templater)
- [Make.com](https://www.make.com/en/register?pc=rymawby)

### Step 1: Create a Make.com Scenario
![Completed scenario will look like this](https://ry.d.pr/i/x6MJRz.png)
1. Log in to your Make.com account and create a new scenario.
2. Add a Webhook module with a Custom Webhook.
3. Name the webhook and add any necessary security measures, then copy the unique URL provided.
![Create a webhook](https://ry.d.pr/i/WqY4Ty.png)



### Step 2: Set up the Outlook Calendar Connection
1. In the Make.com scenario, add a Microsoft 365 Calendar module and choose the API call option.
2. Configure the API call using the date parameter passed from the webhook, adjusting the time zone if necessary.
![The Outlook 365 Calendar node](https://ry.d.pr/i/QeHxH5.png)

### Step 3: Transform the Data to JSON
1. Add a JSON module to the scenario and choose the "Transform to JSON" option.
2. Select the body returned from the previous step as the object to transform.
![JSON Transform node](https://ry.d.pr/i/GhnomZ.png)

### Step 4: Create a Webhook Response
1. Add a Webhook Response module to the scenario and set the status to 200.
2. In the body, use the JSON string created in the previous step.
3. Save the scenario and run it once to test the setup.
![Webhook response node](https://ry.d.pr/i/tZzeOJ.png)


### Step 5: Configure the Templater Plugin in Obsidian
1. Install the Templater plugin in Obsidian and create a new template.
2. In the template, write the code to call the Make.com webhook, ignore specified subjects, and output the events as Markdown text.
3. Save the template in a designated folder in Obsidian. Here is the code we used for our Templater plugin.
```
<%*
async function getDataFromAPI() {

const ignoredSubjects = ['SR', 'Standup/Knowledge Share', 'Review Day/Write up notes', 'Friday Afternoon Internal Meeting Free Zone'];
var ret = ''

try {
  const dateToRequest = tp.file.title;
  const response = await fetch('https://hook.eu1.make.com/12345678?date=' + dateToRequest);
  
  const data = await response.json();
  
	console.log('returned data')
  data.map((item) => {
    if (!ignoredSubjects.includes(item.subject)) {
      const line = '### ' + item.subject;
      console.log(line);
      ret += line + '\n' + '\n';
    }
  });
} catch (error) {
  console.error(error);
}

return ret;

}

tR += await getDataFromAPI();
%>
```


### Step 6: Integrate the Templater Template into Daily Notes
1. In your Obsidian daily note template, add the code `tp.file.Include` followed by the name of the Templater template created in Step 5.
2. This will ensure that the calendar events are imported each time a new daily note is created.

With this setup, your Outlook calendar events will be dynamically imported into your Obsidian daily notes, allowing you to easily manage your schedule and meeting notes in one place. This method can also be adapted to integrate other APIs or personal data using Make.com or similar automation platforms.

Learn how to get external data into your Obsidian Daily Note.

Getting calendar events into my Obsidian Daily note

## How do I automate email analysis?
In this tutorial we show you how to automate email analysis using custom mailhooks in [Make.com](https://make.com). The Make scenario used in this tutorial analyses emails sent by the "Help a Reporter Out" mailing list. The Make scenario will look for a keyword match and if a match is found will message us on Slack.

We walk you through each step of the process including how to create a custom mailhook in Make, how to use regular expressions to split the text and then use Make's inbuilt filter to split the text within the body of the emails. By the end of the tutorial you will have a better understanding of how to use automation to analyse emails using Make.com.

[How to automate email analysis with Make.com. - YouTube](https://www.youtube.com/watch?v=icqnKh0ApPU)

## Flow

![Help a Reporter Out email analysis automation flow](https://mermaid.ink/img/pako:eNpVkE1rwzAMhv-K0Aik0A526shhMJqGXcZgHTsMX9REXUxsK9jOIYT89zn92NhFvJKeV0KasJaGscAsm7TTsZgUxpYtKywUHikksYZr7ZO8pqPhkJqQwN5rS37ciRF_5u-2D1VV7S-WwLW45n-_en7clVuF8zxnmXLKfXvqW_goF92Sl_yFTQ8E79yLj-zhbYgr5Sx1nL-mcF-LTXkwVHf5YYmrmxU2GwjsGmBL2kAUqIcQxcI5bUW6RDzBMuoycDGQIzMGvnoouU_aLHsX9LwF12jZp3aTvjQpB_D3oSTTgZ1C5ebEDX1DkfeNjuKxOJEJvEYaohxGV2MR_cA3qNSUTre_VE_uS-SWzz_Mi4oU?type=png)
```mermaidignore
graph TD

haro(Help a Reporter Out)
make(Make.com)
slack(Slack)

haro -- send email to custom mailhook --> make
make -- analyse email and filter --> slack
```

## How to create an automation with a custom mailhook using Make.com
### Resources
- [Make](https://www.make.com)
- [Help A Reporter Out Mailing List](https://www.helpareporter.com/)

The final Make scenario will have 3 steps and look like this:
![completed make automation with custom mailhook screenshot](https://ry.d.pr/i/8807h4.png)

- The first step is the custom mailhook - a custom mailhook creates a unique email address that triggers this scenario each time an email is received at that address.
- The second step will be to parse the body of the email - splitting the text into bite-size chunks and then checking for keywords.
- The third and final step is to send a message in Slack alerting us to anything of interest within the email.

### Step 1: Create a custom mailhook using Make.com
Add a `Custom mailhook` node in your scenario by selecting the node from within the `Webhooks` nodes.
![create custom mailhook screenshot](https://ry.d.pr/i/ofAbCr.png)

In the `Custom mailhook` node copy your unique email address. Now get emails 
![Copy your unique email address to your clipboard screenshot](https://ry.d.pr/i/oTe1jz.png)

### Step 2: How to parse emails in Make.com
Create a `Text Parser` node using the `Match Pattern` transformer. This allows us to use regular expressions to search and split text into manageable chunks.
![Text parser node using the match pattern transformer screenshot](https://ry.d.pr/i/oVEctn.png)

Your node settings should be similar to the one below. In the pattern match we are simply splitting on a string of hyphens as this is how the `Help A Reporter Out` emails are composed - each request for help is separated by a string of hyphens like this: `-----------------------------------`.
![Settings for text parser.png screenshot](https://ry.d.pr/i/Uxc15T.png)

So for simplicity we split the text with the following pattern:
```
(-----------------------------------\n)((.|\n)*?)(?=\n-----------------------------------\n)
```

After this we use Make's inbuilt filters to check for keywords. 
![Setup Makes inbuilt text filters screenshot](https://ry.d.pr/i/To4ff1.png)

### Step 3: How do I get Make.com to message me in Slack?
Now setup a Slack node and use the output of the `Text Parser` node to send yourself the details of the email.
![Send slack message screenshot](https://ry.d.pr/i/CmxCUR.png)

We use Make.com to filter the high volume Help A Reporter Out mailing list

How to analyse and filter high volume emails using automation

## Automation overview
Alfred is primarily known as an app launcher tool for Mac – but you can do much more than that. Here we show how you can automate the creation of Trello cards via Make.

[How to use Alfred to add Trello cards via Make - YouTube](https://www.youtube.com/watch?v=rwPFqn6hkV8)

## Flow diagram

![Flow diagram of automation](https://mermaid.ink/svg/pako:eNpVkE1rwzAMhv-K8Ai0kBZ26shhUNrmttPKBsMXJVZb09gKtjMoIf99SrKu7GJ9Pa8kq1c1G1KFyrLeepuKXqt0IUdaFVpVGMXJ4Tf3gcFi1VCUIgjYBusw3HbccJj4p81zWZaHWRKpZm_-18vty26_0WoYhizTXvtzwPYCx_3oY3MKZBbbySy1d3ilxZs865qdxClQ0_DiOJnlQwGrFbQYIxhMCIlh1MC3Rfik6sJ8FeAVxm5zz5GvA2EiqDEYYA9zT6h4jLto_RmsTyTbJSvlUT9PV7lyFBxaIzfrtQd43Etc-e5VK-0H4bpW9qGDsYmDKk7YRMoVdonfb75WRQod3aG9RRnl_qgW_RfzPR5-AAn1j78)

```mermaidignore
graph TD

alfred(Alfred)
make(Make.com)
trello(Trello)

alfred -- pass data to Make via Webhook --> make
make -- create card on Trello board using integration --> trello
```


## How to recreate this Alfred/Trello automation
### Resources
- [Alfred](https://www.alfredapp.com/).
- [Make](https://www.make.com/en).
- [Paw](https://paw.cloud/) or [Postman](https://www.postman.com/) (or any other app for making HTTP requests).
- 
### Step 1: Create a webhook trigger in Make

First, create a new Make scenario. In the scenario click the **Add** icon and select **Webhooks**.

![Create a webhook trigger in Make screenshot](https://ry.d.pr/i/mwEqEu.png)
**Note:** A webhook is an HTTP callback function/request that facilitates communication between two APIs. In this instance the Webhook will allow communication between Alfred and Make.

Select **the Custom webhook** option under the “Triggers” section.
![Custom Webhooks option screenshot](https://ry.d.pr/i/gwriPM.png)


A “Webhooks” dialogue box will appear. Click **Add** and enter a **Webhook name**, then click **Save**.
![Create a webhooks dialogue box in Make screenshot](https://ry.d.pr/i/hW0VUe.png)


Click **Copy address to clipboard.** This Webhook URL will allow you to trigger the workflow from outside of Make.
![How to copy a Webhooks address in Make screenshot](https://ry.d.pr/i/eCTdZT.png)

Open your API testing tool and paste the link in the request input – make sure that it is a **POST** request. 
![How to link Paw with a Webhooks using an address screenshot](https://ry.d.pr/i/mOX6Eh.png)
**Note:** The status of the “Webhooks” dialogue box created on Make will read “Successfully determined”. This notification means that Make is receiving the HTTP request.

Here’s how it will appear:
![Webhooks dialogue box notification screenshot](https://ry.d.pr/i/0Dxpls.png)

Now let’s add a parameter for the Make webhook. Create a key/value pair with the key of `content`  in the body of your curl request/ In this example we are using Paw. We will use the content parameter later to pass values into Trello.
![How to set a Parameter key in Paw screenshot](https://ry.d.pr/i/Z0TCtL.png)


Go back to the Webhooks dialogue box and click **Redetermine data structure.** Check if the status of the Webhook reads "successfully determined".
![How to refresh a scenario in Make screenshot](https://ry.d.pr/i/6vokPB.png)


### Step 2: Connect Trello to the Make Webhook

Open Make and click the **Add New Module** icon. Select **Trello**.
![How to connect make with Trello screenshot](https://ry.d.pr/i/IjtusN.png)

Click **Create a card**
![Create a Card option in the Trello node screenshot](https://ry.d.pr/i/HRg5LN.png)

Click **Add** in the "Connection" section
![Add command in trello node screenshot](https://ry.d.pr/i/4ey5Jy.png)


A “Create a connection” dialogue box will appear. Enter your Trello connection and click **Save.**
![How to connect Make screenshot](https://ry.d.pr/i/3xpQCL.png)

Go to **Enter a List ID**. Click **Select** to automatically bring up your Trello board names in the next text box.
![Trello List ID in Make screenshot](https://ry.d.pr/i/ObjTWb.png)

The **Board** text box will contain a list of your existing Trello boards. Select a board name to connect to the webhook.
![Board section on the Trello node in Make screenshot](https://ry.d.pr/i/vd5Ixu.png)

The **List** text box will contain column names from your chosen Trello Board. Click the **Down Arrow** and select a column to add a card.
![How to view Trello columns in Make screenshot](https://ry.d.pr/i/OJjwVR.png)

In the **Name** text box, click the **Down Arrow** and select the name of the Parameter Key created earlier for the Webhook. 
![How to connect Paw with Make screenshot](https://ry.d.pr/i/RDuEXe.png)

Click OK to close the Trello node, then click the **Run once** icon in Make.
![Run Once command in Make screenshot](https://ry.d.pr/i/4lfMS5.png)

The status of the scenario will read, "The request was accepted." To indicate that the Trello card has been created. Here is how it will appear:
![Example of a working scenario in Make screenshot](https://ry.d.pr/i/zjAa1L.png)

Check Trello to see that the Parameter value you entered in your HTTP Request app:
![Example of an Automated Trello board screenshot](https://ry.d.pr/i/WT3OPn.png)

### Step 3: Automate Trello card creation with Alfred

This last step will show you how to use Alfred to trigger this automation. You will be able launch Alfred and use the keyword **idea** followed by your idea text to add it to Trello.

Open Alfred and go to **Workflows.** Click the **Add** icon at the bottom of the window.
![Add new workflow icon in Alfred screenshot](https://ry.d.pr/i/ee2Glv.png)

Select **Blank Workflow**.
![Add a blank workflow command in Alfred screenshot](https://ry.d.pr/i/dxsoxB.png)

Enter a name for the workflow in the “Name” section and fill in your bundle id. Click **Create** when done.

![How to name a workflow in Alfred screenshot](https://ry.d.pr/i/iHByDo.png)

Notice that the Workflow created will appear in the Workflow menu.
![Alfred workflow panel screenshot](https://ry.d.pr/i/44n30I.png)


Right-click any part of the window and select **Inputs**, then click **Keyword.**
![How to add a keyword workflow in Alfred screenshot](https://ry.d.pr/i/vkKIF1.png)

Enter the keyword trigger the “Keyword” section and type the title/hint that will appear when you are entering your idea. Click **Save** when done.
![How to name a workflow in Alfred screenshot](https://ry.d.pr/i/HihAvQ.pn)

Finally, connect Alfred with Make using a curl (HTTP request).
![How to add an argument to a workflow in Alfred screenshot](https://ry.d.pr/i/0TNoEN.png)

We will use a curl command. Right-click the workflow, select **Actions** and click **Run script.**
![How to add a new script in Alfred screenshot](https://ry.d.pr/i/NF2pV9.png)


A dialogue box will appear. The Parameter `$query` represents the text you entered after “idea” in the Alfred input box.
![Alfred Query script screenshot](https://ry.d.pr/i/PVIj35.png)


Open Paw/your HTTP Request app and copy the curl request code.
![Request script in Paw screenshot](https://ry.d.pr/i/bMppEL.png)

Paste the code in the Alfred and change the text string we used for testing to the parameter `$query`. The code should appear as below.
![Request script in Paw screenshot](https://ry.d.pr/i/GMg70F.png)


Lastly, go to Make and click **Run** **once** to type in a Trello card.
![Run Once command in Make screenshot](https://ry.d.pr/i/sxSKqM.png)


Type your hotkey followed by your new Trello card in the text box, and it will appear on the Trello board. Magic.
![Example of an automated Trello board screenshot](https://ry.d.pr/i/33cPjf.png)







Learn how to quickly add cards to your Trello lists with Alfred

The quickest way to create Trello cards using Alfred

## Overview
We combine our [Creating a dynamic infographic](/posts/2022-06-24-Automate-creating-an-infographic) and [Using Make as an API for Excel](/posts/2022-07-19-Using-Make-as-an-API-for-Excel) tutorials to show you how to dynamically create an Infographic using your Excel data. 

We use n8n to first hit a Make scenario to get Excel data and then we pass that data to a different n8n workflow to dynamically create an infographic.

[Learn how to dynamically create an infographic with Excel data - YouTube](https://www.youtube.com/watch?v=1osaqdSFRjw)

## Flow
![Mermaid Flow](https://mermaid.ink/svg/pako:eNptkm1rgzAQx7_KkSG00ArdU4svCltbX21sdE9vfBP12gY1cUmkK-J330XdZmGIetz97v6Xu9QsUSmygHleLaSwQR0xe8ACIxZELOaGjAn0vneuBY9zNBQEAkstCq5PK5Ur3fIX81kYhpsuxWCiZHoeD-8Wq_U8Yk3TeF4k3bPXvDzA69rZsVZHg3p03_3HkZQLOaIXCi4kHJXOdrk6dn7RBoTcqbaESIbxgmc4eqQPmAQl9a3GAwGYTmHmw1OJElyRD4wPSmXwtn0Aii2ds9Vw4KUPW_ys0FjYfCWYQ8otbykn0kk57spxttIS8BwbFrv24ZkbM6g0Ad1XHx6lzxPdSV3mjQ8rjdwipCfJC2KGfGWE3JOnrOz_wre_3dHO9ghWUU47iSX0U-n2AcAmrEBNE0_pXtTO83cnyKSVZhGLZENcVZIYblJhlWbBjucGJ4xXVr2cZMICqyv8gdaCU7NFTzXf7rfTmQ)

```mermaidignore
graph TD

browser(Browser)
n8n(n8n main workflow)
n8ni(n8n infographic workflow)
make(Make scenario)

browser -- 1. Open n8n Webhook URL  --> n8n
n8n -- 2. Request Excel data --> make
make -- 3. Return excel data --> n8n
n8n -- 4. Pass Excel data, request infographic --> n8ni
n8ni -- 5. Create dynamic infographic using input data --> n8n
n8n -- 6. Return image to user --> browser
```

## How to recreate this automation
### Resources
- [n8n](https://n8n.io/cloud?ref=tinyautomations&utm_source=affiliate)
- [Make.com](https://www.make.com/en/register?pc=rymawby)
- [Webhooks (make.com)](https://www.make.com/en/help/tools/webhooks?pc=rymawby)
- [Microsoft 365](https://www.office.com)

### Step 1: Create an n8n workflow
Create a new workflow in n8n. Your final workflow will end up looking like this:
![](https://ry.d.pr/wbEMMq.png)

The workflow consists of 4 nodes.
- The first node is the `Webhook` that you call to kick off the workflow.
- The second node (a `HTTP Request`) calls the [Creating a dynamic infographic](/posts/2022-06-24-Automate-creating-an-infographic) workflow and returns Excel data.
- The third node (another `HTTP Request`) calls the [Using Make as an API for Excel](/posts/2022-07-19-Using-Make-as-an-API-for-Excel) n8n workflow whilst passing in the data from the previous node.
- The final node returns the image to the user.

### Step 2: Create a Webhook node
Create a `Webhook` node in your n8n workflow. Set the `Respond` value to `Using 'Respond to Webhook' Node`. This makes sure that the whole workflow will get executed before returning an image combined with Excel data.
![n8n webhook node](https://ry.d.pr/igslKh.png)

### Step 3: Run the Make workflow
Create a `HTTP Request` node that calls your [Make scenario](/posts/2022-06-24-Automate-creating-an-infographic). This will return JSON data of your Excel spreadsheet.
![Call Make node](https://ry.d.pr/HW9Wan.png)

### Step 4: Call your infographic n8n workflow
Create a `HTTP Request` to call your [n8n workflow](/posts/2022-06-24-Automate-creating-an-infographic).
![n8n Infographic HTTP Reequest node](https://ry.d.pr/YO6V5v.png)

You will need to add a query parameter to the URL - you can do this using the expression editor to select the data coming through from Excel as JSON in the previous step. Your expression should look something like this:
![Using the n8n expression editor to dynamically fill your Excel data](https://ry.d.pr/HNnxGn.png)

### Step 5: Return the image to the user
Return the image to the user/browser - you do this by creating a `Respond to Webhook` node with the `Respond With` set to `Binary` and automatically choosing the data source from Input.

![Respond to Webhook n8n node](https://ry.d.pr/99U1YK.png)

Combine 2 of our previous automations to generate dynamic infographics from Excel data

Dynamically create an infographic with Excel data

## Overview
In this automation we get data out of Excel by hitting a URL. In this automation we use [Make's](https://www.make.com/en/register?pc=rymawby) simple and powerful integration with [Microsoft 365](https://office.com).

[Youtube video tutorial](https://www.youtube.com/watch?v=6NQnWKvHAdI)

## Flow
[![](https://mermaid.ink/img/pako:eNptUU1rwzAM_SvCI9BCexhj68hh0LXJ2KD76tjJFydRF5PELrK9roT899lJyjbYRX5I70nPUstyXSCLWRS1Ukkbt5zZEhvkLOYsE8aDGYy5d0FSZDUaXwRP3JNsBB1XutbU888W52maJoPEYK5V8beeLq9X6wVnXddFEVdcfZDYl_C2DjgjfTBIk9vhnXLViAonGx88xq8c60kSImxkTtronYWLq8vpLy3M55Ao60FQwQGzUusKHNW-cgOh39A1EF8c0hGGjp9S_Op617taPt_3qn7yaCDoXtE6UlALY8GPBb2Dg6bKlIj2nzEj_WH79AhWgws2w7iTuaAY7YefALAZa5AaIQt_lzZkfm7ioV9pxRlXnee5fSEsJoW0mli8E7XBGRPO6u1R5Sy25PBEWkvhl92MrO4bRvCrSA)](https://mermaid.live/edit#pako:eNptUU1rwzAM_SvCI9BCexhj68hh0LXJ2KD76tjJFydRF5PELrK9roT899lJyjbYRX5I70nPUstyXSCLWRS1Ukkbt5zZEhvkLOYsE8aDGYy5d0FSZDUaXwRP3JNsBB1XutbU888W52maJoPEYK5V8beeLq9X6wVnXddFEVdcfZDYl_C2DjgjfTBIk9vhnXLViAonGx88xq8c60kSImxkTtronYWLq8vpLy3M55Ao60FQwQGzUusKHNW-cgOh39A1EF8c0hGGjp9S_Op617taPt_3qn7yaCDoXtE6UlALY8GPBb2Dg6bKlIj2nzEj_WH79AhWgws2w7iTuaAY7YefALAZa5AaIQt_lzZkfm7ioV9pxRlXnee5fSEsJoW0mli8E7XBGRPO6u1R5Sy25PBEWkvhl92MrO4bRvCrSA)

```mermaidignore
graph TD

browser(Browser)
make(Make)
excel(Excel Microsoft 365)

browser -- Enter Make webhook url --> make
make -- Query Excel via Microsoft Graph API --> excel
excel -- Return last row of worksheet --> make
make -- Return JSON to user via webhook --> browser

```

## How to recreate this automation
### Resources
- [Make.com](https://www.make.com/en/register?pc=rymawby)
- [Microsoft 365](https://www.office.com)
- [Webhooks (make.com)](https://www.make.com/en/help/tools/webhooks?pc=rymawby)
- [JSON (make.com)](https://www.make.com/en/help/tools/json?pc=rymawby)
- [Graph Explorer | Try Microsoft Graph APIs - Microsoft Graph](https://developer.microsoft.com/en-us/graph/graph-explorer)

### Step 1: Create a new Make scenario
Create a new scenario in Make. Your scenario will end up looking something like this:
![Completed Make scenario](https://ry.d.pr/HA3ixm.png)

## Step 2: Create a Webhook node
In your Make scenarion create a `Custom webhook` node. `Add` a new webhook and give it a name. Copy the address and open it in your browser.
![Create a custom webhook node](https://ry.d.pr/je0KgS.png)


## Step 3: Create an Excel node
Create a new `Make an API Call` node and connect it to your Microsoft account. You need to determine what you put in the `URL` input box by using the [Microsoft Graph Explorer](https://developer.microsoft.com/en-us/graph/graph-explorer) (more info on this can be found in the video).

![Excel Make an API Call node](https://ry.d.pr/L5uFSB.png)

For this demo we fetch the last row of the Excel worksheet by using this path (where `subscribers` was the name of the worksheet):
```
/v1.0/me/drive/items/01NNEVLKRZNF6EMAUUJHKJ2YA5CMDNPY/workbook/worksheets('subscribers')/usedRange/lastRow
```

Our Excel spreadsheet looks like this:
![Excel spreadsheet](https://ry.d.pr/qAiTLX.png)

## Step 4: Convert the retrieved data to JSON
Use a `Transform to JSON` node to convert the data returned from `Step 3` into JSON. Make allows us to click in the `Object` input box and click an input from the previous node. Here we just use the `Body`.
![Transform to JSON node](https://ry.d.pr/GdrSVx.png)

## Step 5: Return the data to the user
Create a `Webhook response` node that returns a `Status` of `200` (this means all is OK) and a `Body` of the `JSON string` from the previous node. Now when you hit the `URL` from `Step 2` you will see the data from your Excel worksheet being returned. 
![Respond to webhook response](https://ry.d.pr/Y7mdMn.png)

This automation can now be used in other automations to access your Excel data.




How to access your Excel data with a URL using Make

How to use Make as an API for Excel

## Automation overview
Nowadays you can be inundated with PDF reports and analysis from various sources and after a quick glance they are never viewed again. Here I show you a way of extracting and saving that data from a PDF you receive in an email into Excel.

[Extract data from a PDF email attachment into Excel using Make - YouTube](https://www.youtube.com/watch?v=yND9qt8JcG0)

## Automation flow for extracting data from PDFs using Make and inputting into Excel

![Data extraction PDF flow](https://mermaid.ink/svg/pako:eNptkE1rwzAMhv-K8Qik0A526shhMJrmNjbY2GH4ojrqYpJYwVFoS8h_n5K0WzeGQX5lPfqwem0pR53oKOqdd5z0RnOBNRqdGL2DVsRSnd_eITjYVdhKUAnYBFdDOG2oojDxN-u7LMu2c0qLlnz-O5493m_StdHDMESR8eP5DNAU6i0dNXVcEZXx83wvjK-hxPhJjOgm31uKX9Ls1pK4eLRYxdvRLq6S1WqlsAZXqYPjQgmugBlsUaNnCT6oseZceWKPHMDyX2hqdu55jeXA8E-VQ3CMc5BJBTpMzDTi_E2l9FLXGGSyXNbdjy8_qxYpmyqNNn4QrmukEm5zxxR0soeqxaWGjun15K1OOHR4gVIHssH6m2rAfxBd_OELTAijEQ)
```mermaidignore
graph TD

outlook(Outlook)
make(Make)
pdfco(PDF.co)
excel(Excel)

outlook -- email with PDF attachment --> make
make -- extract attachment --> pdfco
pdfco -- extract data --> make
make -- write data to row --> excel
```

## How to recreate this automation
### Resources
- [Make | Work the way you imagine](https://www.make.com)
- [PDF.co](https://pdf.co/)
- [Outlook and Excel](https://www.office.com/)

### Step 1: Setup an Outlook rule to move required emails to a folder
Setting this up simplifies the process within Make - as it means we won't need to do any tricky searches on our whole inbox. For this demo I created a folder called `Automation` and moved any messages from my personal email address containing the subject `Channel Stats` into it.

![Outlook Rule](https://ry.d.pr/7FCbAK.png)

### Step 2: Create a Make scenario that extracts email attachments
This is a 3 step process in itself - first of all you find the emails via a search, then you list out the attachments from that email and then finally you download the attachment.

![Three steps to getting the attachment](https://ry.d.pr/UC0C5K.png)

In the `Search Messages` node we want to grab emails from `Today` that are in the `Automation` folder we set up in `Step 1`. 

![Search Messages](https://ry.d.pr/qKrjSH.png)

In the `List Attachments` node we want to use the `Message ID` from the search result in the `Search Messages` node.

![List Attachments Node](https://ry.d.pr/3z2jaH.png)

In the `Download an Attachment` node we want to use the `Message ID` from the search result in the `Search Messages` node and the `Attachment ID` from the `List Attachments` node.

![Download an Attachment Node](https://ry.d.pr/cUdz2h.png)

### Step 3: Extract data using PDF.co
You need to create an account on PDF.co and create a document parser. In this document parser you are able to set up objects that will extract text/data from your PDF. Here you can see how it was set it up for the demo (for more detailed information on how to set this up watch the video above).

![PDF.co Document Parser](https://ry.d.pr/yefVJT.png)

After you save take note of the ID of the Document Parser Template.

![Document Parser Template ID](https://ry.d.pr/ej0VGY.png)

Add your PDF.co node in Make after the `Download an Attachment` node.

![Add your PDF.co node](https://ry.d.pr/Tqhdrh.png)

Set your PDF.co node up so that its `Input File` is `Upload a File` and the `File` is from the previous node. Then add the ID of your `Document Parser Template` that you set up earlier.
![PDF.co node setup](https://ry.d.pr/eD6bz7.png)

### Step 4: Write out the data to Excel
The final step is to write the data you have extracted from your PDF to your Excel spreadsheet. Add `Microsoft 365 Excel Add a Worksheet Row`  node as the final node.
![Microsoft 365 Excel node](https://ry.d.pr/0mP7WO.png)

Setup your node so that it uses the values from PDF.co to write to your spreadsheet (you need to have created your spreadsheet already). The values you set up in your `Document Parser Template` will be available in this node to write to your spreadsheet.

Select your `Workbook` and then your `Worksheet` and the rows you have setup in your spreadsheet will become available.

![Excel node setup](https://ry.d.pr/u2deCS.png)

Automate data extraction from your PDFs using Make and PDF.co and save to Excel

How to extract data from PDF email attachments into excel

## Automation overview
We use Alfred to quickly get a tweet out using Make (note - we wrote this when Make was actually called Integromat so you may find a few references to Integromat rather than Make in the code samples). Using Make allows us not to have to use our own Twitter app and we do not need to go through the Twitter approval process.

## Automation flow diagram for tweeting from Alfred

![Automation flow diagram for tweeting from Alfred](https://mermaid.ink/svg/pako:eNpdkDFrw0AMhf_KoWJwIBnSDCkeCiGJp3ZpS4dyi-KTkyO-OyPLhGD833t2a0O7iPekTw-kDopgCDJIks56K1mnQS7kSEOm4YRNFEv12_tEtniqqIlDFcGarUO-70MVeOQftus8z48_Kw0VwZu_83z3tD9sNfR9nyTaa39mrC_q5W3QSg21EarX6a4qmcxiajymr3il2W7Sj5sVIV7821OrlSparlQRnENvon9WY8CcNCByIxJlfRlmYANLcMQOrYnf6MbU-RNRxkOuGrTvI9fWBoWOxkpgyEqsGloCthLe776ATLilCTpYjCe6marRf4Uw-f4bk4GA4Q)
```mermaidignore

graph LR

  

step1(Alfred)

step2(Make)

step3(Twitter)

  

step1 -- curl command --> step2

step2 -- tweet info --> step3

```

## Step 1: Alfred
### The trigger
Here we create a keyword trigger using the word "tweet" with the settings below. This will pass anything after the word tweet into our workflow where we are going to use a curl command that passes our tweet to a Make webhook.
![](https://ry.d.pr/sEnqoS.png)

### The curl command
We use a `POST` curl command that references the Make webhook we are going to create in step 2. We use a `run script` action in Alfred and the following curl command in the action.

```shell

curl --location --request POST 'https://hook.integromat.com/my-webhook-url' \

--header 'Content-Type: application/x-www-form-urlencoded' \

--data-urlencode 'tweet={query}'

```
![](https://ry.d.pr/DK84tO.png)

## Step 2: Make
We create a new webhook trigger in our Make scenario. We copy the url address to our clipboard and add it to our curl command above in Alfred. This will allow Alfred to pass the tweet information to our Make webhook and trigger the scenario.
![](https://ry.d.pr/fa969q.png)

Click on `Re-determine data structure` .
![](https://ry.d.pr/jVQc0C.png)

While the little `Stop` icon has a spinner running next to it test your tweet from Alfred.
![](https://ry.d.pr/baD5UO.png)

You should see `Succesfully determined` in green.
![](https://ry.d.pr/6FUE4N.png)

Next add your Twitter module and with the `Status` containing your tweet determined via the curl command.
![](https://ry.d.pr/ndpOXq.png)

Finally save and turn on your scenario and run immediately
![](https://ry.d.pr/O2UZyf.png)

You can now tweet directly from Alfred

Always wanted to tweet from Alfred? We show you how.

Learn how to automate with Make

What can I automate with Make?

How much does Make cost?

How can I learn how to use Make?