Integrate Edit Fields (Set) with 500+ apps and services

This workflow will gather data every minute from the GitHub (https://github.com), Docker (https://www.docker.com/), npm (https://www.npmjs.com/) and Product Hunt (https://www.producthunt.com/) website APIs and display select information on a Smashing (https://smashing.github.io/) dashboard. For convenience sake, the dashboard piece can be easily downloaded as a docker container (https://hub.docker.com/r/tephlon/n8n_dashboard) and installed into your docker environment.

This Workflow will extract the domain for the email address.

This workflow appends, lookup, updates, and reads data from a Google Sheet spreadsheet. Set node: The Set node is used to generate data that we want to add to Google Sheets. Depending on your use-case you might have data coming from a different source. For example, you might be fetching data from a WebHook call. Add the node that will fetch the data that you want to add to the Google Sheet. Use can then use the Set node to set the data that you want to add to the Google Sheets. Google Sheets node: This node will add the data from the Set node in a new row to the Google Sheet. You will have to enter the Spreadsheet ID and the Range to specify which sheet you want to add the data to. Google Sheets1 node: This node looks for a specific value in the Google Sheet and returns all the rows that contain the value. In this example, we are looking for the value Berlin in our Google Sheet. If you want to look for a different value, enter that value in the Lookup Value field, and specify the column in the Lookup Column field. Set1 node: The Set node sets the value of the rent by $100 for the houses in Berlin. We pass this new data to the next nodes in the workflow. Google Sheets2 node: This node will update the rent for the houses in Berlin with the new rent set in the previous node. We are mapping the rows with their ID. Depending on your use-case, you might want to map the values with a different column. To set this enter the column name in the Key field. Google Sheets3 node: This node returns the information from the Google Sheet. You can specify the columns that should get returned in the Range field. Currently, the node fetches the data for columns A to D. To fetch the data only for columns A to C set the range to A:C. This workflow can be broken down into different workflows each with its own use case. For example, we can have a workflow that appends new data to a Google Sheet, and another workflow that lookups for a certain value and returns that value. You can learn to build this workflow on the documentation page of the Google Sheets node.

This example workflow demonstrates how to handle pagination. This example assumes that the API you are making the request to has pagination, and returns a cursor (something that points to the next page). This example workflow makes a request to the HubSpot API to fetch contacts. You will have to modify the parameters based on your API. Config URL node: This node sets the URL that the HTTP Request node calls. HTTP Request node: This node makes the API call and returns the data from the API. Based on your API, you will have to modify the parameters of the node. NoOp node and Wait node: These nodes help me avoiding any rate limits. If you're API has rate limits, make sure you configure the correct time in the Wait node. Check if pagination: This IF node checks if the API returns any cursor. If the API doesn't return any cursor, it means that there is no data to be fetched, and the node returns false. If the API returns a cursor, it means that there is still some data that needs to be fetched. In this case, the node returns true. Set next URL: This Set node is used to set the URL. In the next cycle, the HTTP Request node makes a call to this URL. Combine all data: This node combines all the data that gets returned by the API calls from the HTTP Request node.

This workflow allows you to receive updates about the positiong of the ISS and add it to a table in TimescaleDB. Cron node: The Cron node triggers the workflow every minute. You can configure the time based on your use-case. HTTP Request node: This node makes an HTTP Request to an API that returns the position of the ISS. Based on your use-case you may want to fetch data from a different URL. Enter the URL in the URL field. Set node: In the Set node we set the information that we need in the workflow. Since we only need the timestamp, latitude, and longitude we set this in the node. If you need other information, you can set them in this node. TimescaleDB node: This node stores the information in a table named iss. You can use a different table as well.

Receives data from an incoming HTTP Request (set up to use respond to webhook node) Create dummy data Convert JSON to XML which gets returned Respond to Webhook which returns the data and the content type of the data

This workflow recieves webhook data from a form submission and creates a new user (with name and email) if necessary. It also add the current semester of the program to the relation for the user.

This workflow allows you to validate emails stored in a table using the Mailcheck node. Airtable node: This node will list all the records from a table. Based on your use case, you might want to replace this node. Mailcheck node: This node will check the emails that got returned by the previous node. Set node: We will use the Set node to ensure that only the data that we set in this node gets passed on to the next nodes in the workflow. Airtable1 node: This node will update the Valid field in the table. Based on your use case, you might want to replace this node.

This workflow automatically does the following: Scrapes comments and likes from a LinkedIn post. Adds contact data (nominative and verified email address, gender, standardized first name and last name, all legal company information). Adds these contacts to Airtable. Sends an ultra-personalized cold email sequence. Sends a Linkedin invitation after the cold email sending. Pushes all contacts to HubSpot. Prerequisites A Phantombuster account and credentials A Lemlist account and credentials A Dropcontact account and credentials A HubSpot account and credentials How it works Cron node executes the workflow every hour. Phantombuster node (Launch agent) launches the "LinkedIn Post Likers" phantom and the "LinkedIn Post Commenters" phantom. Note that you have to create these phantoms before setting your workflow automation. Phantombuster node (Get Output agent)** gets results from the previous phantoms. Dropcontact node fetches the new contact information and returns the data of the person and the company associated with the email address, job function, and all legal information. Airtable node (List) lists all the records in the Contacts table. IF node routes the workflow based on whether a contact is in Airtable. Set node sets the required data for the following nodes. Airtable node (Update)** updates the record's name. Airtable node (Append)** creates a record if the account doesn't exist yet. Lemlist node adds a contact to an existing campaign. Phantombuster node (Launch agent)** launches the "LinkedIn Network Booster" phantom. Note that you have to create these phantoms before setting your automation. Hubspot node creates or updates the contacts in the HubSpot CRM.

At the end, add the service you need, for example Telegram ++You can only see the result when you run workflow.++ *Based on these answers: Latest RSS Feed -> Rocket.Chat for get only new post Rss to Twitter with Image for get image*

Companion workflow for MySQL node docs

This workflow allows you to store the output of a phantom in Airtable. This workflow uses the LinkedIn Profile Scraper phantom. Configure and launch this phantom from your Phantombuster account before executing the workflow. The workflow uses the following node: Phantombuster node: The Phantombuster node gets the output of the LinkedIn Profile Scraper phantom that ran earlier. You can select a different phantom from the Agent dropdown list, but make sure to configure the workflow accordingly. Set node: Using the Set node we are setting the data for the workflow. The data that we set in this node will be used by the next nodes in the workflow. Based on your use-case, you can modify the node. Airtable node: The Airtable node allows us to append the data in an Airtable. Based on your use-case you can replace this node with any other node. Instead of storing the data in Airtable, you can store the data in a database or Google Sheet, or send it as an email using the Send Email node, Gmail node, or Microsoft Outlook node.

This workflow demonstrates the use of the $item(index) method. This method is useful when you want to reference an item at a particular index. This example workflow makes POST HTTP requests to a dummy URL. Set node: This node is used to set the API key that will be used in the workflow later. This node returns a single item. This node can be replaced with other nodes, based on the use case. Customer Datastore node: This node returns the data of customers that will be sent in the body of the HTTP request. This node returns 5 items. This node can be replaced with other nodes, based on the use case. HTTP Request node: This node uses the information from both the Set node and the Customer Datastore node. Since, the node will run 5 times, once for each item of the Customer Datastore node, you need to reference the API Key 5 times. However, the Set node returns the API Key only once. Using the expression {{ $item(0).$node["Set"].json["apiKey"] }} you tell n8n to use the same API Key for all the 5 requests.

This workflow allows you to send a message in a Telegram chat via bash-dash. Example usage: - telegram I'll be late If you want to send a predefined message without typing it in the command line, you can replace the Text Expression in the Telegram node with a specific message. In this case, the dash command - telegram will send the predefined message to the chat. Example bash-dash config: commands[telegram]="http://localhost:5678/webhook/telegram"

Not sure what to eat tonight? Have recipes emailed to you daily based on your criterial. To run this workflow, you will need to have: A Recipe Search API key from Edamam An active email account with configured credentials To set up your credentials: Set your Edamam AppID and AppKey in the Search Criteria node Select (or create) your email credentials in the Send Recipes node (and set up the to: and from: email addresses while you are at it) To customize the recipes that you receive, open up the Search Criteria node and modify one or more of the following: RecipeCount** - the numner of recipes you would like to receive IngredientCount** - the maximum number of ingredients you would like each recipe to have CaloriesMin** - the minimum number of calories the recipe will have CaloriesMax** - the maximum number of calories the recipe will have TimeMin** - the minimum amount of time (in minutes) the recipe will take to prepare TimeMax** - the maximum amount of time (in minutes) the recipe will take to prepare Diet** - Select one of the following options: balanced - Protein/Fat/Carb values in 15/35/50 ratio high-fiber - More than 5g fiber per serving high-protein - More than 50% of total calories from proteins low-carb - Less than 20% of total calories from carbs low-fat - Less than 15% of total calories from fat low-sodium - Less than 140mg Na per serving random - selects a different random diet each day Health** - Select one of the following options: alcohol-free - No alcohol used or contained immuno-supportive - Recipes which fit a science-based approach to eating to strengthen the immune system celery-free - does not contain celery or derivatives crustacean-free - does not contain crustaceans (shrimp, lobster etc.) or derivatives dairy-free - No dairy; no lactose egg-free - No eggs or products containing eggs fish-free - No fish or fish derivatives fodmap-free - Does not contain FODMAP foods gluten-free - No ingredients containing gluten keto-friendly - Maximum 7 grams of net carbs per serving kidney-friendly - per serving – phosphorus less than 250 mg AND potassium less than 500 mg AND sodium: less than 500 mg kosher - contains only ingredients allowed by the kosher diet. However it does not guarantee kosher preparation of the ingredients themselves low-potassium - Less than 150mg per serving lupine-free - does not contain lupine or derivatives mustard-free - does not contain mustard or derivatives low-fat-abs - Less than 3g of fat per serving no-oil-added - No oil added except to what is contained in the basic ingredients low-sugar - No simple sugars – glucose, dextrose, galactose, fructose, sucrose, lactose, maltose paleo - Excludes what are perceived to be agricultural products; grains, legumes, dairy products, potatoes, refined salt, refined sugar, and processed oils peanut-free - No peanuts or products containing peanuts pecatarian - Does not contain meat or meat based products, can contain dairy and fish pork-free - does not contain pork or derivatives red-meat-free - does not contain beef, lamb, pork, duck, goose, game, horse, and other types of red meat or products containing red meat. sesame-free - does not contain sesame seed or derivatives shellfish-free - No shellfish or shellfish derivatives soy-free - No soy or products containing soy sugar-conscious - Less than 4g of sugar per serving tree-nut-free - No tree nuts or products containing tree nuts vegan - No meat, poultry, fish, dairy, eggs or honey vegetarian - No meat, poultry, or fish wheat-free - No wheat, can have gluten though random - selects a different random health option each day SearchItem* - the general term that you are looking for e.g. *chicken

Listen on new emails on a given IMAP mailbox. Converts the binary XML attachment to a stringified xmlproperty on the $data object and converts it to JSON. The Setnode could be replaced with Function nodes for example to do a conversion/mapping/transformation. The JSON is ultimately sent to a HTTP Endpoint via POST. This could be a starter for EDI purposes like receiving or transmitting XML data and conversion via JSON object property mapping.

This workflow automatically monitors the functionality of a factory. The workflow logs machine data coming from factory sensors in a CrateDB database, generates an incident report in PagerDuty, and notifies the responsible staff members when the temperature of a machine crosses the threshold value. This workflow builds on a workflow that generates factory data. Read more about this use case and how to build both workflows with step-by-step instructions in the blog post How to automate your factory's incident reporting. Prerequisites A PagerDuty account and credentials AMQP, an ActiveMQ  connection, and credentials A CrateDB instance running locally or on a server, and credentials. Nodes AMQP Trigger node starts the workflow. IF node filters sensor values higher than 50°C. PagerDuty node creates an incident in the account. Set nodes set the required incident information and sensor data, respectively. CrateDB nodes ingest the information data and machine sensor data, respectively. Function node converts degrees from Celsius to Fahrenheit.

Companion workflow for Postgres node docs

Companion workflow for Switch node docs

This workflow allows you to receive updates from Wise and add information of a transfer to a base in Airtable. Wise Trigger node: This node will trigger the workflow when the status of your transfer changes. Wise node: This node will get the information about the transfer. Set node: We use the Set node to ensure that only the data that we set in this node gets passed on to the next nodes in the workflow. We set the value of Transfer ID, Date, Reference, and Amount in this node. Airtable node: This node will append the data that we set in the previous node to a table.

This workflow will allow you to get the latest twitter mentions and send those mentions to Rocket.Chat. To ensure that we don't resend the same tweets as before, we use the Function Node and getWorkflowStaticData() to persist the ids of the tweets which have already been sent and filter those out. This leaves us with only the newest tweets.

Receive a new book recommendation each Friday from Open Library. You can select the subject from thousands of options and have a new recommendation delivered to you automatically.

Companion workflow for blog post

This workflow allows you to release a new version via a Telegram bot command. This workflow can be used in your Continous Delivery pipeline. Telegram Trigger node: This node will trigger the workflow when a message is sent to the bot. If you want to trigger the workflow via a different messaging platform or a service, replace the Telegram Trigger node with the Trigger node of that service. IF node The IF node checks for the incoming command. If the command is not deploy, the IF node will return false, otherwise true. Set node: This node extracts the value of the version from the Telegram message and sets the value. This value is used later in the workflow. GitHub node: This node creates a new version release. It uses the version from the Set node to create the tag. NoOp node: Adding this node is optional.

Companion workflow for IF node docs

Simpe API which queries the received country code via GraphQL and returns it. Example URL: https://n8n.exampl.ecom/webhook/1/webhook/webhook?code=DE Receives country code from an incoming HTTP Request Reads data via GraphQL Converts the data to JSON Constructs return string

This workflow will allow you at the beginning of each day to copy your google calendar events into Trello so you can take notes, label, or automate your tasks. When deploying this, don't forget to change: Label ID for meeting type under "Create Trello Cards". You should be able to find instructions Here on how to find the label ID. Description for Trello cards under "Create Trello Cards". I currently pull in notes but it should be simple to change to pull the Gcal description instead. You can change the trigger time to fire at a different time.

This workflow goes through the teachable webhook request types and adds a user, updates him and tags him with #unsubscribe or removes the #unsubscribe tag. It also tags the user with the tag of the name of the course. Enjoy!

This workflow demonstrates how to can use Redis to implement rate limits to your API. The workflow uses the incoming API key to uniquely identify the user and use it as a key in Redis. Every time a request is made, the value is incremented by one, and we check for the threshold using the IF node. Duplicate the following Airtable to try out the workflow: https://airtable.com/shraudfG9XAvqkBpF

This workflow allows you to filter positive and negative feedback received from a Typeform and insert the data into Google Sheets. Typeform Trigger node: Start the workflow when a new form is submitted via Typeform Set node: Extract the information submitted in typeform IF node: Filter positive and negative reviews (i.e. ratings above or below 3 out of 5). Google Sheets node: Store the positive and negative reviews and ratings in two different sheets for each case.

Companion workflow for MongoDB node docs

This workflow creates an automatic self-hosted URL shortener. It consists of three sub-workflows: Short URL creation for extracting the provided long URL, generating an ID, and saving the record in the database. It returns a short link as a result. Redirection for extracting the ID value, validating the existence of its correspondent record in the database, and returning a redirection page after updating the visits (click) count. Dashboard for calculating simple statistics about the saved record and displaying them on a dashboard. Read more about this use case and how to set up the workflow in the blog post How to build a low-code, self-hosted URL shortener in 3 steps. Prerequisites A local proxy set up that redirects the n8n.ly domain to your n8n instance An Airtable account and credentials Basic knowledge of JavaScript, HTML, and CSS Nodes Webhook nodes trigger the sub-workflows on calls to a specified link. IF nodes route the workflows based on specified query parameters. Set nodes set the required values returned by the previous nodes (id, longUrl, and shortUrl). Airtable nodes retrieve records (values) from or append records to the database. Function node calculates statistics on link clicks to be displayed on the dashboard, as well as its design. Crypto node generates a SHA256 hash.

This workflow will trigger daily at 6am to retrieve your day's calendar events from Google Calendar and send them as a summary message to Slack. I've used a low-code method to filter the dates as I can't code much in JSON :) Contact me on https://twitter.com/sami_abid if you have any questions!

Companion workflow for Google Sheets node docs

This workflow looks for a Close Date value using REGEX in the IF node. If it finds the correct value, it will pass that value on. If it does not find the correct value, it will generate a value based on the present time plus three weeks. The final result will show up in the NoOps node. You can text this execution by enabling and disabling the Set node when you run the execution.

This workflow allows you to receive updates when a new contact is added in Autopilot and add them to a base in Airtable. Autopilot Trigger node: The Autopilot Trigger node will trigger the workflow when a new contact is added in Autopilot. Set node: We use the Set node to ensure that only the data that we set in this node gets passed on to the next nodes in the workflow. Airtable node: This node will store the data coming from the previous node in a table in Airtable.

This workflow allows you to get analytics of a website and store it Airtable. In this workflow, we get the analytics for the sessions grouped by the country. Based on your use-case, you can select different Dimensions and set different Metrics. You can use the Cron node or the Interval node to trigger the workflow on a particular interval and fetch the analytics data regularly. Based on your use-case, you might want to store the data returned by Google Analytics to a database or a Google Sheet. Replace the Airtable node with the appropriate node.

This workflow demonstrates how to use currentRunIndex to get the running index. Function node: This node generates mock data for the workflow. Replace it with the node whose data you want to split into batches. SplitInBatches node: This node splits the data with the batch size equal to 1. Based on your use-case, set the value of the Batch Size. IF node: This node checks the running index. If the running index equals 5 the node returns true and breaks the loop. The node uses the expression {{$node["SplitInBatches"].context["currentRunIndex"];}}, which returns the running index. Set node: This node prints a message Loop Ended. Based on your use-case, connect the false output of the IF node to the input of the node you want to execute if the condition is false.

This is an example that gets the logo, icon, and information of a company and stores it in Airtbale. You can set the values that you want to store in the Set node. If you want to store the data in a different database (Google Sheet, Postgres, MongoDB, etc.) replace the Airtable node with that node. You can refer to the documentation to learn how to build this workflow from scratch.

This workflow is triggered when a typeform is submitted, then it saves the sender's information into HubSpot as a new contact. Typeform Trigger: triggers the workflow when a typeform is submitted. Set: sets the fields for the values from Typeform. HubSpot 1: creates a new contact with information from Typeform. IF: filters contacts who expressed their interest in business services. HubSpot 2: updates the contact's stage to opportunity. Gmail: sends an email to the opportunity contacts with informational material. NoOp: takes no action for contacts who are not interested.

This is the workflow that I presented at the April 9, 2021 n8n Meetup. This workflow uses Baserow.io to store registration information collected using n8n as both the web server and the data processor. To get this workflow working properly, you will either need to run it on n8n.cloud or using the on premise version with people having the ability to connect to n8n externally. You will need an account on Baserow.io to store your subscriptions with a table with the following fields: GUID First Name Last Name Email Confirmed

This workflow is triggered when a new order is created in Shopify. Then: the order information is stored in Zoho CRM, an invoice is created in Harvest and stored in Trello, if the order value is above 50, an email with a discount coupon is sent to the customer and they are added to a MailChimp campaign for high-value customers; otherwise, only a "thank you" email is sent to the customer. Note that you need to replace the List ID in the Trello node with your own ID (see instructions in our docs). Same goes for the Account ID in the Harvest node (see instructions here).

This workflow generates sensor data, which is used in another workflow for managing factory incident reports. Read more about this use case and how to build both workflows with step-by-step instructions in the blog post How to automate your factory’s incident reporting. Prerequisites AMQP, an ActiveMQ  connection, and credentials Nodes Interval node triggers the workflow every second. Set node set the necessary values for the items that are addeed to the queue. AMQP Sender node sends a raw message to add to the queue.

Transforms XML data to JSON honoring XML attributes by putting them in a separate key:

Basics Provides a mechanism to save all your workflows into a github repository and path (of your choosing). These can then be shared through your entire org and used to track changes (if you make any sad 'oopsies'. Flow Obtains and creates listing of currently configured workflows. Iterates through each workflow looking at the following Github source (if present) Actual workflow code (from N8N) Workflow code is sorted and compared for any changes If changed (or new) the workflows are saved / archived into github. Configuration Most of the configuration is done in the Globals node which houses the repo detail for github nodes. The only other dependency is that it by default looks for a GitHub credential, if you use something other than that precise wording you will need to change the credential used on the respective nodes. We gave it 'Manage' rights, but that was only so that it was able to override a requirement for checks to complete? Most would probably only need 'Write' privileges. Background Well, so we initially started using N8N just as a kubernetes-based service housed with its DB running inside the pod. Worked great for getting to know N8N and we jut kept all our workflows and credentials listed in a readme. Fast forward about a year... We have migrated this into our 'production' toolsets and maintain a bunch of team worflows inside it (not company-wide, but LOTS of team fun). While trying to spin a copy of our production RDS database, the ++actual++ production database was deleted, and in doing so AWS was nice enough to wipe our snapshots too!! Yea! Thankfully it only took us a few hours to get everything back up and running thanks to this, so I'm sharing it for everyone to benefit. We have used it to restore old workflows, changes, and now to test our full DR proceedures! (Ok, I might have taken that a bit far)

Companion workflow for CrateDB node docs

This workflow allows you to send position updates of the ISS every minute to a topic in MQTT using the MQTT node. Cron node: The Cron node will trigger the workflow every minute. HTTP Request node: This node will make a GET request to the API https://api.wheretheiss.at/v1/satellites/25544/positions to fetch the position of the ISS. This information gets passed on to the next node in the workflow. Set node: We will use the Set node to ensure that only the data that we set in this node gets passed on to the next nodes in the workflow. AWS SQS: This node will send the data from the previous node to the iss-position topic. If you have created a topic with a different one, you can use that topic instead.

Companion workflow for blogpost

Allow your friends to get updates when you do not meet your workout goals so that they can help you get to where you need to be! Monitors your Strava account and sends an email to three accountability partners each day if you have not had enough activity so that they can reach out to you with some encouragement. Make sure that you configure the Accountability Settings to meet your needs along with the Strava and Send Email credentials.

Companion workflow for blogpost

This workflow allows you to collect tweets, store them in MongoDB, analyse their sentiment, insert them into a Postgres database, and post positive tweets in a Slack channel. Cron node: Schedule the workflow to run every day Twitter node: Collect tweets MongoDB node: Insert the collected tweets in MongoDB Google Cloud Natural Language node: Analyse the sentiment of the collected tweets Set node: Extract the sentiment score and magnitude Postgres node: Insert the tweets and their sentiment score and magnitude in a Posgres database IF node: Filter tweets with positive and negative sentiment scores Slack node: Post tweets with a positive sentiment score in a Slack channel NoOp node: Ignore tweets with a negative sentiment score

This workflow stores responses form responses of Typeform in Airtable. The workflow also sends the response to a channel on Slack. You will have to configure the Set node if your form uses different fields.

This workflow gets the top 5 products from Product Hunt and shares them on the Discord server. Cron node: This node triggers the workflow every hour. Based on your use case, you can update the node to trigger the workflow at a different time. GraphQL node: This node makes the API call to the Product Hunt GraphQL API. You will need an API token from Product Hunt to make the call. Item Lists node: This node transforms the single item returned by the previous node into multiple items. Set node: The Set node is used to return only the name, description, and votes of the product. Discord node: This node is used to send the top 5 products to the Discord server.

This workflow allows creating a new Asana task via bash-dash Example usage: \- asana My new task Example bash-dash config: commands[asana]="http://localhost:5678/webhook/asana"

This workflow allows you to send a message on Mattermost when a workflow is updated. Workflow Trigger node: The Workflow Trigger node will trigger the workflow when the workflow gets updated. Mattermost node: This node will send a message on Mattermost, notifying you about the update.

Creates a new team for a project from webhook form data. When the project is created the current semester is added to it's relation attribute. More info can be found on using this workflow as part of a larger system here.

This workflow allows you to receive updates when a customer is subscribed to a list in GetResponse and add them to a base in Airtable. GetResponse Trigger node: This node triggers the workflow when a customer is added to a list. Based on your use-case, you can select a different event. Set node: The Set node is uded here to ensure that only the data that we set in this node gets passed on to the next nodes in the workflow. For this workflow, we set the name and email of the customer. Airtable node: The data from the Set node is added to a table in Airtable. Based on your use-case, you may want to add the infromation about the customer to a CRM instead of a table in Airtable. Replace the Airtable node with the node of the CRM where you want to add the data.

This simple workflow allows you to get an mp4 attachment from gmail email and then upload it to Google Drive to get attachment webview link.

Automatically adding expense receipts to Google Sheets with Telegram, Mindee API, Twilio, and n8n.

This workflow can be used to save all of your workflows in: a raw state (as a json file in Dropbox) an Airtable base, in a pre-designed format. It runs periodically (currently, every 30 minutes) and either updates (if already existing in Airtable) or creates a new record in Airtable for each workflow. Here's the Airtable base to give you an idea: View Airtable base Note: This workflows uses the "http://localhost:5678/rest" API which the UI editor uses but is still not officially supported. Hence, it may suffer breaking changes at some point in the future and the workflow might become dysfunctional then.

This workflow demonstrates how to use noItemsLeft to check if there are items left to be processed by the SplitInBatches node. Function node: This node generates mock data for the workflow. Replace it with the node whose data you want to split into batches. SplitInBatches node: This node splits the data with the batch size equal to 1. Based on your use-case, set the value of the Batch Size. IF node: This node check if all the data by the SplitInBatches are not processed or not. It uses the expression {{$node["SplitInBatches"].context["noItemsLeft"]}} which returns a boolean value. If there is data yet to be processed, the expression will return false, otherwise true. Set node: This node prints a message No Items Left. Based on your use-case, connect the false output of the IF node to the input of the node you want to execute, after the data is processed by the SplitInBatches node.

This n8n workflow automates sending out SMS notifications via Vonage which includes new tech-related vocabulary everyday. To build this handy vocabulary improver, you’ll need the following: n8n – You can find details on how to install n8n on the Quickstart page. LingvaNex account – You can create a free account here. Up to 200,000 characters are included in the free plan when you generate your API key. Airtable account – You can register for free. Vonage account – You can sign up free of charge if you aren’t already.

If you have made some investments in cryptocurrency, this workflow will allow you to create an Airtable base that will update the value of your portfolio every hour. You can then track how well your investments are doing. You can check out my Airtable base to see how it works or even copy my base so that you can customize this workflow for yourself. To implement this workflow, you will need to update the Airtable nodes with your own credentials and make sure that they are pointing to your Airtable

In this video I will show you the workflow canvas and how to use nodes by building your first simple workflow. > Videotuturial on Youtube

This workflow executes every minute and fetches the recent tweets from Twitter with the search query n8n_io. The workflow is built on the concept of polling. Cron node: The Cron node triggers the workflow every minute. Based on your use-case you can configure the time. You can even use the Interval node to trigger the workflow at a certain time interval. Twitter node: The Twitter node searches for the tweets that contain n8n_io and returns the most recent tweets. You can specify a different search query based on your use-case. Set node: The Set node sets the data that we pass on to the next nodes in the workflow. You can set only the values that you require in your workflow. Function node: All the magic happens in this node. The Twitter node returns all the recent tweets, including the ones which were returned earlier. The Function node, using the getWorkflowStaticData() method, only returns the tweets that are new, i.e., the tweets that were not returned in the previous workflow. Mattermost node: The Mattermost node sends the tweets from the Function node to the Twitter notifications channel. If you don't use Mattermost and want to share this data on a different platform, replace this node with the appropriate node.

Companion workflow for Rename Keys node docs

This workflow is scheduled to run every week, when it gets all your Shopify orders, calculates their sales value, stores the data in Google Sheets, and sends a notification message to a Slack channel.

This example workflow allows you to create, update, and get a document in Google Cloud Firestore. The workflow uses the Set node to set the data, however, you might receive data from a different source. Add the node that receives the data before the Set node and set the values you want to insert in a document, in the Set node. Also, update the Columns/ attributes fields in the Google Cloud Firestore node.

This workflow automatically queries a Postgres database to find outlier readings for which SMS notifications have not been sent. This is Workflow 2 in the blog tutorial Database activity monitoring and alerting. Prerequisites A Postgres database set up and credentials A Twilio account and credentials Nodes Cron node triggers the workflow every minute, so the database is queried at regular intervals. Postgres nodes extract values from, and update values in the database. Twilio node sends an alert SMS about the outlier reading to a specified phone number. Set node sets the notification value to true.

Using Typeform to push task requests to an n8n webhook that then categorizes the request and assigns it in ClickUp accordingly. In order to get his workflow working for yourself, you will need: ClickUp account Typeform account Credentials for these services ClickUp configured with appropriate lists Typeform setup with options that correspond with ClickUp lists. You may modify this workflow to meet your specific needs and configuration. This is a very simple version of this workflow and you can make it as complicated as you wish to meet your requirements.

This workflow allows you to send updates about the position of the ISS every minute to a topic in RabbitMQ

This workflow demonstrates the use of static data in n8n. The workflow is built on the concept of polling. Cron node: The Cron node triggers the workflow every minute. You can configure the time based on your use-case. HTTP Request node: This node makes an HTTP Request to an API that returns the position of the ISS. Set node: In the Set node we set the information that we need in the workflow. Since we only need the timestamp, latitude, and longitude we set this in the node. If you need other information, you can set them in this node. Function node: The Function node, checks if the incoming data is similar to the data that was returned in the previous execution or not. If the data is different the Function node returns this new node, otherwise, it returns a message 'No New Items'. The data is also stored as static data with the workflow. Based on your use-case, you can build the workflow further. For example, you can use it send updates to Mattermost or Slack

This workflow allows extracting data from multiple pages website. The workflow: 1) Starts in a country list at https://www.theswiftcodes.com/browse-by-country/. 2) Loads every country page (https://www.theswiftcodes.com/albania/) 3) Paginates every page in the country page. 4) Extracts data from the country page. 5) Saves data to MongoDB. 6) Paginates through all pages in all countries. It uses getWorkflowStaticData('global') method to recover the next page (saved from the previous page), and it goes ahead with all the pages. There is a first section where the countries list is recovered and extracted. Later, I try to read if a local cache page is available and I recover the cached page from the disk. Finally, I save data to MongoDB, and we paginate all the pages in the country and for all the countries. I have applied a cache system to save a visited page to n8n local disk. If I relaunch workflow, we check if a cache file exists to discard non-required requests to the webpage. If the data present in the website changes, you can apply a Cron node to check the website once per week. Finally, before inserting data in MongoDB, the best way to avoid duplicates is to check that swift_code (the primary value of the collection) doesn't exist. I recommend using a proxy for all requests to avoid IP blocks. A good solution for proxy plus IP rotation is scrapoxy.io. This workflow is perfect for small data requirements. If you need to scrape dynamic data, you can use a Headless browser or any other service. If you want to scrape huge lists of URIs, I recommend using Scrapy + Scrapoxy.

This workflow allows you to send position updates of the ISS every minute to a table in Google BigQuery. Cron node: The Cron node will trigger the workflow every minute. HTTP Request node: This node will make a GET request to the API https://api.wheretheiss.at/v1/satellites/25544/positions to fetch the position of the ISS. This information gets passed on to the next node in the workflow. Set node: We will use the Set node to ensure that only the data that we set in this node gets passed on to the next nodes in the workflow. Google BigQuery: This node will send the data from the previous node to the position table in Google BigQuery. If you have created a table with a different name, use that table instead.

This workflow returns the current weather at a predefined or given city and returns it so that it can be displayed with bash-dash. By default does it return the weather in Berlin if no city got defined. That default can be changed in the "Set City" node. Example usage: \- weather london Example bash-dash config: commands[weather]="http://localhost:5678/webhook/weather"

This workflow allows you to send position updates of the ISS every minute to a queue using the AWS SQS node. Cron node: The Cron node will trigger the workflow every minute. HTTP Request node: This node will make a GET request to the API https://api.wheretheiss.at/v1/satellites/25544/positions to fetch the position of the ISS. This information gets passed on to the next node in the workflow. Set node: We will use the Set node to ensure that only the data that we set in this node gets passed on to the next nodes in the workflow. AWS SQS: This node will send the data from the previous node to the iss-position queue. If you have created a queue with a different one, you can use that queue instead.

This workflow automatically finds verified and nominative email and all information (with Dropcontact) to prospect properly from a Typeform. Typeform Trigger**: This node triggers the workflow when a new Typeform is submitted. Dropcontact**: This node fetches the new contact information and returns the data of the person and the company associated with the email address, job function, and all legal information. Airtable - List**: This will list all the entries from your table in order to check if the subscriber is new or not. If**: Does the contact exist in your Airtable yet? Set**: Set values on the Airtable values Airtable Update**: This node updates your record with new and up-to-date data Airtable - Create**: This node creates a new record when the subscriber is a new lead Slack**: This node sends an alert when the record is added or updated

Este workflow es para trabajar con tratamiento de texto usando n8n y poder iniciarte en como funciona. How To, Paso a Paso: https://comunidad-n8n.com/tratamiento-de-textos/ Comunidad de telegram: https://t.me/comunidadn8n

This workflow allows you to add articles to a Notion reading list by accessing a Discord slash command. Prerequisites A Notion account and credentials, and a reading list similar to this template. A Discord account and credentials, and Discord Slash Command connected to n8n. Nodes Webhook node triggers the workflow whenever the Discord Slash command is issued. IF node checks the type returned by Discord. If the type is not equal to 1, it will return true, otherwise false. HTTP Request node makes an HTTP call to the link and gets the HTML of the webpage. HTML Extract node extracts the title from the HTML which we will use in the next node. Notion node adds the link to your Notion reading list. Set nodes set the reply values for Discord and register the Interaction Endpoint URL.

This workflow is a generic example of how to load data from your workflow into a destination that stores tabular data. For example, a Google Sheets or Airtable sheet, a .CSV file, or any relational database like MySQL. Generally, you need to ensure that you send well-formatted data into the Spreadsheet or Database node. You can use the Set or Function node to transform data into the correct format for your destination. Key concepts Spreadsheets and databases have columns, like "Name" and "Email". The data you send into a Spreadsheet/ Database node needs to match these column names for each row of data that you want to insert. Data points need to be represented as key-value pairs. Specifically, each item of data needs to have a JSON key for each column in the sheet. For a spreadsheet with "Name" and "Email" columns, it would look like: {"Name" : "Karla", "Email" : "[email protected]"} Before appending or inserting data to a spreadsheet or database, you might need to transform it into the correct format. You can preprocess the data with a Set or Function node. The Set node allows you to perform simple transforms when the data you want to load into spreadsheet rows is already represented as items. Use the Function node when you need to map nested data (like arrays) inside a single item to their own top-level items (Example in community forums). Spreadsheet and database nodes in n8n perform their configured action (like Append, Create Row, Write to File) on each item of input data. Workflow walkthrough

This n8n template showcases the new HTTP tool released in version 1.47.0. Overall, the tool helps simplify AI Agent workflows where custom sub-workflows were performing the same simple http requests. Comparisons 1. AI agent that can scrape webpages Remake of https://n8n.io/workflows/2006-ai-agent-that-can-scrape-webpages/ Changes: Replaces Execute Workflow Tool and Subworkflow Replaces Response Formatting 2. Allow your AI to call an API to fetch data Remake of https://n8n.io/workflows/2094-allow-your-ai-to-call-an-api-to-fetch-data/ Changes: Replaces Execute Workflow Tool and Subworkflow Replaces Manual Query Params Definitions Replaces Response Formatting

This AI agent can access data provided by another n8n workflow. Since that workflow can be used to retrieve any data from any service, this template can be used give an agent access to any data. Note that to use this template, you need to be on n8n version 1.19.4 or later.

This workflow demonstrates how easy it is to export SQL query to Excel automatically! Before running the workflow please make sure you have access to a remote SQL server (MS SQL, MySQL, PostgreSQL etc.) with a sample table: Date,Band,ConcertName,Country,City,Location,LocationAddress, 2023-05-28,Ozzy Osbourne,No More Tours 2 - Special Guest: Judas Priest,Germany,Berlin,Mercedes-Benz Arena Berlin,"Mercedes-Platz 1, 10243 Berlin-Friedrichshain", 2023-05-08,Elton John,Farewell Yellow Brick Road Tour 2023,Germany,Berlin,Mercedes-Benz Arena Berlin,"Mercedes-Platz 1, 10243 Berlin-Friedrichshain", 2023-05-26,Hans Zimmer Live,Europe Tour 2023,Germany,Berlin,Mercedes-Benz Arena Berlin,"Mercedes-Platz 1, 10243 Berlin-Friedrichshain", 2023-07-07,Depeche Mode,Memento Mori World Tour 2023,Germany,Berlin,Olympiastadion Berlin,"Olympischer Platz 3, 14053 Berlin-Charlottenburg", The detailed process is explained in the tutorial https://blog.n8n.io/export-sql-to-excel

Task: Handle dates and times in your workflow Why: Date and time formats can be hard to work with, we have 2 main ways of doing that with n8n that cover all the main needs Main use cases: Change date format Set custom dates (incl. now and today) Date math

This n8n template demonstrates an approach to image embeddings for purpose of building a quick image contextual search. Use-cases could for a personal photo library, product recommendations or searching through video footage. How it works A photo is imported into the workflow via Google Drive. The photo is processed by the edit image node to extract colour information. This information forms part of our semantic metadata used to identify the image. The photo is also processed by a vision-capable model which analyses the image and returns a short description with semantic keywords. Both pieces of information about the image are combined with the metadata of the image to form a document describing the image. This document is then inserted into our vector store as a text embedding which is associated with our image. From here, the user can query the vector store as they would any document and the relevant image references and/or links should be returned. Requirements Google account to download image files from Google Drive. OpenAI account for the Vision-capable AI and Embedding models. Customise this workflow Text summarisation is just one of many techniques to generate image embeddings. If the results are unsatisfactory, there are dedicated image embedding models such as Google's vertex AI multimodal embeddings.

This workflow sends a OpenAI GPT reply when an email is received from specific email recipients. It then saves the initial email and the GPT response to an automatically generated Google spreadsheet. Subsequent GPT responses will be added to the same spreadsheet. Additionally, when feedback is given for any of the GPT responses, it will be recorded to the spreasheet, which can then be used later to fine-tune the GPT model. Prerequisites OpenAI credentials Google credentials How it works This workflow is essentially a two-in-one workflow. It triggers off from two different nodes and have very different functionality from each trigger. The flow triggered from On email received node is as follows: Triggers off on the On email received node. Extract the email body from the email. Generate a response from the email body using the OpenAI node. Reply to the email sender using the Send reply to recipient node. A feedback link is also included in the email body which will trigger the On feedback given node. This is used to fine-tune the GPT model. Save the email body and OpenAI response to a Google Sheet. If a sheet does not exist, it will be created. The flow triggered from On feedback given node is as follows: Triggers off when a feedback link is clicked in the emailed GPT response. The feedback, either positive or negative, for that specific GPT response is then recorded to the Google Sheet.

n8n does not currently offer a way to retrieve emails from arbritrary providers via a regular node. Unless you're using Gmail or Outlook, you can only use the email trigger to start a workflow when a new email arrives. This currently limits the possible use cases you can cover in your n8n workflows, as you cannot (for example) get an idea of how many unread messages there are in an inbox, or search for specific messages when an event occurs. But fear not, there's a new sheriff in town! The JMAP standard allows you to interact with your mailboxes, calendars and contacts through single HTTP requests whenever needed. This n8n workflow demonstrates how to retrieve the total number of unread messages from a JMAP server and also retrieve details for the first 3 messages. It can easily be adapted to search for messages other than unread, or to return details for more than the first 3 messages. Screenshots FAQ Which n8n version do I need? The workflow was built using n8n 1.20 and should work here out of the box. HTTP requests are also supported on older n8n versions, so the workflow can be backported as an alternative. Which credentials do I need? The JMAP standard does not limit the available authentication options. Fastmail (the sponsor of the standard) supports Bearer authentication as well as OAuth2. In n8n you can implement the Fastmail Bearer authentication by creating Header Auth credentials with a name of Authorization and a value of Bearer $apiToken (replacing $apiToken with your actual API token from Fastmail). For other services you'd need to check the respective API documentation for more details on the support authentication methods. What even is JMAP? It's an official Internet Engineering Task Force (IETF) standard, sponsored by Fastmail, that will hopefully replace the legacy standards CalDAV, CardDAV, and IMAP soon. The full specs are available here. How can I use JMAP? If you're a Fastmail customer or if you're hosting your own Stalwart mail server you can use JMAP today. If your email provider doesn't yet support JMAP, you might want to contact them and let them know you're interested in this functionality.

This workflow allows you to define multiple tickets/issues in a Notion page, then easily import them into Linear. Why is it useful? We use this workflow internally at n8n for collaboration between Product and Engineering teams: Engineering needs all work to be in our ticketing system (Linear) in order to keep track of it Product prefers to review features in Notion. This is because it and can be used to dump all your thoughts and organise them into themes afterwards, plus it better supports rich content like videos Features Supports rich formatting (bullets, images, videos, links, etc.) Keeps links between the Notion and Linear version, in case you need to refer back Allows you to assign each issue to a team member in the Notion definition Avoids importing the same issues twice if you run it again on the same page (meaning you can issues incrementally) You can see an example of the required format of the Notion page here.

This n8n workflow shows how using multimodal LLMs with AI vision can tackle tricky image validation tasks which are near impossible to achieve with code and often impractical to be done by humans at scale. You may need image validation when users submitted photos or images are required to meet certain criteria before being accepted. A wine review website may require users only submit photos of wine with labels, a bank may require account holders to submit scanned documents for verification etc. In this demonstration, our scenario will be to analyse a set of portraits to verify if they meet the criteria for valid passport photos according to the UK government website (https://www.gov.uk/photos-for-passports). How it works Our set of portaits are jpg files downloaded from our Google Drive using the Google Drive node. Each image is resized using the Edit Image node to ensure a balance between resolution and processing speed. Using the Basic LLM node, we'll define a "user message" option with the type of binary (data). This will allow us to pass our portrait to the LLM as an input. With our prompt containing the criteria pulled off the passport photo requirements webpage, the LLM is able to validate the photo does or doesn't meet its criteria. A structured output parser is used to structure the LLM's response to a JSON object which has the "is_valid" boolean property. This can be useful to further extend the workflow. Requirements Google Gemini API key Google Drive account Customising this workflow Not using Gemini? n8n's LLM node works with any compatible multimodal LLM so feel free to swap Gemini out for OpenAI's GPT4o or Antrophic's Claude Sonnet. Don't need to validate portraits? Try other use cases such as document classification, security footage analysis, people tagging in photos and more.

Use case This workflow enables a Telegram bot that can: Accept speech input in one of 55 supported languages Automatically detect the language spoken and translate the speech to another language Responds back with the translated speech output. This allows users to communicate across language barriers by simply speaking to the bot, which will handle the translation seamlessly. How does it work? Translation In the translation step the workflow converts the user's speech input to text and detects the language of the input text. If it's English, it will translate to French. If it's French, it will translate to English. To change the default translation languages, you can update the prompt in the AI node. Output In the output step, we provide the translated text output back to the user and speech output is generated in the translated language. Setup steps Obtain Telegram API Token Start a chat with the BotFather. Enter /newbot and reply with your new bot's display name and username. Copy the bot token and use it in the Telegram node credentials in n8n. Update the Settings node to customize the desired languages Activate the flow Full list of supported languages All supported languages:

This workflow transcribes audio files stored in AWS S3 and stores the information in Google Sheets. Google Drive Trigger node** triggers the workflow when a new file is uploaded in Google Drive. AWS S3 1 node** uploads the new file to an S3 bucket. AWS S3 2 node** gets the file from the S3 bucket. AWS Transcribe 1 node** creates a transciption job for the respective audio file. Wait node** waits for the transcription job from the previous node to be complete before proceeding with the workflow (necessary in case the service is busy or the file to be transcribed is large, delaying the workflow). AWS Transcribe 2 node** gets the information of the transcription job. Set node** sets the necessary values to be included in the data set. Google Sheets node** adds the transcription information to a sheet that serves as data set.

This template can be used as a real-time listening and processing of search results with Icypeas. Be sure to have an active account to use this template. How it works This workflow can be divided into two steps : A webhook node to link your Icypeas account with your n8n workflow. A set node to retrieve the relevant informations. Set up steps You will need a working icypeas account to run the workflow and you will have to paste the production URL provided by the n8n webhook node.

Primer workflow for OpenAI models: ChatGPT, DALLE-2, Whisper This workflow contains 5 examples on how to work with OpenAI API. Transcribe voice into text via Whisper model (disabled, please put your own mp3 file with voice) The old way of using OpenAI conversational model via text-davinci-003 Examples 1.x. Simple ChatGPT calls. Text completion and text edit Example 2. Provide system and user content into ChatGPT Examples 3.x. Create system / user / assistanc content via Code Node. Promtp chaining technique example Example 4. Generate code via ChatGPT Example 5. Return multiple answers. Useful for providing picking the most relevant reply IMPORTANT! Do not run the whole workflow, it's rather slow Better execute the last node of each branch or simply disconnect branches that are not needed

This workflow collects images from web search on a specific query, detects labels in them, and stores this information in a Google Sheet.

Who is this for? This template is for everyone who manages their blog entries in Notion and want to have an easy way to transform them to Webflow. What this workflow does This workflow syncs your blog posts saved in a Notion Database once a day to Webflow. Sync Notion properties, rich text and cover image with your collection. Works with most elements: H1, H2, H3, normal text, bold text, italic text, links, quotes, bulleted lists, numbered lists, and images (under 4MB). Set up steps Connect your accounts. Add a "slug" field in Notion. Add a "Sync to Webflow?" checkbox in Notion. Run a test and map your collection data. Whenever the workflow runs, all the checked posts will be updated in the Webflow collection, whether it's a new post or an existing one.

Who is this for This workflow is perfect for teams and individuals who manage extensive data in Notion and need a quick, AI-powered way to interact with their databases. If you're looking to streamline your knowledge management, automate searches, and get faster insights from your Notion databases, this workflow is for you. It’s ideal for support teams, project managers, or anyone who needs to query specific data across multiple records or within individual pages of their Notion setup. Check out the Notion template this Assistant is set up to use: https://www.notion.so/templates/knowledge-base-ai-assistant-with-n8n How it works The Notion Database Assistant uses an AI Agent built with Retrieval-Augmented Generation (RAG) to query this Knowledge Base style Notion database. The assistant can search across multiple properties like tags or question and retrieves content from inside individual Notion pages for additional context. Key features include: Querying the database with flexible filters. Searching within individual Notion pages and extracting relevant blocks. Providing a reference link to the exact Notion pages used to inform its responses, ensuring transparency and easy verification. This assistant uses two HTTP request tools—one for querying the Notion database and another for pulling data from within specific pages. It streamlines knowledge retrieval, offering a conversational, AI-driven way to interact with large datasets. Set up Find basic set up instructions inside the workflow itself or watch a quickstart video 👇

Automate Report Generation with n8n & Qualys Introducing the Save Qualys Reports to TheHive Workflow—a robust solution designed to automate the retrieval and storage of Qualys reports in TheHive. This workflow fetches reports from Qualys, filters out already processed reports, and creates cases in TheHive for the new reports. It runs every hour to ensure continuous monitoring and up-to-date vulnerability management, making it ideal for Security Operations Centers (SOCs). How It Works: Set Global Variables:** Initializes necessary global variables like base_url and newtimestamp. This step ensures that the workflow operates with the correct configuration and up-to-date timestamps. Ensure to change the Global Variables to match your environment. Fetch Reports from Qualys:** Sends a GET request to the Qualys API to retrieve finished reports. Automating this step ensures timely updates and consistent data retrieval. Convert XML to JSON:** Converts the XML response to JSON format for easier data manipulation. This transformation simplifies further processing and integration into TheHive. Filter Reports:** Checks if the reports have already been processed using their creation timestamps. This filtering ensures that only new reports are handled, avoiding duplicates. Process Each Report:** Loops through the list of new reports, ensuring each is processed individually. This step-by-step handling prevents issues related to bulk processing and improves reliability. Create Case in TheHive:** Generates a new case in TheHive for each report, serving as a container for the report data. Automating case creation improves efficiency and ensures that all relevant data is captured. Download and Attach Report:** Downloads the report from Qualys and attaches it to the respective case in TheHive. This automation ensures that all data is properly archived and easily accessible for review. Get Started: Ensure your Qualys and TheHive integrations are properly set up. Customize the workflow to fit your specific vulnerability management needs. Need Help? Join the discussion on our Forum or check out resources on Discord! Deploy this workflow to streamline your vulnerability management process, improve response times, and enhance the efficiency of your security operations.

Free template for voice & text messages with short-term memory This n8n workflow template is a blueprint for an AI Telegram bot that processes both voice and text messages. Ready to use with minimal setup. The bot remembers the last several messages (10 by default), understands commands and provides responses in HTML. You can easily swap GPT-4 and Whisper for other language and speech-to-text models to suit your needs. Core Features Text: send or forward messages Voice: transcription via Whisper Extend this template by adding LangChain tools. Requirements Telegram Bot API OpenAI API (for GPT-4 and Whisper) 💡 New to Telegram bots? Check our step-by-step guide on creating your first bot and setting up OpenAI access. Use Cases Personal AI assistant Customer support automation Knowledge base interface Integration hub for services that you use: Connect to any API via HTTP Request Tool Trigger other n8n workflows with Workflow Tool

Simple Social: Instagram Single Image Post with Facebook API Who is this workflow for? This workflow is designed for businesses, social media managers, content creators, and developers who need to automate the process of posting single images to Instagram using the Facebook API. It is ideal for anyone looking to streamline their social media posting process, saving time and ensuring consistent content delivery. Use Case / Problem Solved Manually posting images and captions on Instagram can be time-consuming, especially for businesses and content creators managing multiple accounts. This workflow automates the process from image preparation to publishing, reducing manual effort and increasing efficiency. What this workflow does Trigger Initialization: The workflow starts with a manual trigger that can be adapted to other triggers (e.g., HTTP webhook or schedule). Set Parameters: The workflow includes a node that sets essential parameters, such as the image URL, Instagram business account ID, and caption. Prepare Instagram Media: A node prepares the media for upload using the Facebook API, sending the image and caption for pre-publication processing. Check Media Upload Status: The workflow verifies if the media preparation is complete. Conditional Check: If the media preparation is successful, the workflow proceeds to publish; otherwise, it triggers an error-handling path. Publish Media: The media is published on Instagram if the conditions are met. Post-Publish Check: The workflow checks the status after publication. Conditional Check for Publication: If the publication status is "PUBLISHED," it triggers a success path; otherwise, it triggers a failure handling. Email Notifications: The workflow sends email notifications to indicate successful or unsuccessful outcomes. Setup Here is a quick video in italian language with sub eng(https://youtu.be/obWJFJvg_6g) Add API Credentials: Ensure that valid Facebook API credentials are added and configured for use. Permissions Required: Ensure your app has the necessary permissions (ads_management, business_management, instagram_basic, instagram_content_publish, pages_read_engagement). App review may be required for external user access. Node Configuration: Customize the Set Instagram Parameters node to specify the image URL, caption, and Instagram business account ID. Trigger Adaptation: Adapt the initial trigger if needed to fit your workflow's requirements (e.g., schedule, webhook). How to customize this workflow Change the Image URL and Caption**: Modify the Set Instagram Parameters node to change the image and caption. Trigger Customization**: Replace the manual trigger with other triggers like a webhook to automate posting based on external events. Notifications**: Adjust the email nodes to send customized messages or trigger other workflows based on the outcome. Limitations Image Format**: Only JPEG images are supported. Extended JPEG formats such as MPO and JPS are not compatible. Unsupported Tags**: Shopping tags, branded content tags, and filters are not supported. Instagram TV**: Publishing to Instagram TV is not supported. Rate Limit**: Instagram accounts are limited to 50 API-published posts within a rolling 24-hour period. Carousels count as a single post. Check usage with GET /{ig-user-id}/content_publishing_limit. Example Usage Imagine managing a business account that needs consistent posts. You can schedule this workflow or trigger it manually to automatically post images with captions at the right time, ensuring that your audience stays engaged without manual posting efforts.

This n8n workflow template allows you to write WordPress posts by just providing a few keywords. It uses AI technology to write the text and to create the post's featured image. The text includes an introduction, chapters, and conclusions. Each chapter is written independently and this allows you to create also very long articles. The workflow uses technologies provided by Open AI: Chat GPT for the text and Dall-E for the image. I suggest reviewing the created posts before publishing them on your WordPress website. The article generation might take some minutes as each chapter is created independently. Features Easy to use:** Easy web interface to start the generation of the WordPress post AI-powered:** Text and image generation is done by artificial intelligence Long-text ready:** Possibility to create very long articles Configurable:** Possibility to provide as many keywords as you want, to choose the number of chapters and the length of the article Plugs into your WordPress:** Easily integrates with your WordPress website Tweak it as you want:** Fine-tune the Open AI prompts and the workflow as you want Workflow Steps User form:** An n8n form is used to trigger the post creation Settings:** This node is used to set your WordPress URL (which is used later in the workflow) Article structure:** First AI action that writes the introduction, the conclusions, and the chapter structure. Data check:** Check that the data provided by the AI is valid Chapters split/Chapters text:** Splits the data for each chapter in a separate item and generates each chapter's text with AI Content preparation:** Prepares the text for posting merging the introduction, the chapters, and the conclusions. Adds some basic HTML formatting Draft on WordPress:** Creates the draft post on WordPress Featured image:** Creates a featured image and adds it to the post on WordPress User feedback:** Sends a feedback to the user on the n8n form Getting Started To deploy and use this template: Import the workflow into your n8n workspace Set your WordPress URL in the wordpress_url field in the "Settings" node. Include the slash (/) at the end of the URL Set up your Open AI n8n credentials by following this guide. The Open AI credentials are used by the Open AI nodes ("Create post title and structure", "Create chapters text", and "Generate featured image") Set up your WordPress n8n credentials by following this guide. The WordPress credentials are used by the WordPress and HTTP Request nodes ("Post on Wordpress", "Upload media", and "Set image ID for the post"). Pay attention that the "Password" in the WordPress credentials is not the user's password by the Application Password How use the workflow to create a WordPress post Activate the workflow Open the "Form" node and copy the "Production URL". This is the public URL of the form to AI-write the post Open the URL in a browser and fill in the form Wait a few minutes till you get the feedback in the form that the post was created Go to WordPress and check the newly created draft post. Review and publish your post!

Twitter Virtual AI Influencer Workflow Template This n8n workflow template empowers creators to launch a virtual AI influencer that tweets regularly, engaging audiences with a unique niche, writing style, and inspiration. By automating content creation and posting, it ensures a consistent and natural online presence, tailored to your specific influencer profile. Features Scheduled Posting**: Automates tweet posting every 6 hours, with randomized posting minutes to mimic natural activity. On-Demand Posting**: Offers flexibility with manual trigger options for immediate content sharing. Influencer Profile Configuration**: Customize your virtual influencer by defining a target niche, personal writing style, and sources of inspiration. Content Generation**: Leverages advanced AI to craft tweets that resonate with your audience, aiming for viral engagement. Tweet Validation**: Ensures all generated content adheres to Twitter's character limit, maintaining quality and relevance. Workflow Steps Schedule Posting: Configured to post every 6 hours, this step introduces randomness in posting time to simulate human behavior. Trigger Posting Manually: Provides an option to manually initiate a tweet, offering control over the timing of your content. Configure Influencer Profile: Set up your influencer's niche, style, and inspiration to guide the AI in generating targeted content. Generate Tweet Content: Utilizes a sophisticated AI model to produce engaging tweets based on the configured profile. Validate Tweet: Checks if the generated tweet meets Twitter's length constraints, ensuring all content is ready for posting. Post Tweet: Finalizes the process by sharing the AI-generated tweet to your designated Twitter account. Configuration Notes Niche**: Define a specific area of interest, such as "Modern Stoicism," to focus your influencer's content. Writing Style**: Customize the tone and style of the tweets to reflect a personal touch, enhancing relatability. Inspiration**: Input sources of inspiration, including books and philosophies, to steer the content generation process. Getting Started To deploy this template: Import the workflow into your n8n workspace. Customize the influencer profile settings to match your desired niche, style, and inspiration. Connect your Twitter account through the provided OAuth2 credentials setup. Activate the workflow to start building your virtual influencer's presence on Twitter. Embrace the power of AI to create a distinctive and engaging virtual influencer, captivating your audience with minimal effort.

Having a seamless flow of customer data between your online store and your marketing platform is essential. By keeping your systems synchronized, you can ensure that your marketing campaigns are accurately targeted and effective. The integration between Shopify, a leading e-commerce platform, and Mautic, an open-source marketing automation system, is not available out-of-the-box. However, with a n8n workflow you can bridge this gap with. This template will help you: enhance accuracy in marketing lists by ensuring that subscription changes in Shopify are instantly updated in Mautic. improve compliance with data protection laws by respecting users' subscription preferences across platforms achieve integration without the need for additional plugins or software, minimizing complexity and potential points of failure. This template will demonstrate the follwing concepts in n8n: working with Shopify in n8n control flow with the IF node use Webhooks validate Webhooks with the Crypto node use the GraphQL node to call the Shopify Admin API The template consists of two parts: Sync Email Subscriptions from Shopify to Mautic Sync Email Subscriptions from Mautic to Shopify How to get started? Create a custom app in Shopify get the credentials needed to connect n8n to Shopify This is needed for the Shopify Trigger Create Shopify Acces Token API credentials n n8n for the Shopify trigger node Create Header Auth credentials: Use X-Shopify-Access-Token as the name and the Acces-Token from the Shopify App you created as the value. The Header Auth is neccessary for the GraphQL nodes. Enable the Mautic API under Configuration/API Settings, After the settings are saved you will have an additional entry in your settings menu to create API credentials for n8n Create Mautic credentials in n8n Please make sure to read the notes in the template. For a detailed explanation please check the corresponding video: https://youtu.be/x63rrh_yJzI

With this workflow you get a fully automated AI powered Support-Agent for your WooCommerce webshop. It allows customers to request information about things like: the status of their order the ordered products shipping and billing address current DHL shipping status How it works The workflow receives chat messages from an in a website integrated chat. For security and data-privacy reasons, does the website transmit the email address of the user encrypted with the requests. That ensures that user can just request the information about their own orders. An AI agent with a custom tool supplies the needed information. The tool calls a sub-workflow (in this case, in the same workflow for convenience) to retrieve the required information. This includes the full information of past orders plus the shipping information from DHL. If otherr shipping providers are used it should be simple to adjust the workflow to query information from other APIs like UPS, Fedex or others.

Send Typeforms leads via Whatsapp (Twilio)

Workflow Information 📌 Purpose 🎯 The intention of this workflow is to integrate New Shopify Orders into MS Dynamics Business Central: Point-of-Sale (POS):** POS orders will be created in Business Central as Sales Invoices given no fulfillment is expected. Web Orders:** This type of orders will be created as Business Central Sales Orders. How to use it 🚀 Edit the "D365 BC Environment Settings" node with your own account values (Company Id, Tenanant Id, Tax & Discount Items). Go to the "Shopify" node and edit the connection with your environment. More help here. Go to the "Lookup Customers" node to edit the Business Central connection details with your environment settings. Set the required filters on the "Shopify Order Filter" node. Edit the "Schedule Trigger" node with the required frequency. Useful Workflow Links 📚 Step-by-step Guide/ Integro Cloud Solutions Business Central REST API Documentation Video Demo Need Help? Contact me at: ✉️[email protected] 📥 https://www.linkedin.com/in/greg-lopez-08b5071b/

Use case When collecting new leads via a form, you need to follow up on new submissions. Often, this required a lot of manual work that includes reviewing each submission, checking if they meet your criteria and then outreaching. With this workflow you can do all of that fully automatically and save a lot of your valuable time. What this workflow does This workflow runs every time you're receiving a new submission from an n8n form. It then filters out typical personal emails (such as Gmail, Hotmail, Yahoo etc.) before enriching the submission via Clearbit. It then checks, if the company of the submitter is a B2B company and has more than 499 employees. If it does, it sends an email via Gmail to the user. Setup Add the Clearbit and Gmail credentials Click on Test Workflow Enter your own email (which needs to be a business email to work) in the Form Check your email Once you're happy don't forget to activate this workflow How to adjust this template Replace the form trigger with your form provider of choice (e.g. Typeform, SurveyMonkey, Google Forms etc.) Adjust the criteria to your needs via the If node Adjust the email you're sending in the Gmail node

Easily generate images with Black Forest's Flux Text-to-Image AI models using Hugging Face’s Inference API. This template serves a webform where you can enter prompts and select predefined visual styles that are customizable with no-code. The workflow integrates seamlessly with Hugging Face's free tier, and it’s easy to modify for any Text-to-Image model that supports API access. Try it Curious what this template does? Try a public version here: https://devrel.app.n8n.cloud/form/flux Set Up Watch this quick set up video 👇 Accounts required Huggingface.co account (free) Cloudflare.com account (free - used for storage; but can be swapped easily e.g. GDrive) Key Features: Text-to-Image Creation**: Generates unique visuals based on your prompt and style. Hugging Face Integration**: Utilizes Hugging Face’s Inference API for reliable image generation. Customizable Visual Styles**: Select from preset styles or easily add your own. Adaptable**: Swap in any Hugging Face Text-to-Image model that supports API calls. Ideal for: Creators**: Rapidly create visuals for projects. Marketers**: Prototype campaign visuals. Developers**: Test different AI image models effortlessly. How It Works: You submit an image prompt via the webform and select a visual style, which appends style instructions to your prompt. The Hugging Face Inference API then generates and returns the image, which gets hosted on Cloudflare S3. The workflow can be easily adjusted to use other models and styles for complete flexibility.

How it works It’s very important to come prepared to Sales calls. This often means a lot of manual research about the person you’re calling with. This workflow delivers the latest social media activity (LinkedIn + X) for businesses you are about to interact with each day. Scans Your Calendar**: Each morning, it reviews your Google Calendar for any scheduled meetings or calls with companies based on each attendee email address. Fetches Latest Posts**: For each identified company, it fetches recent LinkedIn and X posts Delivers Insight**s: You receive personalized emails via Gmail, each dedicated to a company you’re meeting with that day, containing a reminder of the meeting, list of posts categorized by the social media platform, and direct links to posts. Setup steps The workflow requires you to have the following accounts set up in their respective nodes: Google Calendar GMail Clearbit Besides those, you will need an account on the RapidAPI platform and subscribe to the following APIs: Fresh LinkedIn Profile Data Twitter Email example

Workflow Description: This workflow automates the synchronization of product data from a Shopify store to a Google Sheets document, ensuring seamless management and tracking. It retrieves product details such as title, tags, description, and price from Shopify via GraphQL queries. The outcome is a comprehensive list of products neatly organized in Google Sheets for easy access and analysis. Key Features: Automated: Runs on a schedule you define (e.g., daily, hourly) to keep your product data fresh. Complete Product Details: Retrieves titles, descriptions, variants, images, inventory, and more. Cursor-Based Pagination: Efficiently handles large product sets by navigating pages without starting from scratch. Google Sheets Integration: Writes product data directly to your designated sheets. Set up Instructions: Set up GraphQL node with Header Authentication for Shopify: Create Google Sheet Credentials: Follow this guide to set up your Google Sheet credentials for n8n: https://docs.n8n.io/integrations/builtin/credentials/google/ Choose your Google Sheet: Select the sheet where you want product information written. For the setup, we need a document with two sheets: 1. for storing Shopify data 2. for storing cursor details. Google sheet template : https://docs.google.com/spreadsheets/d/1I6JnP8ugqmMD5ktJlNB84J1MlSkoCHhAEuCofSa3OSM Schedule and run: Decide how often you want the data refreshed (daily, hourly, etc.) and let n8n do its magic!

This workflow automates a two way sync of customer data between Pipedrive and MySQL. It will create new records in one source if it only exists in the other. Where matching records have different data for name, phone number or email address, it will sync the most recently updated version.

🚀 Supercharge Your Website Indexing with This Powerful n8n Workflow! 🌐 Google page indexing too slow? Tired of manually clicking through each page in the Google Search Console? 😴 Say goodbye to that tedious process and hello to automation with this n8n workflow! 🎉 **NB: this workflow was tested with sitemap.xml generated by Ghost CMS and WordPress. Reach out to Eduard if you need help adapting this workflow to your specific use-case!** ⚙️ How this automation works 📅 The workflow runs on a schedule or when you click "Test workflow". 🌐 It fetches the website's primary sitemap.xml and extracts all the content-specific sitemaps (this is a typical structure of the sitemap). 📑 Each content-specific sitemap is then parsed to retrieve the individual page data. 🔄 The extracted page data is converted to JSON format for easy manipulation. 🗃️ The lastmod (last modified date) and loc (page URL) fields are assigned to each page entry to ensure compliance with the Sitemap protocol. 🔀 The page entries are sorted by the lastmod field in descending order (newest to oldest). 🔁 The workflow then loops over each page entry and performs the following steps: 🔍 Checks the URL metadata in the Google Indexing API. ✅ If the page is new or has been updated since the last indexing request, it sends a request to the Google Indexing API to update the URL. ⏳ Wait a sec and move on with the next page. 🌟 Benefits ⏰ Save time by automating the indexing process. 🎯 Ensure all your website pages are consistently indexed by Google. 🚀 Improve your website's visibility and search engine rankings. 🛠️ Customize the workflow to fit your specific CMS and requirements. 🔧 Getting started To start using this powerful n8n workflow, follow these steps: ☑️ Make sure to verify the website ownership in the Google Search Console. 👨‍💻 Import the workflow JSON into your n8n instance. Edit the Get sitemap.xml node and update the URL with your website's valid sitemap.xml 🔑 Set up the necessary credentials for the Google Indexing API. 🎚️ Adjust the schedule trigger to run the workflow at your desired frequency. 🎉 Sit back and let the workflow handle the indexing process for you! Ready to take your website indexing to the next level? 🚀 Try this workflow now and see the difference it makes! 😊 ⚠️ IMPORTANT NOTE 1 Need help with connecting Google Cloud Platform to n8n? Check out our article on connecting Google Sheets to n8n. The process is mainly the same. When activating Google APIs, make sure to add Web Search Indexing API. Also, in the credential page of n8n, add the https://www.googleapis.com/auth/indexing scope: Check out Yulia's page for more n8n workflows! ⚠️ IMPORTANT NOTE 2 Free Google Cloud Platform account allows (re)indexing only 200 pages per day. If your website has more, then the workflow will automatically fail on quota limit ⛔. Next day it will skip the previously added items and continue with remaining pages. Example:* Assuming you have a free Google account, 500 pages on your website and they don't change for 3 days: On the first day 200 pages will be added for indexing and the workflow will fail due to quota limits. On the second day, the workflow will check 200 pages again and skip them (because the date of re-indexing is later then the page last modified date). The next 200 pages will be added to indexing. Workflow will fail again due to quota limits. On the third day 400 pages will be checked and skipped, the last 100 pages will be added for indexing and the workflow finishes successfully.

This workflow reads PDF textual content and sends the text to OpenAI. Attachments of interest will then be uploaded to a specified Google Drive folder. For example, you may wish to send invoices received from an email to an inbox folder in Google Drive for later processing. This workflow has been designed to easily change the search term to match your needs. See the workflow for more details. Prerequisites OpenAI credentials. Google credentials. How it works Triggers off on the On email received node. Iterates over the attachments in the email. Uses the OpenAI node to filter out the attachments that do not match the search term set in the Configure node. You could match on various PDF files (i.e. invoice, receipt, or contract). If the PDF attachment matches the search term, the workflow uses the Google Drive node to upload the PDF attachment to a specific Google Drive folder.

Want to learn the basics of n8n? Our comprehensive quick quickstart tutorial is here to guide you through the basics of n8n, step by step. Designed with beginners in mind, this tutorial provides a hands-on approach to learning n8n's basic functionalities.

This workflow is aimed at generating keywords for SEO and articles To get started, you need to use the workflow as it is. You just call the webhook URL with a query parameter as q={{ $keywords}} For example, you can call it using ?q=keyword research This will give you a list of keywords back as an array. This system can be used by SEO pros, content marketers and also social media marketers to generate relevant keywords for their user needs

Who is this for? This template is designed for businesses and organizations that use Mautic for email marketing and want to automate the process of removing contacts from specific segments when they receive an unsubscribe request via email. What problem is this workflow solving? / use case Many email recipients, especially those who are less tech-savvy, may not follow the standard unsubscribe link provided in emails. Instead, for example in Gmail, they click the "Unsubscribe" button in the Gmail web interface, which in turn sends an email with a consistent format, these emails contain the word unsubscribe in the 'To' field using the following structure: [email protected] This workflow automates the process of identifying such unsubscribe emails and removing the contact from the relevant Mautic segments, ensuring compliance with unsubscribe requests and maintaining a clean mailing list. What this workflow does Monitors a Gmail account for incoming emails. Identifies unsubscribe emails based on specific patterns in the "To" field (e.g., containing the word "unsubscribe"). Retrieves the contact's ID from Mautic based on the email address. Removes the contact from the specified "newsletter" segment in Mautic. Adds the contact to the "unsubscribed" segment in Mautic. Sends a confirmation email to the contact, acknowledging their unsubscribe request. Setup Configure your email address and unsubscribe message in the "Edit Fields" node. Set your credentials in the Gmail trigger and in the Mautic nodes. Set the segments for the "newsletter" and "unsubscribed" in the Mautic nodes. Make sure your n8n installation has a public endpoint for your Gmail trigger to work correctly. Deploy the workflow. How to customize this workflow to your needs Adjust the conditions for identifying unsubscribe emails based on your specific requirements. Modify the segments or actions taken in Mautic according to your desired behavior. Customize the confirmation email message and sender details. Note: This workflow assumes a consistent structure for unsubscribe emails, where the "From" field contains the word "unsubscribe" using the "+" sign. If your email provider follows a different convention, adjust the conditions in the "Is automated unsubscribe?" node accordingly.

What this workflow does This workflow in n8n demonstrates how to send a message in Lark using a Lark bot. It begins with a manual trigger and then retrieves the necessary Lark token via a POST request. The token is used to authenticate and send a message to a specific chat using the Lark API. The input node provides the required app_id, app_secret, chat_id, and message content. After obtaining the token, the message is sent with the Lark API's message/v4/send/ endpoint. Who This Is For This n8n workflow is ideal for organizations, teams, and developers who need to automate message sending within Lark, especially those managing notifications, alerts, or team reminders. It can help users reduce manual messaging tasks by leveraging a Lark bot to deliver messages at specific intervals or based on particular conditions, enhancing team communication and responsiveness. Setup Fill the Input node with your values Exchange the bearer token in the Send Message node with your token Author: Hiroshi

This workflow combines customers' details with their payment data and passes the input to Pipedrive as a note to the organization. Prerequisites Stripe account and Stripe credentials Pipedrive account and Pipedrive credentials How it works Cron node triggers the workflow every day at 8 a.m. HTTP Request node searches for payments in Stripe. The Item Lists node creates separate items from a list of payment data. Merge node takes in the payment data as an input 1. Stripe node gets all the customers data. Set node renames customer-related data fields and keeps only needed fields. Merge node takes in the customer data as an input 2. Merge node combines the payment data with the customers one. Pipedrive node searches for the organization and creates a note with payment data.

How it works Automates the retrieval of Calvin and Hobbes daily comics. Extracts the comic image URL from the website. Translates comic dialogues to English and Korean. Posts the comic and translations to Discord daily. Set up steps Estimated setup time: ~10-15 minutes. Use a Schedule Trigger to automate the workflow at 9 AM daily. Add nodes for parameter setup, HTTP request, data extraction, and integration with Discord. Add detailed notes to each node in the workflow for easy understanding.

Enhance Security Operations with the Qualys Slack Shortcut Bot! Our Qualys Slack Shortcut Bot is strategically designed to facilitate immediate security operations directly from Slack. This powerful tool allows users to initiate vulnerability scans and generate detailed reports through simple Slack interactions, streamlining the process of managing security assessments. Workflow Highlights: Interactive Modals**: Utilizes Slack modals to gather user inputs for scan configurations and report generation, providing a user-friendly interface for complex operations. Dynamic Workflow Execution**: Integrates seamlessly with Qualys to execute vulnerability scans and create reports based on user-specified parameters. Real-Time Feedback**: Offers instant feedback within Slack, updating users about the status of their requests and delivering reports directly through Slack channels. Operational Flow: Parse Webhook Data**: Captures and parses incoming data from Slack to understand user commands accurately. Execute Actions**: Depending on the user's selection, the workflow triggers other sub-workflows like 'Qualys Start Vulnerability Scan' or 'Qualys Create Report' for detailed processing. Respond to Slack**: Ensures that every interaction is acknowledged, maintaining a smooth user experience by managing modal popups and sending appropriate responses. Setup Instructions: Verify that Slack and Qualys API integrations are correctly configured for seamless interaction. Customize the modal interfaces to align with your organization's operational protocols and security policies. Test the workflow to ensure that it responds accurately to Slack commands and that the integration with Qualys is functioning as expected. Need Assistance? Explore our Documentation or get help from the n8n Community for more detailed guidance on setup and customization. Deploy this bot within your Slack environment to significantly enhance the efficiency and responsiveness of your security operations, enabling proactive management of vulnerabilities and streamlined reporting. To handle the actual processing of requests, you will also need to deploy these two subworkflows: Qualys Start Vulnerability Scan Qualys Create Report To simplify deployment, use this Slack App manifest to quickly create an app with the correct permissions: { "display_information": { "name": "Qualys n8n Bot", "description": "n8n Integration for Qualys", "background_color": "#2a2b2e" }, "features": { "bot_user": { "display_name": "Qualys n8n Bot", "always_online": false }, "shortcuts": [ { "name": "Scan Report Generator", "type": "global", "callback_id": "qualys-scan-report", "description": "Generate a report from the latest scan to review vulnerabilities and compliance." }, { "name": "Launch Qualsys VM Scan", "type": "global", "callback_id": "trigger-qualys-vmscan", "description": "Start a Qualys Vulnerability scan from the comfort of your Slack Workspace" } ] }, "oauth_config": { "scopes": { "bot": [ "commands", "channels:join", "channels:history", "channels:read", "chat:write", "chat:write.customize", "files:read", "files:write" ] } }, "settings": { "interactivity": { "is_enabled": true, "request_url": "Replace everything inside the double quotes with your workflow webhook url, for example: https://n8n.domain.com/webhook/99db3e73-57d8-4107-ab02-5b7e713894ad"", "message_menu_options_url": "Replace everything inside the double quotes with your workflow message options webhook url, for example: https://n8n.domain.com/webhook/99db3e73-57d8-4107-ab02-5b7e713894ad"" }, "org_deploy_enabled": false, "socket_mode_enabled": false, "token_rotation_enabled": false } }

Purpose This workflow allows you to transfer credentials from one n8n instance to another. How it works A multi-form setup guides you through the entire process You get to choose one of your predefined (in the Settings node) remote instances first Then all credentials of the current instance are being retrieved using the Execute Command node On the next form page you can select one of the credentials by their name and initiate the transfer Finally the credential is being created on the remote instance using the n8n API. A final form ending indicates if that action succeeded or not. Setup Select your credentials in the nodes which require those Configure your remote instance(s) in the Settings node Every instance is defined as object with the keys name, apiKey and baseUrl. Those instances are then wrapped inside an array. You can find an example described within a note on the workflow canvas. How to use Grab the (production) URL of the Form from the first node Open the URL and follow the instructions given in the multi-form Disclaimer Please note, that this workflow can only run on self-hosted n8n instances, since it requires the Execute Command Node. Security: Beware, that all credentials are being decrypted and processed within the workflow. Also the API keys to other n8n instances are stored within the workflow. This solution is primarily meant for transferring data between testing environments. For production use consider the n8n enterprise edition which provides a reliable way to manage credentials across different environments.

This workflow will take a timer entry from Clockify and submit it to a matching ticket in Syncro. It saves the time entry ID from Clockify and the time entry ID from Syncro into a Google Sheets. Then, it will check if a match already exists from a previous update and will update the same time entry if the description or time is changed in Clockify. There is a Set node with the name and Syncro IDs of technicians. If you have multiple technicians with the same name, this won't work for you. Likewise, if the name in Clockify doesn't exactly match what you put in the Set, it won't work. You also need to setup a webhook in Clockify set to trigger on "Time entry updated (anyone)" and pointed at your workflow. Configured this way, you can start and stop time entries at will and it won't do anything until you change the description. > This workflow is part of an MSP collection, The original can be found here: https://github.com/bionemesis/n8nsyncro

OpenAI Assistant is a powerful tool, but at the time of writing it doesn't automatically remember past messages from a conversation. This workflow demonstrates how to get around this, by managing the chat history in n8n and passing it to the assistant when required. This makes it possible to use OpenAI Assistant for chatbot use cases. Note that to use this template, you need to be on n8n version 1.28.0 or later.

This n8n workflow demonstrates a simple multi-agent setup to perform the task of competitor research. It showcases how using the HTTP request tool could reduce the number of nodes needed to achieve a workflow like this. How it works For this template, a source company is defined by the user which is sent to Exa.ai to find competitors. Each competitor is then funnelled through 3 AI agents that will go out onto the internet and retrieve specific datapoints about the competitor; company overview, product offering and customer reviews. Once the agents are finished, the results are compiled into a report which is then inserted in a notion database. Check out an example output here: https://jimleuk.notion.site/2d1c3c726e8e42f3aecec6338fd24333?v=de020fa196f34cdeb676daaeae44e110&pvs=4 Requirements An OpenAI account for the LLM. Exa.ai account for access to their AI search engine. SerpAPI account for Google search. Firecrawl.dev account for webscraping. Notion.com account for database to save final reports. Customising the workflow Add additional agents to gather more datapoints such as SEO keywords and metrics. Not using notion? Feel free to swap this out for your own database.

How it works This workflow adds a priority to each Todoist item in your inbox, based on a list of projects that you add in the workflow. Setup Add your Todoist credentials Add your OpenAI credentials Set your project names and add priority

Seamlessly Sync and Update Data from a csv in OneDrive to Excel with n8n This workflow is perfect for users who need a reliable, automated way to transfer and organize data from OneDrive into Excel—especially for tasks like portfolio tracking, inventory management, and record-keeping. By monitoring your OneDrive folder for new CSV files, it performs data cleaning, transformation, and real-time updates in an Excel sheet, ensuring only new or changed records are added. How it Works Automated Monitoring: Every minute, the workflow scans a designated OneDrive folder for new files. File Verification: It checks if the detected file is in CSV format; if not, the process stops with an error message. Data Extraction and Cleaning: CSV data is loaded, and irrelevant headers are removed before mapping to specified columns in Excel. Excel Update: The workflow maps data to your Excel sheet, updating only new or modified entries based on a unique identifier ("Ticker/ISIN"). Cleanup: To keep your OneDrive organized, processed files are deleted after updating Excel. Setup Steps Connect OneDrive and Excel Accounts: Link your Microsoft OneDrive and Excel accounts in n8n. Designate Folder and Worksheet: Specify the OneDrive folder for monitoring and the Excel sheet for data updates. Configure Sync Frequency and CSV Validation: Set the monitoring frequency to every minute and ensure the workflow identifies CSV files accurately. Once configured, this workflow offers a hands-free, efficient solution to keep your OneDrive and Excel data synchronized effortlessly.

This workflow allows you to ask questions about the data in a Google Sheet over a chat interface. It uses n8n's built-in chat, but could be modified to work with Slack, Teams, WhatsApp, etc. Behind the scenes, the workflow uses GPT4, so you'll need to have an OpenAI API key that supports it. How it works The workflow uses an AI agent with custom tools that call a sub-workflow. That sub-workflow reads the Google Sheet and returns information from it. Because models have a context window (and therefore a maximum number of characters they can accept), we can't pass the whole Google Sheet to GPT - at least not for big sheets. So we provide three ways of querying less data, that can be used in combination to answer questions. Those three functions are: List all the columns in the sheet Get all values of a single column Get all values of a single row Note that to use this template, you need to be on n8n version 1.19.4 or later.

Hacker News to Video Content Overview This workflow converts trending articles from Hacker News into engaging video content. It integrates AI-based tools to analyze, summarize, and generate multimedia content, making it ideal for content creators, educators, and marketers. Features Article Retrieval: Pulls trending articles from Hacker News. Limits the number of articles to process (configurable). Content Analysis: Uses OpenAI's GPT model to: Summarize articles. Assess their relevance to specific topics like automation or AI. Extract key image URLs. Image and Video Generation: Leonardo.ai: Creates stunning AI-generated images based on extracted prompts. RunwayML: Converts images into high-quality videos. Structured Content Creation: Parses content into structured formats for easy reuse. Generates newsletter-friendly blurbs and social media-ready captions. Cloud Integration: Uploads generated assets to: Dropbox Google Drive Microsoft OneDrive MinIO Social Media Posting (Optional): Supports posting to YouTube, X (Twitter), LinkedIn, and Instagram. Workflow Steps 1. Trigger Initiated manually via the "Test Workflow" button. 2. Fetch Articles Retrieves articles from Hacker News. Limits the results to avoid processing overload. 3. Content Filtering Evaluates if articles are related to AI/Automation using OpenAI's language model. 4. Image and Video Generation Generates: AI-driven image prompts via Leonardo.ai. Videos using RunwayML. 5. Asset Management Saves the output to cloud storage services or uploads directly to social media platforms. Prerequisites API Keys**: Hacker News OpenAI Leonardo.ai RunwayML Creatomate n8n Installation**: Ensure n8n is installed and configured locally or on a server. Credentials**: Set up credentials in n8n for all external services used in the workflow. Customization Replace Hacker News with any other data source node if needed. Configure the "Article Analysis" node for different topics. Adjust the cloud storage services or add custom storage options. Usage Import this workflow into your n8n instance. Configure your API credentials. Trigger the workflow manually or schedule it as needed. Check the outputs in your preferred cloud storage or social media platform. Notes Extend this workflow further by automating social media posting or newsletter integration. For any questions, refer to the official documentation or reach out to the creator. About the Creator This workflow was built by AlexK1919, an AI-native workflow automation architect. Check out the overview video for a quick demo. Tools Used Leonardo.ai** RunwayML** Creatomate** Hacker News API** OpenAI GPT** Feel free to adapt and extend this workflow to meet your specific needs! 🎉

This workflow shows how you can get your OpenAI assistant to call an n8n workflow as a tool. Since you can put almost any functionality in an n8n workflow, this means you can give your assistant access to almost any data source. Note that to use this template, you need to be on n8n version 1.19.4 or later.

Use Case Following up at the right time is one of the most important parts of sales. This workflow uses Gmail to send outreach emails to Hubspot contacts that have already been contacted only once more than a month ago, and records the engagement in Hubspot. Setup Setup HubSpot Oauth2 creds (Be careful with scopes. They have to be exact, not less or more. Yes, it’s not simple, but it’s well documented in the n8n docs. Be smarter than me, read the docs) Setup Gmail creds. Change the email variables in the Set keys node How to adjust this template There's plenty to do here because the approach here is really just a starting point. Most important here is to figure out what your rules are to follow up. After a month? More than once? Also, remember to update the follow-up email! Unless you want to sell n8n 😉

What this does This automation will create tables in your Airtable base and send Webflow form submissions as records in those tables. It keeps track of your Webflow forms with a Form Index table to ensure that form content does not get sent to the wrong table if you have Webflow forms with identical names. This is useful for Enhancing your Webflow form submission management. By sending structured data to your Airtable base you can do more with your Webflow forms. Usage guide Full written and video guide This automation is made to be as low effort as possible to start enhancing your Webflow forms. Simply create credentials for Webflow and a Personal Access Token for your Airtable base and connect them to the relevant nodes. The guide demonstrates a realworld example using a Webflow template and breaksdown the flow and logic for all the nodes.

Use Case When trying to maximize your outreach, website visitors are often an overlooked source of qualified new leads. This workflow allows your to track and enrich new website visitors and saves them to a Google Sheet once they meet a pre-defined criteria. What this workflow does This workflow fires once a day and gets all your leads saved in Leadfeeder. It then takes the leads that meet a pre-defined engagement criteria, e.g. that they visited your site 3 times, and enriches them additionally with Clearbit. From there it filters the leads again by a criteria on the company, e.g. a minimum employee count, and saves matching leads into a Google Sheet document. Setup Add your Leedfeeder credentials. The name should be Authorization and the value Token token=yourapitoken. You can find your token via Settings -> Personal -> API-Token Add your Google Sheet credentials Save the Leedfeeder account names you want to use in the Setup node Copy the Google Sheets Template and add its URL to the Setup node How to adjust this to your needs Adjust and/or remove the engagement and company criteria Add more ways to enrich a company Potential ideas to enhance the use of this workflow Automatically reach out to users that meet the criteria / that get added to the sheet Create a workflow that finds the right employee in companies that are identified by this workflow

Who is this template for? This template is designed for teams who need to automate data retrieval from SharePoint lists using n8n. It is ideal for users who want to authenticate via OAuth and then use the token to access SharePoint API endpoints, pulling in list data directly into n8n. How it works The template first generates an OAuth token using the Microsoft OAuth API. This token is then used to authenticate requests to the SharePoint List API, allowing the workflow to fetch data from a specified SharePoint list. By following the n8n workflow, the user can configure the necessary credentials and endpoints to automate SharePoint data access securely. Setup steps Step 1: Replace {tenant_id}, {client_id}, and {client_secret} with your Azure AD details for OAuth authentication. Step 2: Specify the SharePoint list API endpoint in the template (under "SharePoint List Fetch" node). Step 3: Configure the SharePoint list URL and make adjustments for specific data fields if necessary.

This workflow is for anyone looking to automatically fetch, validate, and parse complex language-based queries into a structured format. Its unique capability lies in not only processing language but also fixing invalid outputs before structuring them. Note that to use this template, you need to be on n8n version 1.19.4 or later.

This workflow is a template example for making Discord GPT-powered bots. Incoming user requests are analysed and categorised via OpenAI node with the help of a hand-crafted prompt. The response message is then routed to a different Discord channel.

This workflow uses OpenAI Assistant to compose draft replies for labeled email messages. It automatically connects the drafts to Gmail threads. 💡 You can add knowledge base to your OpenAI Assistant and make your reply drafts very customized (e.g. compose response with product information in response to inquiry from customer). 🎬 See this workflow in action in my YouTube video about automating Gmail. How it works? The workflow is triggered at regular intervals (default: every 1 minute – you can change this value) to check for messages with a specific label (e.g., "AI"). The content of the retrieved email message is then forwarded to the OpenAI Assistant node, and a reply draft is generated. Next, the response from the Assistant is converted to HTML, and a raw message in RFC standard is composed. 💡 You can learn more about composing drafts with the Gmail API in the official Google documentation. The raw email message (reply draft) is encoded and attached to the original thread ID. Finally, the trigger label (in this case: "AI") is removed to prevent the workflow from looping. Set up steps Set credentials for Gmail and OpenAI. Add new label in Gmail account for messages that should be handled by the workflow (e.g. name it "AI"). Select this label in the first and last Gmail nodes in workflow. Create and configure your OpenAI Assistant. Select your assistant in "OpenAI Assistant" node. Optionally: change trigger interval (by default interval is 1 minute). If you like this workflow, please subscribe to my YouTube channel and/or my newsletter.

Template Description This n8n workflow is designed to manage Fastmail masked email addresses using the Fastmail API. The workflow provides the following functionalities: Retrieve all masked emails: Fetches all masked email addresses associated with the Fastmail account. Create masked email: Allows creating a new masked email with a specified state (pending, enabled, etc.). Update masked email state: Updates the state of a masked email such as enabling, disabling, or deleting it. Generate HTML template: Constructs an HTML table to display the masked emails in a user-friendly format. Steps to Make it Work Webhook Node: This node listens for incoming requests to manage masked emails. Needs Basic Authentication credentials to secure the endpoint. Session Node: Sends a request to obtain session information from Fastmail's API. Requires an HTTP Header Auth credential with your Fastmail API token. Switch Node: Routes the workflow based on the state of the incoming masked email request (pending, enabled, disabled, deleted). HTTP Request Nodes: These nodes handle various Fastmail API calls for masked emails (get, set, update, delete). All HTTP Request nodes require an HTTP Header Auth credential attached, using the Fastmail API token. Set Node: Gathers the retrieved masked email list into an array for further processing. HTML Node: Generates an HTML template to render the masked email addresses in a table format. Respond to Webhook Node: Sends back the HTML table to the client in response to the webhook request. Needed Credentials Fastmail Masked E-Mail Addresses: An API token from Fastmail's API. Each HTTP call to Fastmail requires this credential for authentication. Note Ensure that you correctly configure authentication for the API calls and webhook security. Use your actual Fastmail API credentials with the correct scope. The workflow assumes that the Fastmail API is correctly configured and accessible from your n8n instance. Update URLs and credentials IDs according to your n8n configuration.

Introducing the Qualys Scan Slack Report Subworkflow—a robust solution designed to automate the generation and retrieval of security reports from the Qualys API. This workflow is a sub workflow of the Qualys Slack Shortcut Bot workflow. It is triggered when someone fills out the modal popup in slack generated by the Qualys Slack Shortcut Bot. When deploying this workflow, use the Demo Data node to simulate the data that is input via the Execute Workflow Trigger. That data flows into the Global Variables Node which is then referenced by the rest of the workflow. It includes nodes to Fetch the Report IDs and then Launch a report, and then check the report status periodically and download the completed report, which is then posted to Slack for easy access. For Security Operations Centers (SOCs), this workflow provides significant benefits by automating tedious tasks, ensuring timely updates, and facilitating efficient data handling. How It Works Fetch Report Templates:** The "Fetch Report IDs" node retrieves a list of available report templates from Qualys. This automated retrieval saves time and ensures that the latest templates are used, enhancing the accuracy and relevance of reports. Convert XML to JSON:** The response is converted to JSON format for easier manipulation. This step simplifies data handling, making it easier for SOC analysts to work with the data and integrate it into other tools or processes. Launch Report:** A POST request is sent to Qualys to initiate report generation using specified parameters like template ID and report title. Automating this step ensures consistency and reduces the chance of human error, improving the reliability of the reports generated. Loop and Check Status:** The workflow loops every minute to check if the report generation is complete. Continuous monitoring automates the waiting process, freeing up SOC analysts to focus on higher-priority tasks while ensuring they are promptly notified when reports are ready. Download Report:** Once the report is ready, it is downloaded from Qualys. Automated downloading ensures that the latest data is always available without manual intervention, improving efficiency. Post to Slack:** The final report is posted to a designated Slack channel for quick access. This integration with Slack ensures that the team can promptly access and review the reports, facilitating swift action and decision-making. Get Started Ensure your Slack and Qualys integrations are properly set up. Customize the workflow to fit your specific reporting needs. Link to parent workflow Link to Vulnerability Scan Trigger Need Help? Join the discussion on our Forum or check out resources on Discord! Deploy this workflow to streamline your security report generation process, improve response times, and enhance the efficiency of your security operations.

TOTP Validation with Function Node This template allows you to verify if a 6-digit TOTP code is valid using the corresponding TOTP secret. It can be used in an authentication system. The inputs need to be: a base32 totp secret (String) a 6 digits code (String) ++Important:++ The 6-digit code must be in text format. If the code starts with zeros and is treated as a number, it could cause validation issues. The function node will generate a 6-digit code from the TOTP secret, then compare it with the provided code. If they match, it will return 1 otherwise, it will return 0. Example usage: You retrieve the user's TOTP secret from a database, then you want to verify if the 2FA code provided by the user is valid. Setup Guidelines You only need the ==TOTP VALIDATION== node. You will need to modify lines 39 and 40== of the node with the correct values for your specific context. Testing the Template You can define a sample secret and code in the EXAMPLE FIELDS node of the template, then click "Test Workflow". If the code is valid for the provided secret, the flow will proceed to the true branch of the IF CODE IS VALID node. Otherwise, it will go to the false branch.

Overview This workflow takes some French text, and translates it into spoken audio. It then transcribes that audio back into text, translates it into English and generates an audio file of the English text. To do so, it uses ElevenLabs (which has a free tier) and OpenAI. Setup These steps should only take a few minutes: In ElevenLabs, add a voice to your voice lab and copy its ID. Add it to the 'Set voice ID' node Get your ElevenLabs API key (click your name in the bottom-left of ElevenLabs and choose ‘profile’) In the 'Generate French audio' node, create a new header auth cred. Set the name to xi-api-key and the value to your API key In the 'credential' field of the 'Transcribe audio' node, create a new OpenAI cred with your OpenAI API key Run the workflow by clicking the orange button at the bottom of the canvas

This workflow gets leads' contacts from a CSV file and adds it to the Pipedrive CRM by creating an organization and a person. The CSV file in this workflow serves as a universal connector allowing you to export contacts from any platform like LinkedIn, Facebook, etc. Prerequisites Google account and Google credentials Pipedrive account and Pipedrive credentials How it works The Google Drive Trigger node starts the workflow when a new CSV file is uploaded to a specific folder in Google Drive. Google Drive node downloads the CSV file. Spreadsheet File node reads data from the CSV file and sends the output to the Merge node. This Spreadsheet File's output becomes the input 1 for the Merge node. Meanwhile, the Pipedrive node gets the same list of contacts from the CSV file. IF node checks if Pipedrive has these contacts already created previously and sends the checked results to the Merge node. These results arrive at the Merge node as input 2. Merge node compares two inputs via email and removes the matches. Pipedrive node creates new contacts based on the data provided by the Merge node with necessary details such as organization and notes.

Purpose This workflow enables you to listen to your recent favorites in very hight quality offline without sacrificing all of your storage. How it works This workflow automatically creates a playlist in Spotify named "Downloads" which periodically gets updated so it always contains only a defined amount of the latest liked songs. This enables only the Downloads playlist to set for automatic downloading and thus free up space on the device. Setup The workflow is ready to go. Just select your Spotify credentials and activate the workflow. In Spotify just enable automatic downloads on the automatically created Downloads folder after the first workflow run. Current limitations This setup currently supports a maximum of 50 songs in the Downloads Playlist. This is due to the paylod limits defined by Spotify encountered in the Get liked songs node. Implementing batching would solve the issue.

Who is this template for? This workflow template is designed for everyone with a Gmail address, who wants to forward all Netflix emails, including temporary login codes, to friends and family effortlessly. How it works Scans your Gmail inbox every minute for new e-mails from Netflix Forwards all Netflix e-mails to all desired e-mail addresses via the e-mail provider Mailjet Setup Steps Connect your Google Mail Account to n8n following the official n8n instructions Add all recipients you want to the recipients array at the "Set all recipients" node. Create and connect your Mailjet Account to n8n following the official n8n instructions. Note: You cannot use an Gmail e-mail address as the sender address, as mailjet does not support this. I recommend using your own email address from a custom domain. This works perfectly.

Who might benfit from this workflow? Do you have to record your working hours yourself? Then this n8n workflow in combination with an iOS shortcut will definitely help you. Once set up, you can use a shortcut, which can be stored as an app icon on your home screen, to record the start, end and duration of your break. How it works Once setup you can tap the iOS shortcut on your iPhone. You will see a menu containing three options: "Track Start", "Track Break" and "Track End". After time is tracked iOS will display you a notification about the successful operation. How to set it up Copy the notion database to your notion workspace (Top right corner). Copy the n8n workflow to your n8n workspace In the notion nodes in the n8n workflow, add your notion credentials and select the copied notion database. Download the iOS Shortcut from our documentation page Edit the shortcut and paste the url of your n8n Webhook trigger node to the first "Text" node of the iOS shortcut flow. It is a best practice to use authentication. You can do so by adding "Header" auth to the webhook node and to the shrotcut. You need help implementing this or any other n8n workflow? Feel free to contact me via LinkedIn or my business website. You want to start using n8n? Use this link to register for n8n (This is an affiliate link)

Instructions This automation streamlines the process of collecting user information using a Form Node, enabling individuals to join a waitlist managed via Google Sheets. It also generates a verification code, prompting users to input this code in the Second Form Step. If the code is _nvalid, the workflow keeps the user in a verification loop until a valid code is entered. Once a valid code is provided, the workflow proceeds to the final step, where additional information can be collected. All entered data and intermediate states are securely stored in the Google Sheet. Structure of the GoogleSheet Firstname | Lastname | Email | Company | Verification-Code | Verified | Intended Use Marcel | Claus-Ahrens | foo[at]bar| foobar | abc123 | TRUE | Just testing Setup Set Up a Google Sheet: Create a Google Sheet with the specified columns, or customize them to suit your needs. Verify the "Send Mail" Node: Ensure your "Send Mail" node is functional, or replace it with another email-sending node. Customize Texts and Fields: Update email content, form texts, and form fields to align with your specific use case. Done! Enjoy the workflow! ❤️ let the workf low — Workflow Automation & Development

Instructions This automation overlays a background image with another image, making it easy to add watermarks or logos. You can use this automation to watermark your images by overlaying them with a transparent version of your logo. If you'd like to place your logo in a specific corner, feel free to adjust the position of the overlay image in the code node. How it Works Both images are downloaded, so we can process binary files (you can modify the source, tho.) We extract metadata, focusing on the dimensions of each image. The position of the overlay image is calculated (default: dead center of the background image). The two images are composited together. Limitations and Optimisation Opportunities The overlay image must be the same size or smaller than the background image for proper alignment. The overlay image does not automatically scale to match the proportions of the background image. Enjoy the workflow! ❤️ let the work flow — Workflow Automation & Development

Automate your email management with this workflow, designed for freelancers and business professionals who receive high volumes of emails. By leveraging AI-powered categorisation and dynamic email processing, this template helps you organise your inbox and streamline communication for better efficiency and productivity. Check out the YouTube video for step-by-step set up instructions! How it works: Fetch & Filter Emails: The workflow retrieves emails from your Microsoft Outlook account, filtering out flagged emails and those already categorised. Content Preparation: Each email is cleaned up and converted to a structured format using Markdown, making it easier for AI processing. AI Categorization: The content is analysed using an AI model, which categorises the emails into predefined categories (e.g., Action, Junk, Business, SaaS) based on the context and content. Email Categorization & Folder Management: The categorised emails are updated in Microsoft Outlook and moved to respective folders such as "Junk Email" or "Receipts" based on the AI's classification. Conditional Processing & Final Checks: Additional checks and conditions ensure that only unread emails are processed, and errors are gracefully managed to maintain workflow stability. Set up steps: Connect Microsoft Outlook: Link your Microsoft Outlook account using the built-in credentials node to enable email fetching, updating, and folder management. Configure AI Model (Ollama API): Set up the AI model by connecting to the Ollama API and choosing your desired language model for categorisation. Modify Email Categories (Optional): Customize the categories and subcategories within the workflow to suit your unique email management needs. Set Up Error Handling: Review the error handling node settings to ensure smooth workflow execution. This template offers a robust solution for managing and organising your inbox, helping you save time and keep your focus on important emails.

This workflow enriches new accounts in Pipedrive using Datagma API by adding data about ICP (ideal customer profile). Instead of Pipedrive, you can use any other CRM. In this example, ideal buyers are heads of sales/business development. Prerequisites Pipedrive account and Pipedrive credentials How it works Pipedrive trigger node starts the workflow when a new company is created. HTTP Request node queries data from Datagma. Pipedrive node updates Pipedrive contact with new data from Datagma. The Item Lists node simplifies returned data from Datagma that contain lists (arrays), enabling you to easily modify the structure for further processing without the need to use Function nodes and write custom JavaScript. IF node identifies if the lead corresponds ICP. HTTP Request node searches for emails in Datagma. Set node prepares data for further merging. Merge node combines data from multiple streams. Pipedrive node adds a new person in Pipedrive.

This workflow handles the incoming call from Twitter and sends the required response for verification. On registering the webhook with the Twitter Account Activity API, Twitter expects a signature in response. Twitter also randomly ping the webhook to ensure it is active and secure. Webhook node: Use the displayed URL to register with the Account Activity API. Crypto node: In the Secret field, enter your API Key Secret from Twitter. Set node: This node generates the response expected by the Twitter API. Learn more about connecting n8n with Twitter in the Getting Started with Twitter Webhook article.

In this automation we first make a screenshot with a screenshot API called URLbox and then send this screenshot into the OpenAI API and analyze it. You can extend this automation by the way you want to ingest the website url's & names into this workflow. Options as data source: Postgres Google Sheets Your CRM ... Setup: Replace Website & URL in Setup Node Put in your URLbox API Key Put in your OpenAI credentials Click here for a blog article with more information on the automation.

Description This n8n workflow verifies the deliverability of mailing addresses stored in Keap/Infusionsoft by integrating with Lob’s address verification service. Who is this for? This template is designed for Keap/Infusionsoft users who need to ensure the accuracy of mailing addresses stored in their CRM systems. What problem is this workflow solving? / Use Case This workflow addresses the challenge of maintaining accurate mailing addresses in CRM databases by verifying the deliverability of addresses. What this workflow does A new contact is created in Keap/Infusionsoft Webhook sent to n8n Verify if the address is deliverable via LOB Report back to Keap/Infusionsoft Set Up Steps Watch this setup video: https://www.youtube.com/watch?v=T7Baopubc-0 Takes 10-30 minutes to set up Accounts Needed: Keap/Infusionsoft LOB Account (https://www.lob.com $0.00/mo 300 US addresses Verifications) n8n Before using this template, ensure you have API keys for your Keap/Infusionsoft app and Lob. Set up authentication for both services within n8n. How to customize this workflow to your needs You can customize this workflow by adjusting the trigger settings to match Keap/Infusionsoft’s workflow configuration. Additionally, you can modify the actions taken based on the deliverability outcome, such as updating custom fields or sending notifications.

Use case This workflow snoozes any Todoist tasks, by moving them into a Snoozed todoist list and unsnoozes them 3 days before due date. Helps keep inbox clear only of tasks you need to worry about soon. How to setup Add your Todoist creds Create a Todoist project called snoozed Set the project ids in the relevant nodes Add due dates to your tasks in Inbox. Watch them disappear to snoozed. Set their date to tomorrow, watch it return to inbox. How to adjust this template Adjust the timeline.. Maybe 3 days is too close for you. Works mostly for me :)

This is an add-on for the template Check if workflows contain build-in nodes that are not of the latest version Purpose This workflow highlights outdated nodes within all workflows of a single n8n instance and places an updated preconfigured node right next to it, so it can be swapped easily. How it works The parent workflow checks the entire n8n instance for outdated nodes within all workflows and passes a list of those alongside some metadata to this workflow This workflow then processes that data and updates the affected workflows Outdated nodes are renamed by prepending an emoji (default: ⚠️) - this is also used for future checks to prevent from double-processing The latest version of each outdated node is added to the workflow canvas (not wired up) behind the old one, slightly shifted in position An Email is sent with a list of modified workflows In the settings it is possible to define: which symbol/emoji should be prepended to outdated notes whether to include only major node updates or all of them whether to add the new nodes to the canvas or not Setup Clone this template to your n8n instance Update the Settings node by setting at least the base URL of your n8n instance Set a recipient in the Gmail node Clone the parent template to your n8n instance and configure it as described in it’s description Add an “Execute Workflow” node to the end of the parent workflow and configure it, so it calls this workflow How to use Execute the parent workflow and check your Email Inbox. All linked workflows should contain one or more updated nodes with an emoji prepended to their names. Disclaimer Beware, that major updates can cause migrations of nodes to fail, since their structure can differ. So always compare the old nodes with the newly created, if all parameters still meet the requirements. Be careful when executing this workflow on a production environment, since it directly modifies your workflows. It is advisable to run this on your testing environment and migrate successfully tested workflows to your production environment using git or manually.

Task: Control your data flow with rate limits and external cues Main use cases: Control the rate of items flow into one or more services in your workflow Wait for external events to occur before continuing with the rest of the workflow

📈 Daily Financial News - Description This workflow automates the process of collecting, organizing, and delivering a daily summary of financial news by following these key steps: Scheduled Activation The workflow starts at 7:00 AM each day, triggered by the Schedule Trigger node. News Retrieval The HTTP Request node fetches the latest financial news from FT.com. Content Extraction The Extract Specific Content node scrapes targeted sections of the HTML (headlines, editor's picks, top stories, etc.) using CSS selectors to locate and capture relevant content. News Aggregation The Set Node gathers and organizes the extracted news data, preparing it for summarization. Categories like "Headline #1," "Editor's Picks," and "Europe News" are all structured into a single data block. Summarization An AI Agent (Google Gemini) takes the aggregated news data and creates a concise, HTML-formatted summary tailored to give investors an insightful market snapshot. Email Delivery Finally, the Microsoft Outlook node sends the summary via email to the designated recipient with the subject "Financial news from today." This process ensures that financial news is efficiently curated, summarized, and delivered without manual intervention.

This workflow parses content from a website (for this example, Baserow's release page) and creates an RSS feed based on the extracted data. Prerequisites Some familiarity with HTML and CSS selectors Nodes Webhook node triggers the workflow when new content (a new Baserow release) is published on a website. Set nodes set the required URLs and links for the RSS feed. HTTP Request node fetches data from a specified website page. HTML Extract nodes extract the posts and their fields (such as date, title, description, and link) from the website. Item Lists node iterates over each post on the page. Date & Time node converts the date of the post to a different format. Function Item node creates RSS items for each post. Function node creates the response code for the RSS feed. Respond to Webhook node returns the RSS feed in response to the Webhook node. The result of this workflow would look like this:

Create new Clickup Tasks from Slack commands This workflow aims to make it easy to create new tasks on Clickup from normal Slack messages using simple slack command. For example We can have a slack command as /newTask Set task to update new contacts on CRM and assign them to the sales team This will have an new task on Clickup with the same title and description on Clickup For most teams, getting tasks from Slack to Clickup involves manually entering the new tasks into Clickup. What if we could do this with a simple slash command? Step 1 The first step is to Create an endpoint URL for your slack command by creating an events API from the link [below] https://api.slack.com/apps/) STEP 2 Next step is defining the endpoint for your URL Create a new webhook endpoint from your n8n with a POST and paste the endpoint URL to your event API. This will send all slash commands associated with the Slash to the desired endpoint Step 3 Log on to slack API (https://api.slack.com/) and create an application. This is the one we use to run all automation and commands from Slack. Once your app is ready, navigate to the Slash Commands and create a new command This will include the command, the webhook URL and a description of what the slash command is all about Now that this is saved you can do a test by sending a demo task to your endpoint Once you have tested the webhook slash command is working with the webhook, create a new Clickup API that can be used to create new tasks in ClickUp This workflow creates a new task with the start dates on Clikup that can be assigned to the respective team members More details about the document setup can be found on this document below Happy Productivity

This workflow is designed to automate task reminders by retrieving tasks from a Notion database and sending reminders to Slack users. It checks for incomplete tasks from a Notion database and sends a Slack message to the relevant users with the task details and due dates. The automation is scheduled to run every weekday at 9:00 AM, ensuring that users are always reminded of pending tasks. Who is this for? This workflow is ideal for teams or individuals who manage their tasks using Notion but rely on Slack for communication. It provides an automated solution for ensuring that tasks in Notion are followed up on, reducing the risk of missing deadlines. What problem is this workflow solving? Often, team members need to be reminded of tasks from various platforms. This workflow bridges the gap between task management in Notion and communication in Slack by automatically sending task reminders. It ensures that team members are informed of their pending tasks each morning, helping them stay organized and on top of their work. What this workflow does Triggers every weekday at 9:00 AM: The workflow runs at 9:00 AM, Monday through Friday. Fetches tasks from Notion: It retrieves tasks from a Notion database. Filters incomplete tasks: The workflow filters tasks that are not marked as "Done." Fetches Slack users: It retrieves all Slack users to ensure that the reminders are sent to the correct user. Matches tasks to the correct user: It checks the Notion task assignee and matches it with the appropriate Slack user. Sends Slack reminders: Sends a Slack direct message to each user with their incomplete tasks and due dates. Setup Connect Notion: You will need to connect your Notion account and specify the database containing tasks. Connect Slack: Authenticate with Slack using OAuth to allow the workflow to send messages on your behalf. Notion user email mapping: Ensure that the Notion users’ email addresses are correctly mapped to their corresponding Notion user profiles. Slack user full name mapping: Ensure that the Slack users’ full names are correctly mapped to their corresponding Slack user profiles. Adjust schedule: If needed, modify the schedule node to run at a different time or frequency. How to customize this workflow Change the database**: You can adjust the workflow to pull tasks from a different Notion database by modifying the "Get To Dos from Tasks Database" node. Add more users**: The workflow currently supports two users, but you can expand it to support more by adding additional logic in the "Switch for Notion Users Emails" node. Modify the message format**: The Slack message content can be customized further to include more task details or change the message format. Workflow Summary This workflow automates sending task reminders from a Notion database to Slack users. By running every weekday morning, it ensures that users receive timely reminders of their incomplete tasks, helping them stay organized and efficient.

Use n8n to bring data from any API to your AI. This workflow uses the Chat Trigger to provide the chat interface, and the Custom n8n Workflow Tool to call a second workflow that calls the API. The second workflow uses AI functionality to refine the API request based on the user's query. It then makes an API call, and returns the response to the main workflow. This workflow is used in Advanced AI examples | Call an API to fetch data in the documentation. To use this workflow: Load it into your n8n instance. Add your credentials as prompted by the notes. Requires n8n 1.28.0 or above

How it works: This project creates a personal AI assistant named Angie that operates through Telegram. Angie can summarize daily emails, look up calendar entries, remind users of upcoming tasks, and retrieve contact information. The assistant can interact with users via both voice and text inputs. Step-by-step: Telegram Trigger: The workflow starts with a Telegram trigger that listens for incoming message events. The system determines if the incoming message is voice or text. If voice, the voice file is retrieved and transcribed to text using OpenAI's API Speech to Text AI Assistant: The telegram request is passed to the AI assistant (Angie). Tools Integration: The AI assistant is equipped with several tools: Get Email: Uses Gmail API to fetch recent emails, filtering by date. Get Calendar: Retrieves calendar entries for specified dates. Get Tasks: Connects to a Baserow (open-source Airtable alternative) database to fetch to-do list items. Get Contacts: Also uses Baserow to retrieve contact information. Response Generation: The AI formulates a response based on the gathered information and sends back to the user on Telegram

Use Case Generate accurate search volume data for SEO keyword research: You have a list of potential keywords to target for your website SEO but don't know their actual search volume You need historical data to identify seasonal trends in keyword popularity You want to assess keyword difficulty to prioritize your content strategy You need data-driven insights for planning your SEO campaigns What this Workflow Does The workflow connects to Google's Keyword Planner API to retrieve keyword metrics for your SEO research: Fetches monthly search volume for each keyword Provides historical trends data for the past 12 months Calculates keyword difficulty scores Delivers competition metrics from Google Ads Setup Fill the Set 20 Keywords with up to 20 Keywords of your choosing in an array e.g. ["keyword 1", "keyword 2",...] Create a Google Ads API account and add credentials to Get Search Data node Replace the Connect to your own database with your own database for the output How to Adjust it to Your Needs Change the Set 20 Keywords node input to a source of your choosing e.g. Airtable database with 20 keywords Connect to output source of your choosing Made by Simon @ automake.io

This workflow automatically imports data from a CSV file located at a specific URL and then updates the Google Sheets document with the provided data. Below is a step-by-step description of what this workflow does: The workflow is started manually using the "When you click 'Execute Workflow'" node. The CSV file is then uploaded from the specified URL "https://opendata.ecdc.europa.eu/covid19/testing/csv/data.csv" using the "Upload CSV" node. The "Import CSV" node accepts the uploaded CSV file and converts it into JSON formatted data. The "Add Unique Field" node generates a unique key by combining the 'country_code' and 'year_week' fields from the JSON data, which will be further used in the Google Sheets document. The 'Keep only DACH in 2023' node filters the data to keep only records where 'country_code' is either 'DE', 'AT', or 'CH' and 'year_week' starts with '2023'. Google's API has limitations on the speed of read and write operations, so only a subset of the data is taken. The filtered data is loaded into the specified Google Sheets document via the 'Load to Spreadsheet' node. The operation is set to 'appendOrUpdate' and the document ID and sheet name are specified. Also, the previously generated 'unique_key' key is set as the key to match the columns.

Fetches workflow definitions from within n8n, selecting only the ones that have one or more (configurable) assigned tags and then: Derives a suitable backup filename by reducing the workflow name to a string with alphanumeric characters and no-spaces Note: This isn't bulletproof, but works as long as workflow names aren't too crazy. Determines which workflows need to be backed up based on whether each one: has been modified. (Note: Even repositioning a node counts.) ...or... is new. (Note: Renaming counts as this.) Commits JSON copies of each workflow, as necessary, to a Gitlab repository with a generated, date-stamped commit message. Setup Credentials Create a Gitlab Credentials item and assign it to all Gitlab nodes. Create an n8n Credentials item and assign it to the n8n node Note: This was tested with http://localhost:5678/api/v1 but should work with any reachable n8n instance and API key. Modify these values in the "Globals" Node gitlab_owner - {{your gitlab account}} gitlab_project - {{ your gitlab project name }} gitlab_workflow_path - {{ subdirectory in the project where backup files should be saved/committed }} tags_to_match_for_backup - {{tag(s) to match for backup selection}} *ALERT: According to the n8n node's Filters -> tags field annotations, and API documentation, this supports a CSV list of multiple tags (e.g. tag1,tag2), but the API behavior requires workflows to have all-of the listed tags, not any-of them.* See: https://github.com/n8n-io/n8n/issues/10348 TL/DR - Don't expect a multiple tag list to be more inclusive. Possible workaround: To match more than one tag value, duplicate the n8n node into multiple single-tag matches, or split and iterate multiple values, and merge the results. Possible Enhancements Make the branch ("Reference") for all the gitlab nodes configurable. Fixed on all as "main" in the template. Add an n8n node to generate an audit and store the output in gitlab along with the backups. Extend the workflow at the end to create a Gitlab release/tag whenever any backup files are actually updated or created.

Integrate Xero with FileMaker using Webhooks Workflow Description This n8n workflow automates the integration between Xero and FileMaker, allowing for seamless data transfer between the two platforms. By listening for webhooks from Xero (e.g., new invoices, payments, or contacts), this workflow ensures that data is automatically sent and recorded in a FileMaker database. Who is This For? This workflow template is ideal for: Accountants** who need a streamlined process to sync financial data between Xero and FileMaker. Business Owners** looking to automate data entry and improve accuracy across their systems. Developers** building solutions for clients that require integration between accounting software and databases. Operations Teams** focused on minimizing manual work and improving efficiency. Key Steps Xero Webhook Trigger: The workflow starts by capturing events from Xero via a webhook. Data Processing: Transforms and maps the incoming data to match FileMaker’s required format. FileMaker Node: Utilizes the FileMaker node to create or update records directly in the FileMaker database. Logging & Error Handling: Tracks successful entries and manages any errors with automated alerts. Setup Instructions Set Up the Xero Webhook: Create a webhook in Xero and point it to your n8n webhook node URL. Configure the types of events to trigger the workflow (e.g., new invoices or payments). Xero will then send some test calls to test you are doing proper hash control. Connect the FileMaker Node: Set up your FileMaker node with the appropriate credentials and database configuration. Map the fields between the incoming Xero data and your FileMaker database structure. Customize Data Processing: Adjust data transformations as needed to ensure compatibility with your FileMaker schema. Test and Deploy: Run the workflow with sample data to ensure everything is functioning correctly. Monitor the execution log to verify data transfer and make any adjustments as needed. Error Handling Configuration: Configure error-handling nodes or alerts to notify you of any issues during data processing. Benefits This setup facilitates real-time data synchronization between Xero and FileMaker, reducing the need for manual data entry and improving overall operational efficiency.

This workflow is an experiment to integrate charts in AI Agents, using the new Structured Output from OpenAI and Quickchart.io. How it works Users chat with an AI Agent. Anytime the AI Agent considers a chart is needed, it calls a tool to generate a chart OpenAI generates a chart using the Quickchart definition This object is added at the end of a Quickchart.io URL (see documentation) The url is added in the conversation via the AI Agent as markdown. Set up steps Create an OpenAI API Key Create the OpenAI credentials Use the credentials for the HTTP Request node (as Predefined Credential type) Activate your workflow Start chatting For example, you can ask the AI Agent to generate a chart about the top 5 movies at the box office Start exploring the limits Shout-out Quickchart.io is an amazing open source project that provides a free API to test. Go check them out! Example of chart

Who is it for If you are a postmaster or you manage email server, you can set up DKIM and SPF records to ensure that spoofing your email address is hard. On your domain you can also set up DMARC record to receive XML reports from email providers (rua tag). Those reports contain data if email they received passed DKIM and SPF verifications. Since DMARC email is public, you will receive a lot of emails from email providers, not only if DKIM/SPF fail. There is no need for it - you probably only need to know if SPF/DKIM failed. So this script is intended to automatically parse all DMARC reports that come from email providers, but ONLY send you notification if SPF or DKIM failed - meaning that either someone tries to spoof your email or your DKIM/SPF is improperly set up. How it works script monitors postmaster email for DMARC reprots (rua) unpacks report and parses XML into JSON maps JSON and formats fields for MySQL/MariaDB input inputs into database sends notification on DKIM or SPF failure Remember to set up email input mailbox notification channels for slack for email

Template Information Who is this template for? This template is for users looking to retrieve email information from LinkedIn profiles and update Google Sheets with the collected data. 🎥 quick set up video How it works** The template utilizes a series of nodes to fetch email information from LinkedIn profiles. It starts with a Schedule Trigger node that sets the interval for the workflow. The Conditional Check node verifies if certain fields like Name, Gender, Job Title, Summary, and LinkedIn URL are not empty. The HTTP Request node sends a POST request to the specified URL with API key and profile information. The Data Merge node merges the data collected. The Field Editing node modifies the fields as needed. Finally, the Google Sheets Update node updates the Google Sheets with the gathered information. Set Up Instructions Make sure to have the necessary credentials and permissions for accessing LinkedIn and Google Sheets. Set up the API key required for the HTTP Request node. Configure the Google Sheets Update node with the appropriate document ID and sheet name. Check and adjust field mappings in the Field Editing node according to your needs. Run the workflow and monitor the updates in your Google Sheets document. Overview: The workflow is designed to find contact information for LinkedIn profile URLs stored in a Google Sheet. It involves various nodes for different operations such as making HTTP requests, scheduling triggers, reading from and updating Google Sheets, field editing, data merging, and conditional checks. A video demonstrating the workflow process can be accessed here. Copy this template to get started : Google Sheets Using Prospeo.io LinkedIn Email Finder API with cURL To use the API endpoint "https://api.prospeo.io/linkedin-email-finder" with cURL, follow these steps: Use the cURL command with the following parameters: curl -X POST \ -H "Content-Type: application/json" \ -H "X-KEY: your_api_key" \ -d '{ "url": "https://www.linkedin.com/in/john-doe/" }' \ "https://api.prospeo.io/linkedin-email-finder" Replace "your_api_key" with your actual API key. Update the "url" field in the JSON data with the LinkedIn profile URL for which you want to find the email address. To get access to this API and obtain your API key, you need to sign up on the Prospeo platform and subscribe to their LinkedIn email finder service. Once you have subscribed, you will receive an API key that you can use to authenticate your requests to the API endpoint. Description: Schedule Trigger:** Triggers the workflow based on a defined schedule interval, in this case, based on minutes. Schedule Trigger Node Documentation Google Sheets Read:** Reads data from a Google Sheets document and sheet based on the provided document ID and sheet name. Google Sheets Node Documentation Conditional Check:** Checks multiple conditions based on the input data and performs actions accordingly. Conditional Node Documentation HTTP Request:** Sends an HTTP POST request to a specified URL with headers and body parameters. HTTP Request Node Documentation No Operation, do nothing:** Placeholder node that does not perform any operation. Data Merge:** Merges data based on specified mode and combination settings. Merge Node Documentation Field Editing:** Edits fields by setting specific values for each field based on input data. Set Node Documentation Google Sheets Update:** Updates data in a Google Sheets document and sheet based on specified columns and values. Google Sheets Node Documentation

This n8n workflow template lets teams easily generate a custom AI chat assistant based on the schema of any Notion database. Simply provide the Notion database URL, and the workflow downloads the schema and creates a tailored AI assistant designed to interact with that specific database structure. Set Up Watch this quick set up video 👇 Key Features Instant Assistant Generation**: Enter a Notion database URL, and the workflow produces an AI assistant configured to the database schema. Advanced Querying**: The assistant performs flexible queries, filtering records by multiple fields (e.g., tags, names). It can also search inside Notion pages to pull relevant content from specific blocks. Schema Awareness**: Understands and interacts with various Notion column types like text, dates, and tags for accurate responses. Reference Links**: Each query returns direct links to the exact Notion pages that inform the assistant’s response, promoting transparency and easy access. Self-Validation**: The workflow has logic to check the generated assistant, and if any errors are detected, it reruns the agent to fix them. Ideal for Product Managers**: Easily access and query product data across Notion databases. Support Teams**: Quickly search through knowledge bases for precise information to enhance support accuracy. Operations Teams**: Streamline access to HR, finance, or logistics data for fast, efficient retrieval. Data Teams**: Automate large dataset queries across multiple properties and records. How It Works This AI assistant leverages two HTTP request tools—one for querying the Notion database and another for retrieving data within individual pages. It’s powered by the Anthropic LLM (or can be swapped for GPT-4) and always provides reference links for added transparency.

Accepting payments via credit card online is a crucial component for the majority of businesses. Stripe provides a robust suite of tools for processing payments, yet many people still find it challenging to create a simple payment page and distribute it to their customers. 📋 Blog post 📺 Youtube Video This n8n workflow aims to offer the simplest and most direct method for generating a Stripe payment link. Features Quick Stripe Payment Link Creation:** Simply enter a title and select a price to create a Stripe payment link in seconds. Set Up Steps Connect your Stripe credentials. Fill the config node (currency). This n8n workflow template is crafted to significantly reduce the creation time of a Stripe Payment link. Created by the n8ninja.

What this workflow does: This flow uses an AI node to generate Seed Keywords to focus SEO efforts on based on your ideal customer profile. You can use these keywords to form part of your SEO strategy. Outputs: List of 20 Seed Keywords Setup Fill the Set Ideal Customer Profile (ICP) Connect with your credentials Replace the Connect to your own database with your own database Pre-requisites / Dependencies You know your ideal customer profile (ICP) An AI API account (either OpenAI or Anthropic recommended) Made by Simon @ automake.io

How it works It’s very important to come prepared to Sales calls. This often means a lot of manual research about the person you’re calling with. This workflow delivers a summary of the latest social media activity (LinkedIn + X) for businesses you are about to interact with each day. Scans Your Calendar**: Each morning, it reviews your Google Calendar for any scheduled meetings or calls with companies based on each attendee email address. Fetches Latest Posts**: For each identified company, it fetches recent LinkedIn and X posts and summerizes them using AI to deliver a qucik overview for a busy sales rep. Delivers Insights**: You receive personalized emails via Gmail, each dedicated to a company you’re meeting with that day, containing a reminder of the meeting and a summary of company's recent social media activity. Setup steps The workflow requires you to have the following accounts set up in their respective nodes: Google Calendar GMail Clearbit OpenAI Besides those, you will need an account on the RapidAPI platform and subscribe to the following APIs: Fresh LinkedIn Profile Data Twitter Email example

This n8n workflow, which runs every Monday at 5:00 AM, initiates a comprehensive process to monitor and analyze network security by scrutinizing IP addresses and their associated ports. It begins by fetching a list of watched IP addresses and expected ports through an HTTP request. Each IP address is then processed in a sequential loop. For every IP, the workflow sends a GET request to Shodan, a renowned search engine for internet-connected devices, to gather detailed information about the IP. It then extracts the data field from Shodan's response, converting it into an array. This array contains information on all ports Shodan has data for regarding the IP. A filter node compares the ports returned from Shodan with the expected list obtained initially. If a port doesn't match the expected list, it is retained for further processing; otherwise, it's filtered out. For each such unexpected port, the workflow assembles data including the IP, hostnames from Shodan, the unexpected port number, service description, and detailed data from Shodan like HTTP status code, date, time, and headers. This collected data is then formatted into an HTML table, which is subsequently converted into Markdown format. Finally, the workflow generates an alert in TheHive, a popular security incident response platform. This alert contains details like the title indicating unexpected ports for the specific IP, a description comprising the Markdown table with Shodan data, medium severity, current date and time, tags, Traffic Light Protocol (TLP) set to Amber, a new status, type as 'Unexpected open port', the source as n8n, a unique source reference combining the IP with the current Unix time, and enabling follow and JSON parameters options. This comprehensive workflow thus aids in the proactive monitoring and management of network security.

Use Case Transform and optimize images for web use: You need to host local images online You want to reduce image file sizes automatically You need image URLs for web content You want to generate and optimize AI-created images What this Workflow Does The workflow processes images through two services: Uploads images to ImgBB for hosting and URL generation (free but need API key) Optimizes images using ReSmush.it to reduce file size (free) Optional: Creates images using OpenAI's image generation Returns optimized image URLs ready for use Setup Create an ImgBB account and get your API key Add your ImgBB API key to the HTTP Request node (key parameter) Optional: Configure OpenAI credentials for image generation Connect your image input source How to Adjust it to Your Needs Skip OpenAI nodes if using your own image files Adjust image optimization parameters Customize image hosting settings Modify output format for your needs Made by Simon @ automake.io

This n8n workflow demonstrates how to build a simple uptime monitoring service using scheduled triggers. Useful for webmasters with a handful of sites who want a cost-effective solution without the need for all the bells and whistles. How it works Scheduled trigger reads a list of website urls in a Google Sheet every 5 minutes Each website url is checked using the HTTP node which determines if the website is either in the UP or DOWN state. An email and Slack message are sent for websites which are in the DOWN state. The Google Sheet is updated with the website's state and a log created. Logs can be used to determine total % of UP and DOWN time over a period. Requirements Google Sheet for storing websites to monitor and their states Gmail for email alerts Slack for channel alerts Customising the workflow Don't use Google Sheets? This can easily be exchanged with Excel or Airtable.

You still can use the app in a workflow even if we don’t have a node for that or the existing operation for that. With the HTTP Request node, it is possible to call any API point and use the incoming data in your workflow Main use cases: Connect with apps and services that n8n doesn’t have integration with Web scraping How it works This workflow can be divided into three branches, each serving a distinct purpose: 1.Splitting into Items (HTTP Request - Get Mock Albums): The workflow initiates with a manual trigger (On clicking 'execute'). It performs an HTTP request to retrieve mock albums data from "https://jsonplaceholder.typicode.com/albums." The obtained data is split into items using the Item Lists node, facilitating easier management. 2.Data Scraping (HTTP Request - Get Wikipedia Page and HTML Extract): Another branch of the workflow involves fetching a random Wikipedia page using an HTTP request to "https://en.wikipedia.org/wiki/Special:Random." The HTML Extract node extracts the article title from the fetched Wikipedia page. 3.Handling Pagination (The final branch deals with handling pagination for a GitHub API request): It sends an HTTP request to "https://api.github.com/users/that-one-tom/starred," with parameters like the page number and items per page dynamically set by the Set node. The workflow uses conditions (If - Are we finished?) to check if there are more pages to retrieve and increments the page number accordingly (Set - Increment Page). This process repeats until all pages are fetched, allowing for comprehensive data retrieval.

Overview This N8N workflow facilitates advanced URL parsing and shortening, incorporating metadata extraction, OpenGraph tag handling, and integration with Switchy API for link management. It employs various nodes for URL processing, metadata extraction, and creation or updating of shortened links with enriched metadata. Features URL Metadata Extraction:** Parses URLs to extract metadata such as titles, descriptions, images, and favicons. OpenGraph API Integration:** Utilizes OpenGraph API for detailed metadata retrieval. Switchy API Integration:** Manages shortened links via the Switchy API. GitHub API Integration:** Uses GitHub for hosting images related to the URLs. Screenshot Capabilities:** Captures screenshots of web pages as part of metadata. API Authorization and Configuration:** Manages API keys and configurations for external service integration. Workflow Structure Split In Batches: Processes URLs in batches. API Auth: Configures API authorization. URL Processing Nodes: Extract metadata using various nodes like Get Headers, OpenGraph API, and Meta tags Scraper. Conditional Nodes: Include IF OpenGraph Invalid and If - Enable ScreenShots for logic handling. Data Aggregation: Uses nodes like Method 1 - META for final metadata aggregation. Switchy API: Handles link creation and updating. GitHub Integration: Hosts screenshots and images on a personal GitHub repository. Final Output: Provides the shortened URL after processing. API Stack | API | Description | |---------------------------------|-------------------------------------------------| | switchy | For creating and updating shortened links. | | opengraph | To retrieve URL metadata using OpenGraph tags. | | dub.sh | Used for scraping meta tags from web pages. | | microlink | Captures screenshots of web pages. | | pxl.to | Alternative service for capturing screenshots. | | favicone | Retrieves favicons for given URLs. | | github | Hosts images and screenshots on GitHub repo. | | statically | Used for CDN services and image hosting. | | Other APIs | Additional APIs used for various purposes. | GitHub Repository Setup To use this workflow, ensure your GitHub API is linked for hosting images. Set up a repository where the workflow can upload screenshots and other related images. This repository will be referenced in the workflow nodes where images are handled. Configuration Before running the workflow, set up the necessary API keys and configurations in the API Auth node. Adjust batch size and other parameters as needed. Error Handling The workflow includes nodes like Stop and Error for robust error handling, post an issue and mention the creator using N8N community. Contributions This workflow is open for community contributions. Enhancements and improvements are welcome.

What this workflow does This (set of) workflow(s) shows how to start multiple sub-workflows, asynchronously, in parallel, and then wait for all of them to complete. Normally sub-workflows would need to be run synchronously, in series, or, if they are executed asynchronously (to run concurrently, in parallel), there is no easy way to merge/wait for an arbitrary number of them to complete. This is a "design pattern" template to show one approach for running multiple, data-driven instances of a sub-workflow "asynchronously," in parallel (instead of running them one at a time in series), but still prevent the later steps in the workflow from continuing until all of the sub-workflows have reported back that they are finished, via callback URL. There are other techniques involving messaging services, database tables, or other external "flow manager" helpers, but this technique accomplishes the goal fully within n8n. Setup To implement this pattern, examine the nodes in the template and modify the incoming data leading to: A split-out loop to acynchronously execute a sub-workflow multiple times, in parallel. For instance, each sub-workflow might process one of a list of incoming documents. The resumeUrl for the main/parent workflow is provided to all of the sub-workflow executions, along with a unique identifier that can be counted later (e.g. a document file-name). A "wait-for-all" loop that checks whether all sub-workflows have reported back (if node) and builds a unique list of identifiers from the callbacks received from each execution of the sub-workflow. The sub-workflow should be designed to respond immediately (async) and later send a callback request when it has finished processing. The callback request should include the unique identifier value received when the sub-workflow it was started. This is meant to be a possible answer to questions like this one about running things in parallel, maybe this one about waiting for things to finish, this one about managing sub-batches of things by waiting for each batch, or this one about running things in parallel. The topic of how to do this comes up A LOT, and this is one of the only techniques that (so far) seems to work.

This template aims to perform Q&A on data retrieved from another n8n workflow. Since that workflow can be used to retrieve any data from any service, this template can be used to ask questions about any data. It uses a manual trigger, various AI nodes, and an OpenAI Chat Model to extract and provide relevant information based on a specific query. Note that to use this template, you need to be on n8n version 1.19.4 or later.

Telegram Bot Starter template workflow provides a foundational setup for creating powerful Telegram bots with n8n. It handles incoming messages, photos, files, and voice notes, making it an excellent starting point for developers looking to create bots for customer engagement, support, or interactive services. Key Features: Dynamic Message Handling: Respond to text messages, photos, files, and more. Modular Design: Easily integrate additional workflows such as user registration, payment modules, or custom commands. Error Handling: Ensure the bot gracefully manages errors and user inputs. Who Can Use This Workflow? Developers looking for a quick way to build and customize Telegram bots. Businesses and service providers who need customer interaction automation. Setup Instructions: Replace Telegram credentials with your own API credentials. Customize responses for different message types (text, photo, file). If integrating with external services (like Google Sheets), update the necessary credentials and links. Extensibility: This workflow is the base for building any Telegram bot. Additional modules, such as a user registration module, payment integration, and user profile management, are available for easy connection to expand the bot’s functionality. ✍🏻Use the Telegram user registration workflow → 💵Use the Telegram Payment, Invoicing and Refund Workflow for Stars → UPDATES: 🔥 Get the most up-to-date and expanded version → Aug 24: Changed processing of system events: “new user” and ‘user who blocked bot’ events Sep 24: Improved message handler: Updated logic to handle various types of messages using Switch (text, photo, file, voice, and callback). Payment processing: Added new nodes for sending invoices and handling payments via Telegram Please reach out to Victor if you need further assistance with your n8n workflows and automations!

Introduction: Streamline your fundamental stock analysis process with AI-powered automation. By harnessing the power of SEC 10K reports - comprehensive documents required by the SEC containing vital company information - this template automates the analysis workflow. From planning by a Senior Research Analyst to execution by five Research Analysts and final review by a Senior Editor, this template takes an AI persona approach to compose the report that includes an overview of the business, strategy, SWOT (Strengths, Weaknesses, Opportunities, and Threads) analysis, near term catalysts, and top risks. Additionally, this template allows you to control the length and detail of the report generated. How it works There are three personas in the workflow: Senior Research Analyst** is the first part of the workflow. They are responsible for planning the work for the rest of the team. Squad of Research Analysts** is the second part of the workflow. They execute the plan created. Senior Editor** is the third part of the workflow. They polish the draft report and send it to publish This template uses a custom tool that is able to answer the SEC 10K questions from the Research team. Setup steps Setup the Stock Q&A Workflow for the company you want to analyze using this template Customize the setup node by specifying the company to analyze Customize the publish step by specifying the file name in the Google docs node Credit Inspired by Guilio's template

Template Description This n8n workflow template allows you to create a masked email address using the Fastmail API, triggered by a webhook. This is especially useful for generating disposable email addresses for privacy-conscious users or for testing purposes. Workflow Details: Webhook Trigger: The workflow is initiated by sending a POST request to a specific webhook. You can include state and description in your request body to customize the masked email's state and description. Session Retrieval: The workflow makes an HTTP request to the Fastmail API to retrieve session information. It uses this data to authenticate further requests. Create Masked Email: Using the retrieved session data, the workflow sends a POST request to Fastmail's JMAP API to create a masked email. It uses the provided state and description from the webhook payload. Prepare Output: Once the masked email is successfully created, the workflow extracts the email address and attaches the description for further processing. Respond to Webhook: Finally, the workflow responds to the original POST request with the newly created masked email and its description. Requirements: Fastmail API Access**: You will need valid API credentials for Fastmail configured with HTTP Header Authentication. Authorization Setup**: Optionally set up authorization if your webhook is exposed to the internet to prevent misuse. Custom Webhook Request**: Use a tool like curl or create a shortcut on macOS/iOS to send the POST request to the webhook with the necessary JSON payload, like so: curl -X POST -H 'Content-Type: application/json' https://your-n8n-instance/webhook/87f9abd1-2c9b-4d1f-8c7f-2261f4698c3c -d '{"state": "pending", "description": "my mega fancy masked email"}' This template simplifies the process of integrating masked email functionality into your projects or workflows and can be extended for various use cases. Feel free to use the companion shortcut I've also created. Please update the authorization header in the shortcut if needed. https://www.icloud.com/shortcuts/ac249b50eab34c04acd9fb522f9f7068

Source code, I maintain this worflow here. Usage Guide This workflow backs up all workflows as JSON files named in the [workflow_name].json format. Steps Create GitHub Repository Skip this step if using an existing repository. Add GitHub Credentials In Credentials, add the GitHub credential for the repository owner. Download and Import Workflow Import this workflow into n8n. Set Global Values In the Globals node, set the following: repo.owner: GitHub username of the repository owner. repo.name: Name of the repository for backups. repo.path: Path to the folder within the repository where workflows will be saved. Configure GitHub Nodes Edit each GitHub node in the workflow to use the added credentials. Workflow Logic Each workflow run handles files based on their status: New Workflow If a workflow is new, create a new file in the repository. Unchanged Workflow If the workflow is unchanged, skip to the next item. Changed Workflow If a workflow has changes, update the corresponding file in the repository. Current Limitations / Needs work Name Change of Workflows If a workflow is renamed or deleted in n8n, the old file remains in the repository. Deleted Workflows Deleted workflows in n8n are not removed from the repository.

This workflow demonstrates how to export SQL to XML and present the data nicely formatted using an XSL Template. The upper part of the workflow starts with a webhook. Then it gets several random records from the SQL table and converts them into an XML string. Then a final XML file is created that contains a link to the XML Stylesheet file. The lower part of the workflow contains a helper Webhook that reads an XSL Template from the GitHub gist and serves it back via the Respond to Webhook node. This is required to comply with the CORS rules of modern browsers. These rules dictate that both XML data and a stylesheet file should come from the same domain.

This workflow demonstrates how easy it is to export SQL query to CSV automatically! Before running the workflow please make sure you have access to a local or remote MSSQL server with a sample AdventureWorks database. The detailed process is explained in the tutorial https://blog.n8n.io/sql-export-to-csv/

What it does The workflow is a simple yet efficient way to automate the process of indexing your website on Google using the Google Indexing API. How it works It works by extracting information from your sitemap, converting it into a JSON file, and looping through each URL to submit it for indexing. Here's a brief rundown of the workflow: The workflow can be triggered manually via the "Execute Workflow" button or scheduled to run at a specific time using the "Schedule Trigger" node. The sitemap of your website is fetched using the "sitemap_set" node with a HTTP Request to the sitemap URL. This XML sitemap is then converted into a JSON file using the "sitemap_convert" node. The "sitemap_parse" node splits the JSON file into individual URLs. The "url_set" node then prepares each URL to be sent to the Google Indexing API. A loop is created using the "loop" node to process each URL individually and make a POST request to Google Indexing API indicating that the URL has been updated. If the POST request is successful and the URL has been updated, the workflow waits for 2 seconds before moving to the next URL. In case the daily limit for the Google Indexing API is reached (200/day by default), an error message is triggered using the "Stop and Error" node. Before you use the workflow Activate the indexing API Create an account with Google Cloud Platform > Console and then create a new project Search for the Indexing API in the Library Activate the API Create a Service Account and get credentials Open the Service accounts page. If prompted, select a project. Click add Create Service Account, enter a name and description for the service account. You can use the default service account ID, or choose a different, unique one. When done click Create. On the Grant users access to this service account screen, scroll down to the Create key section. Click add Create key. In the side panel that appears, select the JSON format Click Create. Your new public/private key pair is generated and downloaded to your machine. Open the file and copy the private key. Add the credentials in the url_index node Add the user as owner of the site Beware, for each site you need to add the user as a owner like this: Set your sitemap Open the sitemap_set node and add the url to your sitemap. Now you should be able to ensure that Google is always up-to-date with the latest content on your website, improving your website's visibility and SEO rankings, have fun!

This workflow imports multiple CSV files and appends or updates them to a Google Sheets document. Here's a step-by-step breakdown: When clicked "Execute Workflow", the process starts. The "Read Binary Files" node reads all the '.csv' files from the specified directory. The files are then split into batches (one file in a batch) by the "Split In Batches" node. For each file, the "Read CSV" node reads the data from the CSV file. The "Assign source file name" node assigns the source file name to the data. The data is then processed by the "Remove duplicates" node. This removes any duplicate entries based on the 'user_name' field. The "Keep only subscribers" node filters the data to keep only those entries where the 'subscribed' field is set to 'TRUE'. The data is then sorted by the 'date_subscribed' field using the "Sort by date" node. Finally, the processed data is appended or updated to a specified Google Sheets document using the "Upload to spreadsheet" node. It checks for the 'user_name' field, if the data corresponding to that 'user_name' already exists, it updates the data, otherwise appends the new data.

Enhance Query Resolution with the Knowledge Base Tool! Our KB Tool - Confluence KB is crafted to seamlessly integrate into the IT Ops AI SlackBot Workflow, enhancing the IT support process by enabling sophisticated search and response capabilities via Slack. Workflow Functionality: Receive Queries**: Directly accepts user queries from the main workflow, initiating a dynamic search process. AI-Powered Query Transformation**: Utilizes OpenAI's models or local ai to refine user queries into searchable keywords that are most likely to retrieve relevant information from the Knowledge Base. Confluence Integration**: Executes searches within Confluence using the refined keywords to find the most applicable articles and information. Deliver Accurate Responses**: Gathers essential details from the Confluence results, including article titles, links, and summaries, preparing them to be sent back to the parent workflow for final user response. To view a demo video of this workflow in action, click here. Quick Setup Guide: Ensure correct configurations are set for OpenAI and Confluence API integrations. Customize query transformation logic as per your specific Knowledge Base structure to improve search accuracy. Need Help? Dive into our Documentation or get support from the Community Forum! Deploy this tool to provide precise and informative responses, significantly boosting the efficiency and reliability of your IT support workflow.

This n8n workflow is a fun way to query and search over your credentials on your n8n instance. Good to know Your credentials should remain safe as this workflow does not decrypt or use any decrypted data. Example Usage "Which workflows are using Slack and Google Calendar?" "Which workflows have AI in their name but are not using openAI?" How it works Using the n8n API, it fetches all workflow data on the instance. Workflow data contains references to credentials used so this will be extracted. With some necessary reformatting, the workflows and their credentials metadata are stored to a SQLite database. Next, an AI agent is used with a custom SQL tool that reads the SQLite database created in the previous step. The AI agent is instructed to perform SQL queries against our workflow credential table when asked about credentials by the user. Requirements You'll need an n8n API key. Please note that only workflows will be scoped to your API key. Customising the workflow Add extra table fields to the SQLite database to answer even more complex queries such as: workflow status to differentiate between active and inactive workflows.

This workflow performs several data integration and synchronization tasks between Google Sheets and a MySQL database. Here is a step-by-step description of what this workflow does: Manual Trigger: The workflow starts when the user clicks "Execute Workflow." Schedule Trigger: This node schedules the workflow to run at specific intervals on weekdays (Monday to Friday) between 6 AM and 10 PM. It ensures regular data synchronization. Google Sheet Data: This node connects to a specific Google Sheets document and retrieves data from the "Form Responses 1" sheet, filtering by the "DB Status" column. SQL Get inquiries from Google: This node retrieves data from a MySQL database table named "ConcertInquiries" where the "source_name" is "GoogleForm." Rename GSheet variables: This node renames the columns retrieved from Google Sheets and transforms the data into a format suitable for MySQL, assigning a value for "source_name" as "GoogleForm." Compare Datasets: This node compares the data retrieved from Google Sheets and the MySQL database based on timestamp and source_name fields. It identifies changes and updates. No reply too long?: This node checks if there has been no reply within the last four hours, using the "timestamp" field from the Google Sheets data. DB Status assigned?: This node checks if the "DB Status" field is not empty in the compared dataset. Update GSheet status: If conditions are met in the previous nodes, this node updates the "DB Status" field in Google Sheets with the corresponding value from the MySQL dataset. DB Status in sync?: This node checks if the "source_name" field in Google Sheets is not empty. Sync MySQL data: If conditions are met in the previous nodes, this node updates the "source_name" field in the MySQL database to "GoogleFormSync." Send Notifications: If conditions are met in the "No reply too long?" node, this node sends notifications or performs actions as needed. Sticky Notes: These nodes provide additional information and documentation links for users.

Task: Create a simple API endpoint using the Webhook and Respond to Webhook nodes Why: You can prototype or replace a backend process with a single workflow Main use cases: Replace backend logic with a workflow

This automated workflow takes a Typeform form, and once it is filled out, it is automatically uploaded as a Lead in Pipedrive. There is an option for custom fields (this workflow works with company size), and leaves notes in the note section based on questions answered. Prerequisites Typeform account and Typeform credentials and a form for people to fill out Pipedrive account and Pipedrive credentials Nodes Typeform node gets the data after the survey is completed Set node extracts data from the Typeform node and keeps only relevant data Function node maps the company size Pipedrive node populates a pipeline with a deal and adds custom fields

This workflow illustrates how to convert data from JSON to binary format and import JSON data or files into Google Sheets or local spreadsheets.

Who we are We are Aprende n8n, the first n8n Spanish course for all n8n lovers. If you want to learn more, you can find out more at Aprende n8n. Task goal This task allows extracting data from any email body with a NoCode snippet. An small explanation You receive an email when a user submits a form from your website. All those emails usually have the same structure as the next one: Name: Miquel Email: [email protected] Subject: Welcome aboard Message: Hi Miquel! Thank you for your signup! This task allows to parse any email body and assign all values to the defined labels, getting an output like this: { "Name": "Miquel", "Email": "[email protected]", "Subject": "Welcome aboard", "Message" "Hi Miquel! Thank you for your signup!" } After importing it When you import the import, you get the next task in your n8n: We recommend importing this workflow into your current task and adapting it. You define a couple of variables in the "Set values" SET: body: the email body you want to parse. You can add this as an expression from previous variables. labels: the keywords you want to detect and parse. Labels are case insensitive. We define the next values: Body Name: Miquel Email: [email protected] Subject: Welcome aboard Message: Hi Miquel! Thank you for your signup! Labels Name,Email,Subject,Message A screenshot of the Set output is the next one If we check the "Function item" Node, we get the next content after executing the task: Capabilities The task has the next features: You can detect as many labels as you want. Label detection is case insensitive. You can use the snippet as an independent workflow to call it generically, adding the Function item to the workflow and passing body and labels as paremeters. Limitations This task has limitations: The parser only accepts the multiline values at the end of the email. Help and comments If you have any doubt about this snippet, please, contact us at [email protected]. You can contact us at Aprende n8n or in the Spanish n8n community

This workflow is aimed to create new posts in wordpress automatically from an airtable dashboard. When creating content in bulk, we can save time by automating how we can post and publish this content. Usage Get the content from Airtable. Since we have this as a markdown, we will have to convert it to a html format to make it easier to publish and manage on WordPress Upload the blog post with the content, title and all other relevant information needed for an optimized blog Once the post is posted, we need to upload the image and set it as a features image for the blogs Happy productivity

This n8n workflow template lets you easily generate comprehensive FAQ (Frequently Asked Questions) content for multiple services (or any items or pages you need to add the FAQs to). Simply provide the Google Sheets document containing the items to scrape, and the workflow automatically creates detailed, AI-enhanced FAQ documents. How it works The workflow reads data from a Google Sheets document containing information about different services and categories (again, in your case - whatever objects you need). For each service and category, it generates a set of standard questions and answers covering setup, permissions, integrations, use cases, and pricing benefits. An AI model (OpenAI's GPT) is used to enhance or complete some of the answers, making the content more comprehensive and natural-sounding. The workflow formats the Q&A pairs, combining AI-generated content with predefined answers where applicable. It creates a text file (JSON) for each service or category, containing the formatted Q&A pairs. The generated files are saved to specific folders in Google Drive, organized by the type of integration (native, credential-only, non-native) or category. After processing each service or category, it updates the status in the original Google Sheets document to mark it as completed. Ideal for: Marketing teams: Rapidly create comprehensive FAQ documents for multiple products or services. Customer support: Generate consistent and detailed answers for common customer queries. Product managers: Easily maintain up-to-date documentation as products evolve. Content creators: Streamline the process of creating informative content about various offerings. Accounts required Google account (for Google Sheets and Google Drive) OpenAI API account (for AI-enhanced content generation) n8n.io account (for workflow execution) Set up instructions Set up the required credentials for Google Sheets, Google Drive, and OpenAI when you first open the workflow. Prepare your Google Sheets document with the service/category information. Here's an example of Google Sheet. Fill the "Define Sheets" node with your sheets Adjust the folder IDs in the "Prepare Job" node to match your Google Drive structure. Configure the OpenAI model settings in the "OpenAI Chat Model" node if needed. Test the workflow with a small subset of data before running it on your entire dataset. Adjust the questions asked in the "Create your Q&A templates" section After testing, activate your workflow for automated FAQ generation. 🙏 Big, big kudos to Jim Le for his ideas, input and support when building this workflow. Your approach to AI workflows is always super helpful!

This workflow will backup your workflows to Github. It uses the public api to export all of the workflow data using the n8n node. It then loops over the data checks in Github to see if a file exists that uses the workflow name. Once checked it will then update the file on Github if it exists, Create a new file if it doesn't exist and if it's the same it will ignore the file. Config Options repo_owner - Github owner repo_name - Github repository name repo_path - Path within the Github repository >This workflow has been updated to use the n8n node and the code node so requires at least version 0.198.0 of n8n

This workflow creates a Slack thread when a new ticket is created in Zendesk. Subsequent comments on the ticket in Zendesk are added as replies to the thread in Slack. Prerequisites Zendesk account and Zendesk credentials. Slack account and Slack credentials. Slack channel to create threads in. How it works The workflow listens for new tickets in Zendesk. When a new ticket is created, the workflow creates a new thread/message in Slack. The Slack thread ID is then saved in one of the ticket's fields called "Slack thread ID". The next time a comment is added to the ticket, the workflow retrieves the Slack thread ID from the ticket's field and adds the comment to the thread/message in Slack as a reply. Setup This workflow requires that you set up a webhook in Zendesk. To do so, follow the steps below: In the workflow, open the On new Zendesk ticket node and copy the webhook URL. In Zendesk, navigate to Admin Center > Apps and integrations > Webhooks > Actions > Create Webhook. Add all the required details which can be retrieved from the On new Zendesk ticket node. The webhook URL gets added to the “Endpoint URL” field, and the “Request method” should match what is shown in n8n. Save the webhook. In Zendesk, navigate to Admin Center > Objects and rules > Business rules > Triggers > Add trigger. Give trigger a name such as “New tickets”. Under “Conditions” in “Meet ALL of the following conditions”, add “Status is New”. Under “Actions”, select “Notify active webhook” and select the webhook you created previously. In the JSON body, add the following: { "id": "{{ticket.id}}", "comment": "{{ticket.latest_comment_html}}" } Save the Zendesk trigger. You will also need to set up a field in Zendesk to store the Slack thread ID. To do so, follow the steps below: In Zendesk, navigate to Admin Center > Objects and rules > Tickets > Fields > Add field. Use the text field option and give the field a name such as “Slack thread ID”. Save the field. In n8n, open the Update ticket node and select the field you created in Zendesk.

Flow Start: The flow starts upon receiving an HTTP GET call. Webhook: Receives the HTTP GET call and triggers the flow. Database: Connects to the database (Customer Datastore) to retrieve all necessary information (getAllPeople). Data Processing: Variable Insertion: The retrieved data is inserted into a variable. Variable Aggregation: The variables are aggregated and prepared for use in FlutterFlow. Webhook Response: Sends the response back through the Webhook with the processed data ready for use in FlutterFlow.

This workflow is triggered by a parent workflow initiated via a Slack shortcut. Upon activation, it collects input from a modal window in Slack and initiates a vulnerability scan using the Qualys API. Key Features Trigger:** Launched by a parent workflow through a Slack shortcut with modal input. API Integration:** Utilizes the Qualys API for vulnerability scanning. Data Conversion:** Converts XML scan results to JSON for further processing. Loop Mechanism:** Continuously checks the scan status until completion. Slack Notifications:** Posts scan summary and detailed results to a specified Slack channel. Workflow Nodes Start VM Scan in Qualys: Initiates the scan with specified parameters. Convert XML to JSON: Converts the scan results from XML format to JSON. Fetch Scan Results: Retrieves scan results from Qualys. Check if Scan Finished: Verifies whether the scan is complete. Loop Mechanism: Handles the repetitive checking of the scan status. Slack Notifications: Posts updates and results to Slack. Relevant Links Qualys API Documentation Qualys Platform Documentation Parent workflow link Link to Report Generator Subworkflow

This workflow shows a no code approach to creating Salesforce accounts and contacts based on data coming from an Excel file. For Excel 365 (the online version of Microsoft Excel) check out this workflow instead. To run the workflow: Make sure your Salesforce account is authenticated with n8n. Have a Microsoft Excel workbook with contacts and their account names ready. The workflow uses this example file, but you probably want to use your own data instead. Hit the Execute Workflow button at the bottom of the n8n canvas. Here is how it works: The workflow first searches for existing Salesforce accounts by name. It then branches out depending on whether the account already exists in Salesforce or not. If an account does not exist yet, it will be created. The data is then normalised before both branches converge again. Finally the contacts are created or updated as needed in Salesforce.

This n8n template is one of a 3-part series exploring use-cases for clustering vector embeddings: Survey Insights Customer Insights Community Insights This template demonstrates the Community Insights scenario where HN commments can be quickly grouped by similarity and an AI agent can generate insights on those groupings. With this workflow, Researchers or HN users can quickly breakdown community consensus on a particular topic and identify frequently mentioned positives and negatives. Sample Output: https://docs.google.com/spreadsheets/d/e/2PACX-1vQXaQU9XxsxnUIIeqmmf1PuYRuYtwviVXTv6Mz9Vo6_a4ty-XaJHSeZsptjWXS3wGGDG8Z4u16rvE7l/pubhtml How it works HN comments are imported via the Hacknews API node. Comments are then inserted into a Qdrant collection carefully tagged with the Hackernews API metadata. Comments are then fetched and are put through a clustering algorithm using the Python Code node. The Qdrant points are returned in clustered groups. Each group is looped to fetch the payloads of the points and feed them to the AI agent to summarise and generate insights for. The resulting insights and raw responses are then saved to the Google Spreadsheet for further analysis by the researcher or the HN user. Requirements Works best with lots of comments! Qdrant Vectorstore for storing embeddings. OpenAI account for embeddings and LLM. Customising the Template Adjust clustering parameters which make sense for your data. Adjust sentimentality setting if comments are overwhelmingly negative at times.

This workflow allows you to send multi-step email campaigns using n8n, Gmail and Google Sheets. You define a sequence of emails, and a list of email addresses to send them to. The first email is sent to everyone, but the later emails in the sequence are only sent if no-one has replied to the thread yet. This means you only need to worry about replying to people who respond to your email, not chasing people who don’t. Requirements A list of emails in a Google sheet. You can define extra info that will be available to your email templates (e.g. name, company, etc.) A sequence of emails to send, plus how long to wait to send each one, e.g. On day 0:** “Hi, {name} — nice to meet you at the conference. Was wondering whether {company} would be interested in a quick call about X?” On day 3:** “Hi, {name}, just wanted to check in on this. Let me know if there’s any interest!” On day 7:** “{name}, just wanted to give this one last try” A Gmail account (although you could also swap out that part for any other email service) How it works When sending the emails, n8n inserts a hidden attribute in each one that tags it as being part of the email campaign. It then regularly looks through the email threads with that tag and checks whether: No-one has replied yet It’s time to send the next message The workflow doesn’t send emails on weekends. Notes This workflow is not intended for spam! Please use responsibly You can use this workflow for multiple different campaigns by making copies of the workflow and changing the sequence / Google Sheet that it uses

This workflow is a building block designed to be called from other workflows via an Execute workflow node. When called from another workflow, and given the JSON input of a "pulse" field with the ID to pull from monday, this workflow will return: The items name and ID All column data, indexable by the column name All column data, indexable by the column's ID string All board relation columns, with their data and column values All subitems, with their data and column values For example: ++Prerequisites++ A monday.com account and credential A workflow that needs to get detailed data from a monday.com row The pulse id of the monday.com row to retreive data from. ++Setup++ Import the workflow Configure all monday nodes with your credentials and save the workflow Copy the workflow ID from it's URL In a different workflow, add an Edit Fields node, to output the field "pulse", with the monday item you want to retrieve. Feed the Edit Fields node with your pulse into an Execute workflow node, and paste the workflow ID from above into it This "pulse" field will tell the workflow what pulse to retreive. This can be populated by an expression in your workflow There is an example of the Edit Fields and Execute Workflow nodes in the template

Who is this for? This workflow is for all sales reps and lead generation manager who need to prepare their prospecting activities, and find relevant information to personalize their outreach. Use Case This workflow allows you to do account research with the web using AI. It has the potential to replace manual work done by sales rep when preparing their prospecting activities by searching complex information available online. What this workflow does The advanced AI module has 2 capabilities: Research Google using SerpAPI Visit and get website content using a sub-workflow From an unstructured input like a domain or a company name. It will return the following properties: domain company Linkedin Url cheapest plan has free trial has entreprise plan has API market (B2B or B2C) The strength of n8n here is that you can adapt this workflow to research whatever information you need. You just have to precise it in the prompt and to precise the output format in the "Strutured Output Parser" module. Detailed instructions + video guide can be found by following this link.

Use Case Research search engine rankings for SEO analysis: You need to track keyword rankings for your website You want to analyze competitor positions in search results You need data for SEO competition analysis You want to monitor SERP changes over time What this Workflow Does The workflow uses ScrapingRobot API to fetch Google search results: Retrieves SERP data for your target keywords Captures URL rankings and page titles Processes up to 5000 searches with free account Organizes results for SEO analysis Setup Create a ScrapingRobot account and get your API key Add your ScrapingRobot API key to the HTTP Request node's GET SERP token parameter Either connect your keyword database (column name "Keyword") or use the "Set Keywords" node Configure your preferred output database connection How to Adjust it to Your Needs Modify keyword source to pull from different databases Adjust the number of SERP results to capture Customize output format for your reporting needs Made by Simon @ automake.io

This workflow uses AI to analyze the content of every new message in Gmail and then assigns specific labels, according to the context of the email. Default configuration of the workflow includes 3 labels: „Partnership” - email about sponsored content or cooperation, „Inquiry” - email about products, services, „Notification” - email that doesn't require response. You can add or edit labels and descriptions according to your use case. 🎬 See this workflow in action in my YouTube video about automating Gmail. How it works? Gmail trigger performs polling every minute for new messages (you can change the trigger interval according to your needs). The email content is then downloaded and forwarded to an AI chain. 💡 The prompt in the AI chain node includes instructions for applying labels according to the email content - change label names and instructions to fit your use case. Next, the workflow retrieves all labels from the Gmail account and compares them with the label names returned from the AI chain. Label IDs are aggregated and applied to processed email messages. ⚠️ Label names in the Gmail account and workflow (prompt, JSON schema) must be the same. Set up steps Set credentials for Gmail and OpenAI. Add labels to your Gmail account (e.g. „Partnership”, „Inquiry” and „Notification”). Change prompt in AI chain node (update list of label names and instructions). Change list of available labels in JSON schema in parser node. Optionally: change polling interval in Gmail trigger (by default interval is 1 minute). If you like this workflow, please subscribe to my YouTube channel and/or my newsletter.

A n8n workflow designed to shorten URLs using Dub.co API. How it works: It shortens a url using Dub.co API, with the ability to use custom domains and projects. It updates the current shortened url if the slug has been already used. Estimated Time: Around 15 minutes. Requirements: A Dub.co account. Configuration: Configure the "API Auth" node to add your Dub.co API key, project slug, and the long URL. There some extras that you're able to configure too. You will be able to do that by clicking the "API Auth" node and filling the fields. Detailed Instructions: Sticky notes within the workflow provide extensive setup information and guidance. Keywords: n8n workflow, dub.co, dub.sh, url shortener, short urls, short links

Who this is for This template is for everyone that wants to download their n8n Cloud invoices automatically as a PDF instead of downloading them manually. How it works This workflow checks your Gmail inbox for new n8n invoice emails from n8n's payment provider Paddle. Once it finds something, it converts the URL into a PDF using pdflayer and saves it in Google Drive. Setup Setup your Gmail and Google Drive credentials Create a free account at https://pdflayer.com/ Insert your pdflayer API key into the Setup node Insert the URL to the wanted drive folder into the setup node (make sure to remove everything after the ?) How to adjust it to your need Instead of saving the PDF in Google drive, you could also save it in your local system, any other storage provider or send the PDF automatically to the right person in your company.

Workflow: Snapshot Contabo How it Works This workflow automates daily backups (snapshots) of VPS instances hosted on Contabo. Each day at midnight, it checks for existing snapshots and ensures that only the latest backups are retained by removing older ones. It provides a seamless, hands-off backup process to keep your data secure. Setup Steps Setting up this workflow is quick, typically taking about 10-15 minutes. The essential part of the setup is providing the necessary credentials, which you can easily retrieve from your Contabo control panel. Import the Workflow: Download and upload the workflow JSON into n8n. Configure Credentials: Add CLIENT_ID, CLIENT_SECRET, API_USER, and API_PASSWORD in the credential node. Activate the Workflow: Enable it to run automatically at midnight every day. Flow Overview Schedule Trigger (00:00 daily):** Automatically initiates the workflow. Formatted Date:** Prepares a timestamp for naming the snapshot. List Snapshots:** Verifies if an existing snapshot is available for each VPS. Conditional Logic:** No Snapshot? Proceeds to create a new one. Snapshot Found? Deletes the old snapshot before creating a new one. Key Points Snapshot Retention:** Old snapshots are deleted to ensure only the latest backups are stored. Unique Identifiers:** UUIDs are used to track and guarantee unique operations.

This n8n workflow demonstrates how to create an agent using LangChain and SQLite. The agent can understand natural language queries and interact with a SQLite database to provide accurate answers. 💪 🚀 Setup Run the top part of the workflow once. It downloads the example SQLite database, extracts from a ZIP file and saves locally (chinook.db). 🗣️ Chatting with Your Data Send a message in a chat window. Locally saved SQLite database loads automatically. User's chat input is combined with the binary data. The LangChain Agend node gets both data and begins to work. The AI Agent will process the user's message, perform necessary SQL queries, and generate a response based on the database information. 🗄️ 🌟 Example Queries Try these sample queries to see the AI Agent in action: "Please describe the database" - Get a high-level overview of the database structure, only one or two queries are needed. "What are the revenues by genre?" - Retrieve revenue information grouped by genre, LangChain agent iterates several time before producing the answer. The AI Agent will store the final answer in its memory, allowing for context-aware conversations. 💬 Read the full article: 👉 https://blog.n8n.io/ai-agents/

What this template does This template uses GROQ LLAVA V1.5 7B API that offers fast inference for multimodal models with vision capabilities for understanding and interpreting visual data from images. . The users send a image and get a description of the image from the model. Setup Open the Telegram app and search for the BotFather user (@BotFather) Start a chat with the BotFather Type /newbot to create a new bot Follow the prompts to name your bot and get a unique API token Save your access token and username Once you set your bot, you can send the image, and get the descriptions.

Automate Google Analytics Reporting with n8n This n8n workflow collects, processes, and formats Google Analytics data into a comprehensive HTML report. The report is segmented into three primary categories: Engagement Stats, Search Results, and Country Views. The formatted report can be emailed or saved as a document, and the workflow includes error handling and logging for better debugging. Overview Purpose To automate the extraction, processing, and presentation of Google Analytics data in a visually appealing and structured format for easier insights and decision-making. Features Data Parsing**: Individual parsers process raw Google Analytics data for different time periods and categories. Data Aggregation**: Combines parsed data into a single structured JSON object. HTML Report Generation**: Formats the aggregated data into an HTML table with color-coded segments for better readability. Email or Document Output**: The formatted report can be emailed or saved as a Google Doc (will need additional setup). Error Handling**: Includes checks for missing data and detailed error messages for debugging. Workflow Steps Data Fetching: Six separate Google Analytics data pulls: Page Engagement Stats (This Week and Prior Week) Google Search Results (This Week and Prior Week) Country Views (This Week and Prior Week) Data Parsing: Each data pull is processed using a dedicated parser node to generate a URL-safe string. Example nodes: Parse - Get Page Engagement This Week Parse - Country Views Prior Week Data Aggregation: Aggregates parsed data into a structured JSON object using the Aggregate Data node. Ensures consistency and handles missing or malformed data. HTML Report Generation: Creates a formatted HTML report with color-coded tables for each segment: Engagement Stats: Green Search Results: Blue Country Views: Orange Includes headers and neatly formatted tables for each data set. Output: The report can be sent via email using the Gmail API or saved to Google Docs. Example nodes: Gmail node for email delivery. Google Docs node for saving the report as a document. Requirements Prerequisites Google Cloud Setup**: Enable Google Analytics API. Enable Gmail API (if using email output). Generate OAuth credentials for API access. n8n Installation**: Self-hosted n8n instance with required nodes (Gmail, Google Docs, etc.). Free Cloud-based n8n account. Environment Variables Ensure API credentials and tokens are set up in the n8n environment. Update the respective nodes with client ID, client secret, and access tokens. Configuration Google Analytics Configure the Get Report nodes with the appropriate property ID and metrics. Ensure correct date ranges are selected for each node. Formatting Node The Format Data node processes aggregated data and generates the HTML content. Customize the HTML styling and segment colors as needed. Email Node Configure the Gmail node with OAuth credentials. Set the recipient email address and subject line dynamically. Error Handling Common Issues Authentication Errors: Ensure OAuth credentials are correct. Verify that the APIs are enabled in the Google Cloud Console. Empty Data: Check the raw data from Google Analytics. Validate the property ID and query parameters in the Get Report nodes. Parsing Errors: Ensure the parser nodes are correctly configured and match the expected input format. Debugging Use debug logs in each node to identify data flow issues. Add error-handling nodes to capture and log issues during execution. Example Usage Run the Workflow Trigger the workflow to fetch, process, and format Google Analytics data. Verify Output Check the formatted HTML output in the debug logs. Ensure the email or Google Doc contains the correctly formatted report. Future Enhancements Add support for additional metrics or dimensions. Integrate with Slack for notifications. Enable scheduling for automated reports. Add a visual dashboard for real-time analytics.

This workflow checks a Google Calendar at 8am on the first of each month to get anything that has been marked as a Holiday or Illness. It then merges the count for each person and sends an email with the list. To use this workflow you will need to set the credentials to use for the Google Calendar node and Send Email node. You will also need to select the calendar ID and fill out the information in the send email node. This workflow searches for Events that contain "Holiday" or "Illness" in the summary. If you want to change this you can modify it in the Switch node.

Workflow Description: This n8n workflow automates the drafting of email replies for Fastmail using OpenAI's GPT-4 model. Here’s the overall process: Email Monitoring: The workflow continuously monitors a specified IMAP inbox for new, unread emails. Email Data Extraction: When a new email is detected, it extracts relevant details such as the sender, subject, email body, and metadata. AI Response Generation: The extracted email content is sent to OpenAI's GPT-4, which generates a personalized draft response. Get Fastmail Session and Mailbox IDs: Connects to the Fastmail API to retrieve necessary session details and mailbox IDs. Draft Identification: Identifies the "Drafts" folder in the mailbox. Draft Preparation: Compiles all the necessary information to create the draft, including the generated response, original email details, and specified recipient. Draft Uploading: Uploads the prepared draft email to the "Drafts" folder in the Fastmail mailbox. Prerequisites: IMAP Email Account: You need to configure an IMAP email account in n8n to monitor incoming emails. Fastmail API Credentials: A Fastmail account with JMAP API enabled. You should set up HTTP Header authentication in n8n with your Fastmail API credentials. OpenAI API Key: An API key from OpenAI to access GPT-4. Make sure to configure the OpenAI credentials in n8n. Configuration Steps: Email Trigger (IMAP) Node: Provide your email server settings and credentials to monitor emails. HTTP Request Nodes for Fastmail: Set up HTTP Header authentication in n8n using your Fastmail API credentials. Replace the httpHeaderAuth credential IDs with your configured credential IDs. OpenAI Node: Configure the OpenAI API key in n8n. Replace the openAiApi credential ID with your configured credential ID. By following these steps and setting up the necessary credentials, you can seamlessly automate the creation of email drafts in response to new emails using AI-generated content. This workflow helps improve productivity and ensures timely, personalized communication.

This workflow automatically deletes user data from different apps/services when a specific slash command is issued in Slack. Watch this talk and demo to learn more about this use case. The demo uses Slack, but Mattermost is Slack-compatible, so you can also connect Mattermost in this workflow. Prerequisites Accounts and credentials for the apps/services you want to use. Some basic knowledge of JavaScript. Nodes Webhook node triggers the workflow when a Slack slash command is issued. IF nodes confirm Slack's verification token and verify that the data has the expected format. Set node simplifies the payload. Switch node chooses the correct path for the operation to perform. Respond to Webhook nodes send responses back to Slack. Execute Workflow nodes call sub-workflows tailored to deleting data from each individual service. Function node, Crypto node, and Airtable node generate and store a log entry containing a hash value. HTTP Request node sends the final response back to Slack.

This workflow shows a no code approach to creating Salesforce accounts and contacts based on data coming from Excel 365 (the online version of Microsoft Excel). For a version working with regular Excel files check out this workflow instead. To run the workflow: Make sure you have both Excel 365 and Salesforce authenticated with n8n. Have a Microsoft Excel workbook with contacts and their account names ready: Select the workbook and sheet in the Microsoft Excel node of the workflow, then configure the range to read data from: Hit the Execute Workflow button at the bottom of the n8n canvas: Here is how it works: The workflow first searches for existing Salesforce accounts by name. It then branches out depending on whether the account already exists in Salesforce or not. If an account does not exist yet, it will be created. The data is then normalised before both branches converge again. Finally the contacts are created or updated as needed in Salesforce.

This n8n workflow demonstrates how to automate indexing of images to build a object-based image search. By utilising a Detr-Resnet-50 Object Classification model, we can identify objects within an image and store these associations in Elasticsearch along with a reference to the image. How it works An image is imported into the workflow via HTTP request node. The image is then sent to Cloudflare's Worker AI API where the service runs the image through the Detr-Resnet-50 object classification model. The API returns the object associations with their positions in the image, labels and confidence score of the classification. Confidence scores of less the 0.9 are discarded for brevity. The image's URL and its associations are then index in an ElasticSearch server ready for searching. Requirements A Cloudflare account with Workers AI enabled to access the object classification model. An ElasticSearch instance to store the image url and related associations. Extending this workflow Further enrich your indexed data with additional attributes or metrics relevant to your users. Use a vectorstore to provide similarity search over the images.

This workflow integrates both web scraping and NLP functionalities. It uses HTML parsing to extract links, HTTP requests to fetch essay content, and AI-based summarization using GPT-4o. It's an excellent example of an end-to-end automated task that is not only efficient but also provides real value by summarizing valuable content. Note that to use this template, you need to be on n8n version 1.50.0 or later.

Facebook access tokens expire quickly, requiring regular updates for continued API access. This workflow simplifies the process of exchanging short-lived tokens for long-lived ones, saving time and reducing manual effort. What this workflow does Exchanges a short-lived Facebook User Access Token for a long-lived token using the Facebook Graph API. Optionally retrieves a long-lived Page Access Token associated with the user. Outputs both the user and page tokens for further use in automation or integrations. Setup Prerequisites: A valid Facebook App ID and App Secret. A short-lived User Access Token from the Facebook platform. (Optional) The App-Scoped User ID for fetching associated page tokens. Workflow Configuration: Replace placeholder values in the "Set Parameter" node with your Facebook credentials and token. Run the workflow manually to generate long-lived tokens. Documentation Reference: Follow the official Facebook guide for more details: https://developers.facebook.com/docs/facebook-login/guides/access-tokens/get-long-lived/

This workflow will allow you to enrich in real-time a form submission from Webflow using Datagma. Based on the result of this workflow, a specific Calendly link will be shown on the website. If the process outcome is '1', a link for a one-on-one demo will be provided. If the process outcome is '2', a link for a group demo will be shown. Full guide here: Real-time Lead Routing

Replicate Line Items on New Deal in HubSpot Workflow Use Case This workflow solves the problem of manually copying line items from one deal to another in HubSpot, reducing manual work and minimizing errors. What this workflow does Triggers** upon receiving a webhook with deal IDs. Retrieves** the IDs of the won and created deals. Fetches** line items associated with the won deal. Extracts** product SKUs from the retrieved line items. Fetches** product details based on SKUs. Creates** new line items for the created deal and associates them. Sends** a Slack notification with success details. Step up steps Create a HubSpot Deal Workflow 1.1 Set up your trigger (ex: when deal stage = Won) 1.2 Add step : Create Record (deal) 1.3 Add Step : Send webhook. The webhook should be a Get to your n8n first trigger. Set two query parameter : deal_id_won as the Record ID of the deal triggering the HubSpot Workflow deal_id_create as the Record ID of the deal created above. Click Insert Data -> The created object Set up your HubSpot App token in HubSpot -> Settings -> Integration -> Private Apps Set up your HubSpot Token integration using the predefined model. Set up your Slack connection Add an error Workflow to monitor errors

Template to get your public IP address and push it to Namecheaps Dynamic DNS per subdomain. Open "yourdomain.com" Insert your domain and your Namecheap DDNS password Open "subdomains" Replaces and insert your subdomains Execute Workflow Have fun!

This is the workflow powering the n8n demo shown at StrapiConf 2022. The workflow searches matching Tweets every 30 minutes using the Interval node and listens to Form submissions using the Webhook node. Sentiment analysis is handled by Google using the Google Cloud Natural Language node before the result is stored in Strapi using the Strapi node. (These were originally two separate workflows that have been combined into one to simplify sharing.)

Monitor Zalando product pricing and get notified if a Zalando product price falls under a limit you have defined. This n8n workflow lets you follow the evolution of the price of products you select. For each product, you define a minimal price. The workflow automatically scrapes the price for you on a daily basis. If the price falls under your minimal price settings, you receive a notification. This workflow is very easy to use. From a simple form, just paste the URL of the Zalando product you want to monitor and fill in the minimal price. Features Monitor Zalando Product price: follow the price evolution of your favorite Zalando products. Email notification: set a minimal price, if the product price falls below this limit, you get notified by email. Visual price evolution: get a graphical overview of the product pricing evolutions. Automated Daily check-up: this workflow automatically checks the price of your selected Zalando products on a daily basis. Set up Copy this workflow to your n8n interface. Create a new Google Spreadsheet, copy this template Setup your workflow with your Google credential, your email, and your copy of the Spreadsheet. Activate the Workflow and start pasting Zalando product URLs. I hope you will enjoy this workflow that is probably one of the simplest ways to monitor the pricing evolution of your favorite Zalando products. Feel free to contact me should you have any questions or suggestions. Created by the n8n.inja ✨ follow on X 📺 follow on YT

AI Content Generator Workflow Introduction This workflow automates the process of creating high-quality articles using AI, organizing them in Google Drive, and tracking their progress in Google Sheets. It's perfect for marketers, bloggers, and businesses looking to streamline content creation. With minimal setup, you can have a fully operational system to generate, save, and manage your articles in one cohesive workflow. How It Works Collect Inputs: Users fill out a form with details like article title, keywords, and instructions. Generate Content: AI creates an outline and writes the article based on user inputs. Organize Files: Saves the outline and final article in Google Drive for easy access. Track Progress: Updates Google Sheets with links to the generated content for tracking. Set Up Steps Time Required**: Approximately 15–20 minutes to connect all integrations and test the workflow. Steps**: Connect Google Drive and Google Sheets: Authorize access to store files and update the spreadsheet. Set Up OpenAI Integration: Add your OpenAI API key for generating the outline and article content. Customize the Form: Modify the form fields to match the details you want to collect for each article. Test the Workflow: Run the workflow with sample inputs to ensure everything works smoothly. This workflow not only simplifies the process of article creation but also sets a foundation for expanding into additional automations, like posting to social media platforms.

Use Case This workflow aims to enrich new contacts in Intercom. The more relevant the Intercom profile, the more useful it is. Once active, this n8n workflow will update contact data (phone, email) as well as location data from ExactBuyer. Setup Add a webhook url in Intercom to call this workflow Add your Exact Buyer API key Add your Intercom API key Activate workflow How to adjust this template There's plenty of interesting info that ExactBuyer returns that could be helpful. Take a look and update this workflow to add what you need.

Description: This template facilitates the transfer of a folder, along with all its files and subfolders, within a Nextcloud instance. The Nextcloud user must have access to both the source and destination folders. While Nextcloud allows folder movement, complications may arise when dealing with external storage that has rate limits. This workflow ensures the individual transfer of each file to avoid exceeding rate limits, particularly useful for setups involving external storage with rate limitations. How it works: Identify all files and subfolders within the specified source folder. Recursive search within subfolders for additional files. Replicate the folder structure in the target folder. Individually move each identified file to the corresponding location in the target folder. Set up steps: Set Nextcloud credentials for all Nextcloud nodes involved in the process. -Edit the trigger settings. Detailed instructions can be found within the respective trigger configuration. Initiate the workflow to commence the folder transfer process. Help If you need assistance with applying this template, feel free to reach out to me. You can find additional information about me and my services here. => https://nicokowalczyk.de/links I have also produced a video where I explain the workflow and provide an example. You can find this video over here. https://youtu.be/K1kmG_Q_jRk Cheers. Nico Kowalczyk

Hello there! This is a supporting workflow for an Airtable Base that handles Recurring Tasks. The objective of the workflow is to handle creating tasks on a recurring basis depending on the Airtable Setup You can access that Airtable Template here for complete context- Airtable Universe The functionality of the workflow can be easliy adapted to any data source. Feel free to contact us with any doubts or questions at http://sidetool.co ​ Use this as is, or adapted to your existing Airtable Base – embrace automated simplicity! 🚀🌟

This workflow automatically syncs Shopify orders with your Zendesk contacts. Using this workflow, the Shopify email ID, phone number ID and order information will be added or updated to Zendesk contacts. Prerequisites Shopify account and Shopify credentials Zendesk account and Zendesk credentials How it works Shopify Trigger starts the workflow whenever a customer`s data is updated. Zendesk Node then searches the contact by email address. Set node keeps only the UserId and email of the contact. Merge by Key node combines the Shopify and Zendesk data. If node splits the workflow conditionally, check if the contact already exists or not. If the user exists, Zendesk node updates its contact data. If the user does not exist, Zendesk node creates a new contact.