
## What can I automate with n8n?
You can automate tasks by creating custom workflows with a visual editor. n8n can interact with a variety of apps and services through its built-in nodes, and users can also create custom nodes to interact with other apps and services not natively supported by n8n. Some examples of apps and services that n8n can interact with include Slack, Trello, and Airtable.

## How much does n8n cost? 
n8n is open source and it is free to self-host the app. n8n also have hosted cloud based plans starting at [€20 per month](https://n8n.io/pricing/).

## How can I learn how to use n8n?
n8n has an [active forum](https://community.n8n.io/) that you can visit - or take a look at our tutorials below.

n8n is an open-source, low-code workflow automation tool that allows users to automate a wide range of tasks by creating custom workflows.

## 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
Learn how to dynamically create infographics using this simple but powerful n8n workflow.

[How to dynamically create infographics using n8n - YouTube](https://www.youtube.com/watch?v=aE6kSMqjGV8)


## Dynamic infographic automation Flow

![Dynamic infographic automation flow](https://mermaid.ink/svg/pako:eNplUMtugzAQ_BVrK6RESg49JeJQqQ1w6il9HCpfDGzACqzpYhQhxL93gaQPVZbl8c7MvgbIXI4QQhAMlqwPBw2-xBo1hBpS0wrYqGvs3bA1aYWtkEqEDdvacH9wleNZf7e7T5IkXiwtZo7yv3zyuD9EOw3jOAaBpukUbJpSvUYTTtldWuTV0_KuNdGeVnLXv1i13aqYvIC347O6WF-qzw65bz1bKoR9UOKYrZP0iL5jUpZObi5ls_-e3HgjCiXjFDhnuNZaWlQKNlAj18bmsqphivysSaBMedagaRRd10g2jHPrHUN4MlWLGzCddy89ZRB67vAmiqyRlupvVWPow7nbf_wCc0WNGA)
```mermaidignore
graph TD

browser(Browser)
n8n(n8n)

browser -- Enter URL with querystring --> n8n
n8n -- Return infographic with querystring data in image --> browser
```

## How to recreate this automation
### Resources
- [n8n](https://n8n.io/cloud?ref=tinyautomations&utm_source=affiliate)
- [n8n workflow](https://github.com/rymawby/tiny-automations-source/blob/main/automate-creating-an-infographic/Dynamic_Infographic.json)
- [Template image sample](https://github.com/rymawby/tiny-automations-source/blob/main/automate-creating-an-infographic/tiny-automation-stats-template.png)

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

### Step 2: Create a webhook node
In your n8n workflow create a webhook node - make sure that the you are responding with the `Respond to Webhook` node in the settings. This makes sure that the whole workflow will get executed before returning the modified image.
![Webhook node screenshot](https://ry.d.pr/xAAzG2.png)

When you call this webhook via its URL you can use a querystring parameter to pass in data. If your `Webhook` node URL is `http://n8n.io/webhook/my-webhook-url` you can add a querystring parameter like this: `http://n8n.io/webhook/my-webhook-url?stat=1900` (here it is named `stat` as this is what we use in the video tutorial). You can then use this `stat` variable later when we edit the image.

### Step 3: Get the image template
Use a `HTTP Request` node to load the [image template](https://github.com/rymawby/tiny-automations-source/blob/main/automate-creating-an-infographic/tiny-automation-stats-template.png). Update the `URL` input to the URL of your template image and change the `Response Format` to `File`.

![HTTP Request node for the image template screenshot](https://ry.d.pr/TPOXkV.png)

### Step 4: Dynamically add text to the image
Now we have the image template (Step 3) and the `stat` value (Step 2) we can combine them so the image contains the `stat` value. We do this with an `Edit Image` node. Below you can see the image prior to the node being executed 
 on the left and after node execution on the right. As you can see we have added the value from `stat` (1900) to the image.
![Edit image node screenshot](https://ry.d.pr/S5K3Pt.png)

Use the `Text` input's `Expression editor` to select the querystring data from `Step 2`. The value we pass in when we call the URL is now used to generate the image.
![Text input expression editor screenshot](https://ry.d.pr/MTeaKS.png)

### Step 5: Return the finished image
The final step is to return the image to the user and end the workflow. We do this with a `Respond to Webhook` node. Make sure that `Respond With` is set to `Binary` and `Response Data Source` is set to `Choose Automatically From Input`.
![Respond to Webhook screenshot](https://ry.d.pr/MPyXE6.png)

Now save the workflow, set it to `Active` and hit the production URL of the initial `Webhook` with a query param.



Use this highly customisable automation to up your image game

Dynamically create infographics using n8n

## Overview of the n8n and Shortcuts bin day automation
Be the envy of your street by using n8n and Shortcuts to let you know what colour bins are meant to go out.

This tutorial will show you how to use n8n as a backend and Shortcuts (macOS or iOS) as a front end client.

[Bin day automation - how to remember what colour bins need to go out - YouTube](https://www.youtube.com/watch?v=PY35t81IUL0)

## Take out the correct bins automation flow
![Bin day automation flow diagram](https://mermaid.ink/svg/pako:eNpVkE1rwzAMhv-K0Ai0kB52aslhUJIGdhtsbDB8UWx3MUvs4I9DCPnvU7I1owjBK-mRhDShdEpjgVk2GWtiMQmMre61wEJgQ4FFDn-5d_KGmk4HLgKDgzc9-bF0nfMr_3B8rOv68tsStHRW3dfr86msjgLnec4yYRf78jS08FYtOrTOR5li2G1qL6w92R37_o6AwwFK6jpojAVFI5xfnjn3BEyuLQvw0VIEyeuTX7noYEgRHPuCbsMwx177noziT0zCAvx_gSUf8S1Q2Jm5NCiK-qJMdB6LK3VB50gputfRSiyiT_oGVYb4uH6jBrKfzt3i-QdCgIBn)
```mermaidignore
graph TD

shortcuts(shortcuts)
n8n(n8n)

shortcuts -- Call bin day API --> n8n
n8n -- What colour bin to put out --> shortcuts
```

## How to recreate this automation
### Resources
- [Bin Day Shortcut for macOS/iOS](https://www.icloud.com/shortcuts/9beb8e54e8c8470b929c4b62f0193184)
- [n8n workflow](https://github.com/rymawby/tiny-automations-source/blob/main/bin-day-n8n-and-shortcuts/bin_day_api.json)
- [n8n.io - Free and Open Workflow Automation Tool](https://n8n.io/)


### Step 1: Use n8n to create an API
This automation is simple enough that you don't really need this API - as currently the only data I could get was a PDF detailing what bins need to go out. If this changes in the future and I move somewhere with a better bin day website or even it's own API I will just have to change this backend and not the frontend Shortcut.

The n8n backend consists of 3 nodes. A `Webhook` node that we can call via a URL, a `Function` node that figures out what colour bins need to go out next Tuesday (my bin day) and then a `Respond to Webhook` node that returns the data from the `Function` node.

![Bin day API call in n8n](https://ry.d.pr/TW1MvE.png)

If you open the `Bin day` node you can see the URL you need to retrieve the data from this workflow. Take note of this URL as you will need to use it in your Shortcut. We are using `GET` as the `HTTP Method` as we do not need to pass in any parameters. (it would be worth adding some kind of `Authentication` too).

Not also we have set `Respond` to `Using 'Respond to Webhook' node` - this is how we will return the data from the `Function` node.

![The Bin Day URL](https://ry.d.pr/tfxLxt.png)

In the `Function` node we calculate what bins are out the following Tuesday - or today if today is Tuesday. My bins just alternate colours every week - yours may be different and you'd have to analyse and modify the code so it's relevant to you. But my code is something like this: 

```javascript

function getNextDayOfTheWeek(dayName, excludeToday = true, refDate = new Date()) {
    const dayOfWeek = ["sun","mon","tue","wed","thu","fri","sat"]
                      .indexOf(dayName.slice(0,3).toLowerCase());
    if (dayOfWeek < 0) return;
    refDate.setHours(0,0,0,0);
    refDate.setDate(refDate.getDate() + +!!excludeToday + 
                    (dayOfWeek + 7 - refDate.getDay() - +!!excludeToday) % 7);
    return refDate;
}

function daysBetweenTwoDates(startDate, endDate) {
  var millisecondsPerDay = 24 * 60 * 60 * 1000;
  return Math.round((endDate - startDate) / millisecondsPerDay);
}

function isItFortnightlySince(days) {
  return days % 14 === 0;
}

const INITIAL_BIN_DAY = new Date(2022, 0, 4);
const nextBinDay = getNextDayOfTheWeek("Tuesday", false);

const daysBetweenBinDays = daysBetweenTwoDates(INITIAL_BIN_DAY, nextBinDay);

var binColor = "";
if(isItFortnightlySince(daysBetweenBinDays)){
  binColor = "Blue and Green";
} else{
  binColor = "Yellow";
}

items[0].json = {announce: "Put out the " + binColor + " bins."};

return items;
```

Notice the format we return data in n8n - the `items[0].json` usage is so that we can pass data between nodes - also note that the property we are setting is named `announce`.

In the `Respond to Webhook` node just return the `First incoming item`. 
![Respond to Webhook setup](https://ry.d.pr/8CtSX3.png)

Test it out, save and activate - your n8n API is up and running.

### Step 2: Create a Shortcut that calls your n8n API
Now you've set up your n8n backend you can create a Shortcut that calls this API and then displays what it returns. Below is in macOS but you can do the same on iOS/iPadOS.

Re-create the Shortcut as below but with your URL from `Step 1`. We call that URL, that the contents of the URL and then grab the value for `announce` and display it with a `Show Result` node.

![The Shortcut](https://ry.d.pr/kogO8t.png)

Now run your Shortcut - it should call your n8n backend and then display the result.

Be the envy of your street by putting the right colour bins out every week.

Bin day automation using n8n and Shortcuts

## Overview
Save yourself time and effort (and from the temptation of time wasting browsing) by getting mentions of your interests, brands or products directly to Slack every morning.

[Automate your Google Alerts to Slack every morning - YouTube](https://www.youtube.com/watch?v=B0R2NenmSq0)

## Google Alert to Slack morning update using n8n automation flow diagram
![Google Alert to Slack morning update using n8n automation flow diagram](https://mermaid.ink/svg/pako:eNpVkE1rwzAMhv-K0QikkB52aslhUJpm92XsMHxREzU19UewnUMJ-e-Ts7ZbMbZfSc9rI03Quo6ghCyblFWxnCTEMxmSUEo4YmBRiFvuC73Co6bARcHg4JVBf9077fzCv2xe67o-_FoCtc52z_V6t91XGwnzPGeZtGn1Hoez-KyStlub815x1rleE2ryMX9ftNilQHw0DZeDxvaSN-lc3YxivRatd-l-E__sT28lyIcgTkRdWEh2PuyGQsCelvzyAxRgyBtUHU9oklaIv-mw5OYuEqSdmRuHDiMdOhWdh_KEOlABOEbXXG0LZfQj3aFKITdtHtSA9tu5ezz_ABtzh8A)
```mermaidignore
graph TD

n8n(n8n)
googlealert(Google Alert RSS)
slack(Slack)

n8n -- cron --> googlealert
googlealert -- rss feeds --> n8n
n8n -- message --> slack
```

## How to recreate this automation
### Resources
* [Github repo](https://github.com/rymawby/tiny-automations-source/blob/main/google-alerts-to-slack)
* [n8n workflow](https://github.com/rymawby/tiny-automations-source/blob/main/google-alerts-to-slack/Google_Alerts_to_Slack.json)
* [Slack - n8n Documentation](https://docs.n8n.io/integrations/nodes/n8n-nodes-base.slack/)
### Step 1: Setup your Google Alerts as RSS feeds
Go to `https://www.google.com/alerts`. Create alerts of subjects etc that are of interest to you. Once you have done that click the edit button:
![Edit google alert](https://ry.d.pr/NqAzey.png).

Change the `Deliver to` section to `RSS feed`.
![Deliver to as RSS feed](https://ry.d.pr/ipCJPS.png)

Now click on the `RSS feed` icon and grab the URL from the browser (you'll use this later in n8n - it'll look something like `https://www.google.com.au/alerts/feeds/12345581409404114402/1234574375811598703`)
![RSS feed icon](https://ry.d.pr/UFLMDn.png)

Repeat this process for all the subjects/keywords that interest you. Remember to save all your feed URLs as you'll need them in n8n.

### Step 2: Setup your n8n workflow
Your n8n workflow should look like something like this: 
![n8n workflow](https://ry.d.pr/lgsT6C.png)

The `Cron` node runs this workflow every morning at 7am. (A [cron job](https://en.wikipedia.org/wiki/Cron) is a way of running tasks at certain times repeatedly).


In the `List feeds` function node create an array of Google Alert RSS urls from `Step 1` - something like the below (`items[0].json` follows the format for passing data in n8n).
```javascript
items[0].json.feeds = [

	"https://www.google.com/alerts/feeds/12345581409404114402/1234525054193310532",
	"https://www.google.com/alerts/feeds/12345581409404114402/1234535688892159086",
	"https://www.google.com/alerts/feeds/12345581409404114402/12345125633164967",
	"https://www.google.com/alerts/feeds/12345581409404114402/1234537100179579905",
	"https://www.google.com/alerts/feeds/12345581409404114402/1234540289464225414",
	"https://www.google.com/alerts/feeds/12345581409404114402/1234577577438323748"]

return items;
```

In the `Cycle through feeds` function node we `pop` a value from the array and pass it on.
```javascript
items[0].json.feed = "";

if(items[0].json.feeds.length > 0){
	items[0].json.feed = items[0].json.feeds.pop();
}

return items;
```

If there are still feeds in the `feeds` array we loop back around to the `Cycle through feeds` function using the `IF` node (each time this is run it decreases the length of the `feeds` array by `1`). 

We also pass valid `feed` values through to the `RSS Feed Read` node. This node just takes in the value passed to it from the `IF` node (a Google Alerts RSS URL) and loads it.

The Slack node then sends this data to Slack.

## Future enhancements
- add more sources - not just Google Alerts for the ultimate morning update.
- combine Google Alert RSS feeds into a single RSS feed.




Keep up-to-date with morning updates using Google Alerts

Google Alert to Slack - morning update

## Overview
This automation uses Airtable to store a knowledge base and n8n as both the trigger and the source/backend. The questions and answers are displaying in Shortcuts. This isn't the quickest or, to be honest, most logical automation as it stands - but it could be the start of a whole knowledge system - with different sources and different triggers - hence the use of n8n to trigger as well as grabbing the dataset from Airtable.

[Knowledge System using automation and n8n, Pushcut, Airtable & Shortcuts. - YouTube](https://www.youtube.com/watch?v=o6xDXIdD7KI)

## How to improve your recall using n8n, Pushcut, Shortcuts and Airtable automation flow diagram

![How to improve your recall using n8n, Pushcut, Shortcuts and Airtable automation flow diagram](https://mermaid.ink/svg/pako:eNp9UcFqg0AQ_ZVli2AgofSU4KFQYvyBlh7KXia61aU6a2Z3Kan47x2NmrSHsMi-mXlvnsvrZG4LLRMZRZ1B45NOSV_pRiuZKHkEx2Atpt47kIFjrR0PBRNbMg3QeW9rSyP_YfuUZdnhInE6t1j8nWcvu326VbLv-yhSOJySoK3EWzpg3GHM30phG1yVBx9PN3dcZckzdPGCuAuG_PBL8QxW0x6x2YicLApPpiw1cf0spm3L-oE0z0_B_IykZf2N50AkfQraeUGAhW3EWBiLj4Due9rPvos5aR8I77FvjBbNxeI_uwDPSfhRNT_0-vZBWer7KjaQa9loasAUHHenUIhr1Aw5qS8lFfbMCy1r9aEw3pJMPqF2ei0hePt6xlwmnoKeSakBTrBZWC3gh7Vz3f8Cg0nVdQ)
```mermaidignore
graph TD

n8n(n8n)
pushcut(pushcut)
shortcuts(shortcuts)
airtable(airtable)

n8n -- cron trigger --> pushcut
pushcut -- trigger quiz --> shortcuts
shortcuts -- request random question/answer --> n8n
n8n -- return random question/answer --> shortcuts
n8n -- request question/answer dataset --> airtable
airtable -- get question/answer dataset --> n8n
```

## How to recreate this automation
### Resources
* [Github source](https://github.com/rymawby/tiny-automations-source/tree/main/improving-your-recall-with-automation)
* [n8n workflow](https://github.com/rymawby/tiny-automations-source/blob/main/improving-your-recall-with-automation/Knowledge_System.json)
* [Trivia Airtable](https://airtable.com/shrACk3hEub3dTD47)
* [Quiz shortcut](https://github.com/rymawby/tiny-automations-source/blob/main/improving-your-recall-with-automation/Quiz.shortcut)

### Step 1: The trigger
I wanted to view the questions on my phone once an hour every hour 9am-5pm. To do this is a 2 step process. I have n8n setup with a cron job to trigger on the hour during these hours and this calls Pushcut on my phone (via webhook).
![n8n trigger workflow](https://ry.d.pr/GAZ4Gd.png)

### Step 2: Run the Quiz shortcut on your phone
Pushcut opens the Quiz shortcut workflow. The Quiz shortcut then calls a webhook on n8n which get's a random question from the trivia Airtable dataset. The shortcut then displays the question before displaying the answer. The Quiz shortcut looks like this:
![Quiz shortcut](https://ry.d.pr/zBHtL6.png)

And the n8n workflow it calls via webhook:
![n8n get question workflow](https://ry.d.pr/B5HRo6.png)

### Step 3: The Airtable dataset
I just quickly imported some random questions I found on the [Open Trivia DB](https://opentdb.com/api.php?amount=10) for demo purposes. With Airtable you can actually import the JSON outputted.
![](https://ry.d.pr/QFcqVd.png)

## Future enhancements
* Different triggers - Shortcut automations, manually, location based etc.
* More sources - n8n could pull in more than just from Airtable, maybe from your Anki database, Readwise excerpts etc.
* Caching - n8n could cache the questions nightly so it runs quicker.


Create a knowledge system with n8n, airtable, pushcut and shortcuts.

Improving your recall with automation

This tiny automation allows you to allocate your income automatically. It runs a service on n8n so that anyone with the shortcut can run the same numbers.

## Income allocator automation flow diagram
![Income allocator automation flow diagram](https://mermaid.ink/svg/pako:eNpVkDFrw0AMhf_KoWJIIBnSDAkeCm0Sjx2a0qHcovjU5IgtmbNuCMb_vWenbilanvQ-PZA6KMUR5JBlnWeveWdBL1SThdzCCdskFuZn9oHB46miNpkmgU3wNYbbTioJI_-wWRVFcbivtFQKu_9-8bzd7TcW-r7PMstDnQM2F_O-H7R3q9kL8nU-yMfZ8SJBy6jt2K9nvOX5D2aWS_MqSgZriaymQe_S7MmkvXF5AA6sFCbibq7HpMF8I42BzSm6M6nBqpIS1QtPKbCAmkKdctN3OsvG_H0myXTY1YLlPnGxcah0cF4lQP6FVUsLwKhyvHEJuYZIE7T3mA6uf6kG-VNk6vtvTQWEYg)

```mermaidignore
graph TD

id1(Bank)
id2(Shortcuts)
id3(n8n)

id1 -- Note amount paid --> id2
id2 -- Enter amount --> id3
id3 -- Return budget allocation --> id2
```

## Step 1. Get paid
The best step. Note how much - this income allocator can take in any amount and still split it to the same percentages.

## Step 2. Create a shortcut that takes in your income amount
Create a shortcut that posts to the webhook you are going to create in **Step 3**. It should be a `POST` request with `amount` added to the request body. The blurred out bit is the `URL` of the n8n webhook.
![](https://ry.d.pr/tDoWQ8.png)

## Step 3. Create an n8n workflow
Create a webhook workflow that contains 2 nodes - a webhook and a function node.
![The n8n income allocator workflow](https://ry.d.pr/bl9jve.png).

The webhook listens and receives the data that is sent from the shortcut in **Step 2**. We then do a calculation in the function and return that data as a response. Something like this:
```js
total = Number(items[0].json.body.amount);
treatMoney = Math.floor(total * 0.05);
savingsMoney = Math.floor(total * 0.35);
expensesMoney = Math.floor(total * 0.55);
items[0].json.display = "Money into everyday expenses: $" + expensesMoney.toString() + "\nMoney into savings: $" + savingsMoney.toString() + "\nMoney into each spending account: $" + treatMoney;
return items;
```

It just responds with a simple, human readable string with instructions where to allocate the money. This string is then displayed by the shortcut.

You could make this more complex if you have different budgetting needs. I really love this simple architecture - you could use it to do all manner of things.

 If you liked enjoyed this tiny automation please do share the [original twitter thread](https://twitter.com/TinyAutomations/status/1485575632788471809?s=20).

Learn how to automate with n8n

What can I automate with n8n?

How much does n8n cost?

How can I learn how to use n8n?