How to Create Tasks in Notion with Your Voice

Here’s a quick look at how the entire automation works:

Let’s break it down in a bit more detail. First, this is what happens on your phone:

1. Your voice is transcribed, either by Siri on iOS or Google Assistant on Android.
2. An on-device automation app (Shortcuts on iOS, Tasker on Android) packages your dictation with your name and the current date. Sending your name allows you to assign tasks to yourself.
3. Shortcuts/Tasker sends the data as an HTTP request to your workflow in Pipedream, which will handle eveything else.

Once the data hits your Pipedream workflow, the following steps are executed:

1. Validate the user input, making sure it doesn’t contain disallowed characters.
2. Craft a user message and send it to ChatGPT, which is instructed to act as a natural language task parser. It returns an group of task objects.
3. Calculate the cost of the ChatGPT request (typically around $0.003).
4. Validate the response from ChatGPT, making sure that it’s valid JSON (and attempting to repair it if not).
5. Query Notion for a list of users and projects (in your chosen Projects database)
6. For each task with an assignee and/or project, match the nearest user/projet from Notion. If there’s not a good match, we don’t include it.
7. Create a task object for each task, formatted in the way thet Notion API requires
8. Create a new page in your Notion tasks database for each task
9. Send a confirmation back to your phone

In short, a POST request is a type of request that one computer sends to another where the intention is to send data. Data is sent over HTTP (HyperText Transfer Protocol), which is essentially what allows the internet to work.

What is HTTP? Protocol Overview for Beginners

Without HTTP (Hypertext Transfer Protocol), the World Wide Web as we know it today would not exist. HTTP is the protocol that enables the transfer of data over the internet, allowing users to access websites and other online resources. There are various ways to design web applications, including GraphQL, SOAP,

www.freecodecamp.org

Often, POST requests are send in order to create something new at the destination. For example, the Create_Notion_tasks step in our pre-built Pipedream workflow sends a POST request to Notion in order to create new pages.

Most of the requests you make from your computer (or phone) to other computers (usually servers) are GET requests. These are requests for the server to send something back, like a web page.

There are five main types of HTTP request methods:

• GET – used for reading data from the application. It is read-only, so it has no risk of modifying any data.
• POST – sends data to the application to create something new.
• PUT – sends data to the application to update an existing resource. Contains a full updated copy of the resource.
• PATCH – also updates an existing resource, but only contains the changes to be made instead of the entire updated resource.
• DELETE – sends an instruction to the application to delete an existing resource.

In our workflow, we’re sending a POST request from your phone to Pipedream because we need to send data to Pipedream.

If you’d like to learn more about HTTP and its methods, here’s a great video:

On rare occasions, Apple’s Shortcut-sharing feature goes down due to server issues on their end. I ran into one such occasion shortly after publishing this guide, which prevented people from importing the shortcut above.

If you experience this issue, here are instructions on how to build the shortcut from scratch.

1. Find the Shortcuts app on your iOS device or MacOS computer. If you’re using MacOS, the UI will still be very similar to what is shown here.
2. Tap the + icon in the top-right corner.
3. You’re now in the shortcut builder. Tap the “New Shortcut” name at the top of the screen and hit Rename if you want to give your shortcut a custom name. Then hit the Search for Apps and Actions bar near the bottom of the screen.

Next:

1. Search for Dictate Text and add it as your first step.
2. Make sure your language is set, then choose your Stop Listening mode. I prefer After Pause, which automatically stops listening after you pause speaking for long enough.
3. Add another action. Search for and choose Text.

Next:

1. In the Text action’s field, enter your Pipedream trigger URL. Click here to jump back to the earlier instruction if you don’t know how to find it.
2. Add another action. Search for and choose Get URLs from Input.
3. In the variable selector for that action, choose your Text action.

Next:

1. Add another action. Search for and choose Date.
2. Make sure the Date action is set to Current Date.
3. Add another action. Search for and choose Format Date.

Next:

1. Set the Format Date action’s Date Format to ISO 8601, and make sure “Include ISO 8601 Time” is checked.
2. Add another Text action. In this field, enter your name as it is displayed in Notion. This allows you to do self-assignments – e.g. “I need to buy groceries” instead of “Thomas Frank needs to buy groceries”.
3. Add a new action. Search for Set Variable, name the variable name and ensure its value is set to Text (which should be the default).

Next:

1. Add another Text action. In the field, enter a unique passphrase. You’ll need to enter this same passphrase in the settings of your Pipedream workflow later. This helps prevent others from using your workflow, even if they knew your trigger URL. (Still, don’t share your trigger URL nor this passphrase). Learn more about this in the security FAQ section.
2. Add another Set Variable action. Name this one secret and ensure its value is set to Text. This will refer to the Text action directly above it, which is what you want.
3. Add another action. Search for and add Get Contents of URL.

Next:

1. Tap to set the cursor the blank URL field, then tap Select Variable.
2. In the “Select a Magic Variable” screen, find and tap the URLs variable beneath your Get URLs from Text step.
3. Open the settings of your Get Contents of URL action. Set the Method to POST and make sure the Request Body is set to JSON.

Next:

1. Tap Add New Field to add fields to the request body. Create four fields, all with the Text data type. For each field, give it the name shown below and then either tap Select Variable or scroll sideways to find the correct variable:
   • task – set to Dictated Text
   • name – set to the name variable you created
   • date – set to Formatted Date
   • secret – set to the secret variable you created
2. Add a new action. Search for and tap Show Result.
3. Set the Show Result action’s value to Contents of URL.

Now you’re done! You can now hit the Done button and run your shortcut. Make sure to hit Always Allow when asked about sending data to your Pipedream trigger URL.

If you need more help with Apple Shortcuts, here’s the official user guide:

You may also find the Shortcuts subreddit helpful:

When you first install Tasker, you may be asked to go through several setup steps before you can start creating or importing workflows.

Below, you’ll find screenshots and instructions taken from my team’s own experiences in testing this workflow.

I’ll note that Tasker is a complex app, and Android itself is an OS with many device/manufacturer-specific quirks and customizations. It’s possible that your device will show something different than what is shown below.

If you need additional help, consult the official Tasker website.

When you install Tasker, make the following choices if asked:

1. Choose the full Tasker experience, not Tasky.
2. Check all boxes as needed.
3. Disable battery optimizations as needed.

Tasker may require you to disable certain vendor-specific battery optimization options. We only have one Android phone (a Pixel 7) in the office to test workflows, so we can’t provide instructions for every possible Android device. Please refer to this Tasker doc page if you get stuck.

Next:

1. If asked to create a profile, you can create one. We created one called Base.
2. You may also be asked to enble Usage Data Access. If so, tap Ok.

The Pipedream workflow’s code uses fuzzy matching (with Fuse.js) to try to match what you say to an existing project in your workspace.

If you need, you can set Enable Advanced Options to true, then change the value in Project-matching Search Score Threshold if you need tighter or looser matching. You can also set up filters, so that only certain projects are in the pool of potential matches (e.g. only projects that are do not have a “Done” status value).

I’d recommend leaving these settings at their defaults unless you run into issues.

The settings are fairly conservative by default, as matching the wrong project would be much worse than failing to match a project at all.

If the wrong project is matched, the task would likely leave your Task Inbox (assuming you’re using Ultimate Tasks or Ultimate Brain, or have your task manager template set up in a similar way), and you could potentially lose the task.

If no project is matched, the task would go to your inbox and you’d see it quickly.

Tasks can have a due date, but they can also reference event dates that are not the due date. Consider these tasks:

• “I need to prepare my slides for the Friday meeting.”
• “I need to prepare my slides for the Friday meeting by Wednesday.”

Friday is not the due date for either of these, and it’s pretty obvious that it’s not. But what about this task?

• “I need to prepare my slides for the meeting Friday.”

If Friday the day of the meeting here? Is it the due date for the slide-preparation task?

This phrasing does not make the due date clear to me, and so we can’t expect it to be clear to ChatGPT either.

And indeed, my testing shows that ChatGPT (especially the cheaper gpt-3.5-turbo model) is not very accurate at determining due dates from ambiguous phrasing like this.

For that reason, it’s best to be clear about what is a due date and what is not.

Here’s an example, using the default gpt-3.5-turbo model. For reference, the system instructions consume around 1,800 tokens on each run.

You can see how word counts equate to token counts using OpenAI’s Tokenizer tool.

I built this workflow and tutorial using gpt-3.5-turbo, so the gpt-4 pricing is only listed here in case you do have access and want to use it. The workflow does have an option to change the model to gpt-4 if you want.

I have found gpt-3.5-turbo to be adequate for all the tasks I’ve sent it, and I’ve engineered the system instructions in the prompt to handle edge cases well. Of course, gpt-4 will always be better – but if you’re getting consistently good results with gpt-3.5-turbo, I see no reason to pay ~7.5x more per prompt.

If you do end up having issues, try using gpt-4 or customizing your system instructions (advanced).

As far as I know, the only 100% free way to interact with an LLM via an API right now would be to self-host an open-source model on your local machine, build a web app and API to expose it to the internet, and then make requests to it.

That is far beyond the scope of this guide and my current expertise, and it likely will require a pretty high-end GPU to accomplish.

Beyond that, all other methods I know of will cost money in one way or another. You could deploy a model to Replicate, or use one of their public models, but their time-based pricing looks to be even more expensive than ChatGPT’s token-based pricing when using the high-end GPUs that advanced models require.

You could also use a tool like Cog to containerize a model and deploy it to GKE, your own VPS, or a similar cloud hosting solution – but those also come with ongoing costs.

When using this automation, the following data is sent to, and processed by, OpenAI:

• Anything you dictate when using the automation (e.g. whatever you say to create your tasks)
• Your name (or whatever name you set up in your automation)
• The current date

To make things abundantly clear, here’s an example. If I run my automation and say:

I need to buy a new overhead light for the studio redesign project.

…then this is the exact piece of information that will be sent to the ChatGPT API:

{
  task: 'I need to buy a new overhead light for the studio redesign project.',
  name: 'Thomas Frank',
  date: '2023-05-27T08:27:43-06:00'
}

Additionally, the system message is sent to OpenAI. However, this typically just contains instructions on how ChatGPT should respond. If you don’t modify the system messages I’ve provided in this workflow, no additional personal data beyond what was explained above will be sent.

Beyond that, this automation does query your Notion workspace to get both a list of workspace users and a list of projects in your Projects database. None of this information is sent to OpenAI; it is used directly in the automation’s code itself to determine the correct assignee and Project for each task.

Here’s what Open AI’s API data usage policy states:

Starting on March 1, 2023, we are making two changes to our data usage and retention policies:

OpenAI will not use data submitted by customers via our API to train or improve our models, unless you explicitly decide to share your data with us for this purpose. You can opt-in to share data.

Any data sent through the API will be retained for abuse and misuse monitoring purposes for a maximum of 30 days, after which it will be deleted (unless otherwise required by law).

Personally, I am fine with this – but I’d like to make sure you’re aware so you can make your own informed decisions.

To be thorough, here’s a list of the privacy/security pages of each service that processes your information in this workflow:

• OpenAI privacy policy and API usage policy
• Notion security & privacy page
• Pipedream security & privacy page

We may be able to do so in the near future. My team and I are currently researching a few alternative AI options, including using Microsoft Azure’s ChatGPT endpoints and leveraging open-source models like Llama2.

Microsoft Azure

My team and I are currently looking into offering an Azure-based variant of this workflow. If you’re interested in getting updates about it, you can register your interest here.

As Microsoft states in their documentation, Azure’s ChatGPT endpoints also log prompts and completions for abuse monitoring by default. However, customers can apply to have this abuse monitoring disabled for low-risk, privacy-critical purposes.

Microsoft is also far more stringent about who can use their OpenAI endpoints than OpenAI itself is, and there is currently an application/approval process. As of this writing, I’m currently waiting for approval from Microsoft to gain access to the endpoints. If that’s successful, I’ll apply to have monitoring disabled. Assuming that goes well, I’ll start work on developing a privacy-focused Azure variant of the workflow.

Open-Source LLMs

We’re starting to see the emergence of extremely capable open-source LLMs (large language models) that can compete with ChatGPT on certain tasks. Meta’s new Llama 2 model is quite capable, and has produced promising results in my tests. Here’s a demo you can play with on HuggingFace.

Replicate offers this model (in all sizes) on its platform, and Pipedream even has a beta app for Replicate.

It’s possible that the best future option for this workflow would be to fine-tune one of the Llama 2 models using Replicate’s fine-tuning tools, then deploy it to Replicate so you can access it via Pipedream. My intuition says that even a smaller, less computationally-intensive model like Llama 2 7B could handle task parsing with enough fine-tuning.

That said, this is a research avenue I’ve only begun to go down. There are currently a lot of unanswered questions, so I don’t ancipate having anything to show here for a while.

Non-LLM Options

Parsing specific details from natural language is hard. There are currently only a handful of productivity apps that do this well (Todoist, TickTick, Fantastical, iOS Reminders) and even then, you have to speak more precisely than you do with a good LLM like ChatGPT.

At my level of technical ability, I don’t anticipate being able to build a non-LLM version of this workflow anytime soon. I also predict that we’ll see a lot more privacy-friendly LLM tools releasing in the near future, so I don’t even know that it’s worthwhile.

That said, if you’re curious, there are a couple of npm packages I’ll share here:

• Chrono-node – one of the most popular packages for natural-language date parsing.
• Natural – a general language-processing package.

My code already does quite a bit of heavy lifting without relying on ChatGPT – including the fuzzy-matching that allows you to set assignees and projects without needing to say them perfectly.

However, it’s much harder to do things like parsing multiple tasks from a single string, identifying due dates vs. normal date words, etc. That’s why LLMs are such a breakthrough for task processing.

In the interest of security education and full disclosure, I want to note that this secret-key method, while effective, isn’t as good as if we had something like an app with proper authentication (typically via OAuth). With my Notion Voice Notes workflow, the Pipedream workflow is triggered when a file is uploaded to Dropbox/Google Drive – in that case, the workflow is protected by robust OAuth, and all the security features that Dropbox/Google offer.

Here, the only real way to build this workflow in a frictionless way is to use iOS Shortcuts or Tasker on Android – and with those apps, we don’t have the option of using OAuth. So, for now, using a secret key in the POST request is the best option we have.

I will note that my team and I are working on a new project that may solve this in the future. I’m hoping we’ll be able to ship that in early 2024!

I’ve been told by the Pipedream team that this secret-key method is effective, and that the overall risk for this workflow is low. I’ve also taken steps to minimize that risk as much as possible.

On each workflow run, the maximum number of tokens you can have in your prompt is 500. If we add the system instructions and completions from ChatGPT, the full maximum token consumption for each run is around 5,650.

Using the default gpt-3.5-turbo model, which costs $0.0015 per 1,000 tokens for prompts and $0.002 per 1,000 tokens for completions, the max cost per run would be around $0.01007.

On Pipedream’s Free plan, you get 100 credits per day. Each run typically costs 1 credit, so the maximum daily cost (again, using gpt-3.5-turbo) would be around $1.00.

For gpt-4, the system instructions combined with the max input tokens (500) equal 1,136 tokens, with the completion tokens for a prompt of that size being around 1,550. Since gpt-4 (8k context) costs $0.03 per 1,000 prompt tokens and $0.06 per 1,000 completion tokens, the max cost per run would be around $0.127. This means the max cost per day on Pipedream’s Free plan (limited to 100 credits) would be around $12.70.

Again, the best way to mitigate against this in the case of your URL and secret key leaking is the set your Hard Limit in your OpenAI settings to a low monthly amount, such as $10. Typical use should never come even close to that amount – each run costs around $0.003 on gpt-3.5-turbo, or around 300 runs for $1.

If your credit usage hits 100% on the Free plan, you’ll get an email notification (and the same applies if you hit 80% on a paid plan).

If you’re on a Paid Pipedream plan, you can also set a monthly or daily Compute Budget to limit the number of credits that can be consumed in a specific period. If you’re on their Advanced plan, you can also customize concurrency and throttling settings on a per-workflow basis.

When setting up the Pipedream portion of this automation, you may run into an issue where you don’t see any databases in the Tasks Database dropdown:

It’s also possible that you’ll see some databases, but not the one you’re looking for.

There are three potential fixes to this problem:

1. Fix one: Wait
2. Fix two: Ensure permissions are granted
3. Fix three: Go directly to each database, remove the Pipedream connection, then re-add it

First, if you’ve just created a brand-new database to use for this automation, it can take up to 5 minutes for the Notion API to index it. In this case, try waiting about 5 minutes and then refreshing the Pipedream page.

If that doesn’t work, then it’s extremely likely that your Notion connection didn’t give Pipedream permission to access your Tasks database.

To fix this, go to either:

• A page that contains your Tasks database, along with any other databases you want to work with, such as your Projects database (recommended)
• Your Tasks database itself

From there, you can go to the ••• menu in the top-right corner, go to Connections, and click Pipedream in order to give it access to that page and all sub-pages/sub-databases.

Good to Know: Notion uses cascading permissions, meaning that page permissions are determined by the nearest parent page that has custom permissions set. If no parent pages have custom permissions, then a page’s permissions are determined by the top-level page, which will be shown in your sidebar. Of course, if you set custom permissions for a page itself, those will override any cascading permissions.

After doing this, your database should show up in the list of choices within the Tasks Database dropdown in the Pipedream automation.

If that doesn’t work, navigate directly to your Task and Project databases. Manually remove Pipedream from the Connetions section on each, then re-add it from the Add Connections menu.

This is typically not needed, but on occasion the Notion API just fails to grant the needed permission even though Pipedream is listed under Connections.

If you recieve the following error:

“Secret key in the request doesn’t match the one set in the workflow settings.”

…it means the secret property in your mobile app’s request body doesn’t match the secret key you set in your workflow options.

To fix this, first verify the secret key sent by your mobile device by following these steps:

1. Go to the trigger step at the top of the workflow builder
2. In the Exports tab, drill down to steps.trigger → event → body → secret
3. Verify the string listed as the secret property’s value

In the screenshot below, you can see that my secret key for this demo workflow is dogfood.

Next, find the Secret Key option in the main Parse_and_Create_Tasks option. This field hides and encrypts your secret key after you type it, so click the eye icon to show the value.

Type in your key, making sure it matches the secret value from the trigger step.

When setting up the workflow, some properties are dynamically loaded after you choose an option for another property.

For example, you won’t see the Kanban Status Value property until you choose an option for the Kanban Status property – after all, the workflow can’t pull the options from your chosen Notion property until you choose that property!

On occasion, one of these dynamic properties can fail to load. I find that this sometimes happens when you set values for both the Kanban Status and Priority properties in quick succession.

Fortunately, the fix is simple – just click the Refresh Fields button, and the property you’re looking for should load.

If you test your Pipedream workflow and recieve and error like “Request failed with status code 429”, it is likely due to an API key issue with OpenAI.

One beta tester reported that this happened when they set their billing details in their OpenAI account. They had a previously-created API key from when they were using OpenAI’s 3-month trial credits. Once they added their billing details, that API key stopped working.

Other people have reported this error here:

python – OpenAI ChatGPT (GPT-3.5) API error 429: “You exceeded your current quota, please check your plan and billing details” – Stack Overflow

stackoverflow.com

And here:

API keys created before setting up billing don’t work – #2 by tomfrankly – API – OpenAI Developer Forum

This is a bit hard to verify since I think it only happens once for new accounts. However, I’ve got this feedback from 4 different users of my ChatGPT API wrapper UI https://assistant.bloat.app Steps to reproduce (I thi…

community.openai.com

It seems the fix here is simply to go to your OpenAI API key dashboard, create a new key (after setting your billing details), and updating your Pipedream workflow with that new key.

If you do this, I’d recommend deleting the old key as well.

Unfortunately, the Notion API doesn’t currently support working with Reminders.

For this reason, this workflow can’t add Reminders to tasks. Hopefully Notion will add this capability to the API in the future; if they do, I’ll add it as an option to this workflow!

Yes, you can!

You can share the iOS and/or Android instructions with anyone on your team, which will allow them to create tasks in your team Notion workspace.

The only change they’d want to make on their own mobile phone is setting their own name in the name field – that will allow them to self-assign tasks by saying “I need to…”

You’re also more than welcome to duplicate the workflow multiple times in your Pipedream account, which would allow you to set different options in each copy.

A couple of things to keep in mind:

• Anyone with an actual user account in your Pipedream account will be able to see the details of any run within that account. This may be different if you’re on Pipedream’s Enterprise plan (see all plans here), but you’d want to reach out to their team to ask.
• In the case of an error in a workflow, an email with the error details and task details will be sent to the main email address of the Pipedream account. So maybe don’t use this to create a task about surprising your boss for her birthday if she controls the Pipedream account 😉

If you’re interested in enterprise-level privacy with respect to ChatGPT, my team is currently looking into creating a Microsoft Azure-based version of this workflow.

Microsoft has a form your team can fill out in order to opt out of the standard 30-day prompt retention policy, meaning your prompts and completions would be immediately deleted and hence not accessible via Microsoft staff. We don’t yet know if this workflow will be viable, but you can register your interest here and we’ll let you know when we find out.

Yes, you can see the entire code that runs this workflow in the GitHub repo.

The code in the Pipedream workflow looks different because it has been minified in order to imporve performance (this is an industry-standard practice, and is often called bundling). I use a two-step minification process:

1. First, I run the code through Speedy Web Compiler (SWC) with the Module type set to ES Modules, Source Type set to Module, and Minify, Compress, Mangle, and Env Targets enabled.
2. Next, I run the SWC output through Minify JS to minify all the instruction strings.

This workflow is provided free of charge, and currently neither I, nor my team, can provide guaranteed support for it. However, if you find a bug, do please open a Github Issue about it. I’ll do my best to fix those, and I’ll also add fix instructions for common errors to the Common Errors section of this guide.

I’m currently in the process of looking into how I can offer paid support and consulting for companies. If you’re subscribed to my Notion Tips Newsletter, you’ll be the first to know when I have more details about that!

Additionally, my customer community has a AI & Automations space where customers swap tips and help each other out with Notion automations like this. Purchasing any of my premium Notion Templates – such as Ultimate Brain or Creator’s Companion – will get you access. But to be clear, this is one area of our customer community that doens’t get guaranteed support. I pop in to help when I can, but my support team doesn’t have the technical background to help with these advanced automations.

Finally, Pipedream itself has support options, including a community forum and a Slack workspace you can join.

If the workflow is working for you as expected, you shouldn’t need to worry about updates. That said, here’s information on how to update your workflow if needed.

When you click my shared workflow link, a fresh copy of the workflow is created in your Pipedream account. It’s almost exactly like duplicating a Notion template.

This means that you’ll need to click the workflow link in this article again if you want to create a new copy of the workflow. If I update the code at all, that will be the only way for you to get the update. You can see how recently the workflow was updated at the GitHub repo.

There is one exception to this: I’ve set the workflow up so that it will remotely fetch the system instructions for each ChatGPT call from my GitHub repo. If I (or the community) discover a better set of system instructions, I’ll be able to update them there and your workflow will automatically use them on all subsequent runs.

If you enable the Advanced Options in your workflow, you’ll see an option to turn this off. You can also set it to use your own system instructions. See the next toggle for information on that.

By default, this workflow pulls the latest system instructions for ChatGPT from my GitHub repo every time your workflow runs. Here’s the direct link to them. The code also contains “hard-coded” system instructions, and it will fall back on them if you disable the remote fetch or if the fetch operation takes more than 2 seconds.

However, I’ve also included an option for writing your own system instructions.

Note: This option is for experts only. Absolutely no support will be provided for this option.

To enable this option, first enable the advanced options by clicking it in Optional Fields, then scrolling up to it and setting the value to True:

Next, find System Message Source and set it to Write Your Own (Advanced). Then find System Message URL and enter the URL where your system messages are hosted.

I recommend hosting your system messages in a GitHub repo, since it’s free. You could also choose to host on Amazon AWS or any other hosting platform.

Your system messages should be mostly identical to mine, which you can find here. If they are not, the workflow is likely to break. In particular:

• They must be in a JSON file with a parent property called en, containing child properties round_1, round_2, round_3, and gpt_4.
• They must instruct ChatGPT to return data in the exact form that my system messages do.

If you’re going to write your own system messages, I’d recommend first copying mine and then making tweaks. The best way to make tweaks would be to add additional examples that help ChatGPT deal with edge cases you run into, while leaving everything else as-is.

If you’re going to do this, you’re welcome to simply clone my repo (or the system messages section of it), write your messages as text files, and then run system-messages-js.js in a node project.

If you want to adapt this workflow to use a different tool, it’s helpful to understand the fundamental concepts it is using.

At a conceptual level, this workflow is doing a few things:

• Getting text from another source – Siri voice transcriptions, Android voice transcriptions, etc
• Using ChatGPT to turn the natural language of the input text into well-formatted JSON that computers can understand
• Formatting that JSON so it is in a form that the Notion API can understand
• Creating new tasks in Notion

In even simpler terms:

• It accepts text
• It transforms that text into something more useful – first with AI, then with hand-coded functions
• It sends the formatted text to a new destination

If you want to change it so that it support a different tool, you simply need to change part of the workflow to support that tool.

This is actually quite easy if all you want to change is the source. Our Pipedream workflow is triggered when any source sends a POST request to the trigger step’s unique URL, containing a JSON body formatted like so:

{
  task: 'I need to buy a new overhead light for the studio redesign project.',
  name: 'Thomas Frank',
  date: '2023-05-27T08:27:43-06:00'
  secret: 'muffins'
}

If your chosen source can do that, you’re in business. A great tool for testing out POST requests with this type of JSON body is ReqBin, which I used a lot during the build process.

Example: Building a Slash Command for Slack

To give you an example of how you could build an alternative source for your tasks, I’ll give you a brief look at how I built a custom Slack command for creating new tasks in Notion.

I also have a full tutorial for this workflow, though it’s in what I’ll call “draft” state right now. I’ll likely polish it up and post it to this site in the future.

But to keep things short and sweet, I created a slash command in my team’s Slack workspace that allows us to type commands like this:

/task Mount new overhead light a: @Thomas Frank d: 05/10/23 p: Studio Redesign

You can also get fancy and use interactive modals that contain multiple fields, but I opted to keep things simple and used what I’ll call “colon codes” to label things like assingee (a:), due date (d:), etc.

In Pipedream, I wrote code that uses regular expressions to extract the details of each task. This is where the colon codes come in; my regular expressions look for them, and grab the task details that follow them.

import { axios } from "@pipedream/platform"
export default defineComponent({
  props: {
    slack_bot: {
      type: "app",
      app: "slack_bot",
    },
  },
  async run({ steps, $ }) {

    // Set our Slack bot auth token
    const slackToken = this.slack_bot.$auth.bot_token

    /* Get the entire text from the Slack bot command.
    *  Format any colon keys that use semi-colons back to using colons
    *  (handles potential typos by user)
    */
    const text = steps.trigger.event.body.text.replace(/(a|d|p);/g, "$1:")

    // Define our array, taken from the text of the Slack message
    const arr = text.split(" ")

    // Push a "dummy" element onto the end of the array that contains a colon
    arr.push('e:')

    // Create a test function to use with our findIndex() calls in getTaskDetail()
    function colonTest(element) {
      const regex = new RegExp(this)
      const result = regex.test(element)
      return result
    }

    // Extract Slack User ID and fetch Real Name from Slack API using it
    async function getUserID(str) {
      const regex = /<@(\w*)\|/
      const user = str.match(regex)[1]
      let realName
      const response = await axios($, {
        method: 'GET',
        url: `https://slack.com/api/users.info`,
        headers: {
          Authorization: `Bearer ${slackToken}`,
        },
        params: {
          user: user
        }
      }).then((response) => {
        realName = response.user.real_name
      }).catch((error) => {
        console.error(error)
        realName = "Error: User not found"
      })

      return realName
    }

    // Create a function to extract each task parameter
    function getTaskDetail(arr, colonKey) {
      const present = arr.includes(colonKey)
      console.log(`Result for ${colonKey} is ${present}`)
      let result

      // If a colon key wasn't included, set its corresponding value to "Detail not included."
      if (!present) {
        result = "Detail not included."
      } else {
        const slice = arr.slice(arr.findIndex(colonTest, colonKey))
        slice.shift()
        const block = slice.slice(0, slice.findIndex(colonTest, '(a|d|p):')).join(" ")
        const bracket = new RegExp('<@')
        if (bracket.test(block)) {
          result = getUserID(block)
        } else {
          result = block
        }
      }

      // Format the date to ISO 8601 if it is present
      if (colonKey === 'd:' && result !== "Detail not included.") {
        result = formatDatetoISO8601(result)
      }

      return result
    }

    function formatDatetoISO8601(result) {
      // We need to convert the MM/DD/YY string to ISO 8601 - YYYY-MM-DD
      // Split the MM/DD/YY string into an array: ['MM', 'DD', 'YY']
      const dueArray = result.split('/')

      // If day is single-digit (e.g. 1), change to 01
      if (dueArray[0].length === 1) {
        dueArray[0] = '0' + dueArray[0]
      }

      // If month is single-digit (e.g. 1), change to 01
      if (dueArray[1].length === 1) {
        dueArray[1] = '0' + dueArray[1]
      }

      // If year is 2 digits, convert to 4 - e.g. 23 to 2023
      if (dueArray[2].length === 2) {
        dueArray[2] = '20' + dueArray[2]
      }

      // Combine the array elements into an ISO 8601 date string
      result = `${dueArray[2]}-${dueArray[0]}-${dueArray[1]}`

      return result
    }

    // Create an object to hold all the task details
    const taskDetails = {
      task: arr.slice(0, arr.findIndex(colonTest, '(a|d|p):')).join(" "),
      assignee: await getTaskDetail(arr, 'a:'),
      due: await getTaskDetail(arr, 'd:'),
      project: await getTaskDetail(arr, 'p:')
    }

    return taskDetails
  },
})

This code returns an object called taskDetails, which is very similar to the JSON object used in the trigger step of the main tutorial above.

From there, I use the object to create the task in Notion. This automation actually doesn’t use ChatGPT (I originally built it for a privacy-concious organization that didn’t want to use ChatGPT).

If you incorporated ChatGPT as we did in the main tutorial above, you wouldn’t even need the colon codes!

As for sending tasks to a different destination… well, that’s a little bit harder, though not impossible. The workflow above structures each task object to fit the requirements of the Notion API.

If you want to create tasks in another tool, you’ll need to get familiar with that tool’s API (if it has one), and write code to format your tasks for it.

I can’t go much further in this section, as adapting this workflow for other tools is beyond the scope of this tutorial. However, I hope this overview at least gives you some direction for any adaptations you want to make!

As always, I’ll note that ChatGPT itself is an excellent tutor for these kinds of projects.