As an Amazon Associate we earn from qualifying purchases. This post may contain affiliate links.

How to Automate Obsidian with n8n Webhooks: 5-Step Guide

Quick Answer: To automate Obsidian with n8n webhooks, you need the Obsidian Local REST API plugin enabled in your vault and an n8n instance running on the same network. By sending HTTP POST requests from an n8n webhook trigger to your local Obsidian API URL, you can automatically create, append, and update markdown files based on data from external apps like Notion, Telegram, or RSS feeds.

Obsidian is unmatched for deep work, linking your thinking, and building a local-first knowledge base. However, its greatest strength—being a local application—is also its biggest friction point when it comes to automation. Unlike cloud-based tools like Notion or Evernote, Obsidian cannot natively receive data from web services while you are away from your keyboard.

If you want to clip articles, log tasks, or journal your daily metrics automatically, manual data entry quickly becomes a bottleneck. This is where n8n and webhooks bridge the gap. By combining Obsidian’s extensibility with n8n’s node-based automation engine, you can build a system that captures data from the web and silently formats it into perfectly structured Markdown files within your local vault.

This guide details exactly how to automate Obsidian with n8n webhooks, moving from basic API configuration to advanced data-routing workflows.

1. Preparing Your Obsidian Vault for Automation

To allow n8n to communicate with your Obsidian vault, you must first transform Obsidian into a local web server capable of receiving HTTP requests. This is accomplished using a community plugin.

Installing the Local REST API Plugin

The foundation of this automation is the Local REST API plugin for Obsidian. This plugin exposes a secure, local-only API that allows external applications to read, write, and modify the Markdown files inside your vault.

1. Open Obsidian Settings and navigate to Community Plugins.
2. Turn off Safe Mode if you haven’t already, and click Browse.
3. Search for “Local REST API” (developed by coddingtonbear) and click Install, then Enable.
4. Open the plugin settings. You will see an interface displaying your API server status, the default port (usually 27123 or 27124), and your API Key.

Securing the Connection

By default, the Local REST API plugin generates a self-signed HTTPS certificate and a secure Bearer token.

Copy your API Key immediately and store it in a secure password manager. You will need this token to authenticate your n8n webhooks. Ensure the server is set to run on HTTPS. Because you are using a self-signed certificate on a local network, web browsers will flag the connection as insecure, but the encryption itself is valid and prevents local network sniffing.

Testing the API

Before moving to n8n, verify the API is responding. Open your terminal or a tool like Postman and send a simple GET request:

curl -k -H "Authorization: Bearer YOUR_API_KEY_HERE" https://127.0.0.1:27124/

(The -k flag tells cURL to ignore the self-signed certificate warning).

If configured correctly, Obsidian will return a JSON response listing the configuration status of your vault. Your endpoint is now ready to receive data.

2. Setting Up Your n8n Environment

To interact with a local application like Obsidian, your automation platform needs local network access. This is why n8n is vastly superior to Zapier or Make for Obsidian automation: n8n can be self-hosted on your own hardware.

Self-Hosted vs. Cloud

If you use n8n Cloud, the n8n servers are located on the public internet. They cannot securely reach your local computer’s IP address (like 192.168.1.50) without a complex reverse proxy setup.

For the most reliable Obsidian automation, you should run n8n locally via Docker on the same machine as Obsidian, or on a local home server (like a Raspberry Pi or NAS) connected to the same LAN.

Creating the Webhook Trigger

Once your n8n instance is running, create a new workflow. The first node in your workflow will dictate how data enters the system.

1. Add a Webhook node to the canvas.
2. Set the HTTP Method to POST.
3. Set the Path to something descriptive, like obsidian-inbox.
4. Choose the Authentication method. If you are exposing this webhook to external services (like Telegram), you may want to set up basic Auth or header auth within n8n to prevent spam.
5. Save the node. n8n will generate a Test URL.

This Webhook node acts as your digital catcher’s mitt. Whenever a service sends a POST request to this URL, the workflow will trigger, passing the payload data into n8n for processing.

3. Connecting n8n to Obsidian via HTTP Request Node

With data entering n8n via the Webhook, the next step is formatting that data and pushing it into your Obsidian vault. This is handled by the HTTP Request node.

Configuring the HTTP Node

Add an HTTP Request node directly after your Webhook node. This node will act as the client talking to your Obsidian Local REST API.

Configure the node with the following settings:

• Authentication: Set to “None” (we will pass the token in the headers).
• Request Method: Choose POST to create a new file, PUT to overwrite an existing file, or PATCH to append data to an existing file.
• URL: Input your Obsidian Local REST API endpoint. For example, to create a new note in your inbox folder: https://192.168.1.100:27124/vault/Inbox/AutomatedNote.md.
• Ignore SSL Issues: Toggle this to ON. Because Obsidian generates a self-signed certificate, n8n will reject the connection unless you explicitly tell it to ignore SSL validation errors.

Setting Headers and Payload

You must pass your API key to Obsidian to authorize the write operation.

1. Scroll to the Headers section of the HTTP node.
2. Add a new header pair:
   • Name: Authorization
   • Value: Bearer YOUR_API_KEY_HERE

Next, configure the body of the request. The Local REST API plugin accepts plain text Markdown.

1. Set the Body content type to String or Raw.
2. In the body text field, you can use n8n’s expression engine to format your note.

For example, to format an incoming webhook payload into a Markdown file with YAML frontmatter:

---
title: {{$json.body.title}}
date: {{$now.toFormat('yyyy-MM-dd')}}
tags: [automated, inbox]
---
# {{$json.body.title}}

{{$json.body.content}}

*Captured via n8n at {{$now.toFormat('HH:mm')}}*

When the node executes, n8n will interpolate the incoming JSON data, generate the Markdown string, and push it to Obsidian. A split second later, the file will magically appear in your vault.

4. Building Advanced Automation Workflows

Once the core connection is established, you can build highly specific workflows to automate your knowledge management. Here are three high-impact workflows you can implement.

Telegram to Daily Note

Capturing quick thoughts on mobile is notoriously slow with the official Obsidian app. By connecting a Telegram bot to n8n, you can create a frictionless capture system.

1. Create a bot using Telegram’s BotFather and add the Telegram Trigger node to n8n.
2. Add a Set node to format the incoming text.
3. Use an HTTP Request node set to the PATCH method.
4. Target your daily note dynamically using an expression in the URL: https://127.0.0.1:27124/vault/Daily/{{$now.toFormat('yyyy-MM-dd')}}.md.
5. Set the body to - [ ] {{$json.message.text}} to format the message as a task.

Now, whenever you send a message to your Telegram bot, it instantly appends as a task at the bottom of today’s Obsidian daily note.

RSS Feed to Reading List

Stop losing track of interesting articles. You can automate a reading list by watching RSS feeds.

1. Use the RSS Read node in n8n, set to run on a schedule (e.g., every 6 hours).
2. Use an Item Lists node to batch the incoming articles.
3. Connect an HTTP Request node set to POST.
4. Set the file path dynamically based on the article title: https://127.0.0.1:27124/vault/Reading/{{$json.title.replace(/[^a-zA-Z0-9]/g, '-')}}.md.
5. Pass the article URL, excerpt, and author into the note’s frontmatter.

Syncing Todoist Tasks to Obsidian

Many users manage tasks in Todoist but take notes in Obsidian. You can use n8n to bridge them.

1. Set up a Webhook node to listen for Todoist’s “Task Completed” event.
2. Filter the payload to ensure it only grabs tasks from specific projects using a Switch node.
3. Use the HTTP Request node (PATCH method) to append the completed task data to your Obsidian weekly review note.
4. Format the output to include a link back to the original Todoist item.

5. Practical Advice for Resilient Webhooks

While setting up the webhook pipeline is straightforward, local network automation comes with inherent fragility. Unlike cloud servers, your laptop goes to sleep, changes Wi-Fi networks, and requires system updates. To keep your automation robust, apply these architectural rules.

Handling Node Failures When Obsidian is Closed

If n8n attempts to send a webhook to Obsidian while the Obsidian application is closed, the HTTP request will fail, and your data will be lost.

To prevent this, implement error routing in n8n. On the HTTP Request node connecting to Obsidian, enable the “Continue On Fail” setting. Connect an “Error Trigger” node that catches these failed executions and routes the payload to a local database (like SQLite) or a cloud service (like a private Google Sheet). Once Obsidian is open, you can trigger a secondary workflow to pull those queued items into your vault.

Alternatively, if you use Obsidian Sync, you can configure n8n to write the Markdown files directly to the local folder on your hard drive using the n8n Read/Write Files node instead of the API. Obsidian will index them the next time it opens. However, the REST API is generally safer for appending data to existing files to avoid sync conflicts.

Managing Dynamic File Paths and Sanitization

When using n8n expressions to generate file names from incoming webhooks, you must sanitize the input. Webhook payloads often contain characters that are illegal in file paths (like colons, slashes, or quotes).

Always use JavaScript string manipulation in your n8n expressions to strip invalid characters. A reliable expression for file names is: {{ $json.title.replace(/[\/\\?%*:|"<>]/g, '').trim() }}

This ensures that a webhook payload titled “Guide: How to Automate!” becomes a valid file named Guide How to Automate!.md.

Securing Remote Access with Tailscale

If you host n8n on a home server but travel with your Obsidian laptop, your n8n instance will not be able to reach your Local REST API over the internet.

Instead of exposing your Obsidian port to the public internet (which is highly dangerous), install Tailscale on both your n8n server and your laptop. Tailscale creates a secure, encrypted mesh VPN. You can then configure your n8n HTTP Request node to target your laptop’s Tailscale IP address (e.g., 100.85.x.x) instead of the local 192.168.x.x address. This allows your webhooks to reach Obsidian safely from anywhere in the world.

Conclusion

Automating Obsidian with n8n webhooks unlocks the true potential of your personal knowledge management system. By leveraging the Local REST API plugin alongside n8n’s visual node editor, you can seamlessly pipe data from any API, web service, or chat application directly into your local Markdown files.

Start small. Begin by creating a simple webhook to append quick thoughts to your daily note. Once you are comfortable managing the JSON payloads and routing HTTP requests, you can scale your system to handle complex workflows like syncing task managers, backing up social media bookmarks, and categorizing RSS feeds. By automating the friction of data capture, you free up your time to focus on what actually matters: connecting ideas and producing meaningful work.

Frequently Asked Questions

Can n8n connect to Obsidian if my vault is closed?

No. The Obsidian Local REST API plugin requires the Obsidian application to be actively running to process incoming HTTP requests. If the app is closed, requests from n8n will time out or return an error.

Is the Obsidian Local REST API safe to use?

Yes, it is secure for local environments. The plugin generates a Bearer token for authentication and utilizes a self-signed HTTPS certificate, meaning your data is encrypted in transit on your local network.

What happens if I rename a file that n8n targets?

If you rename a file in Obsidian, n8n will no longer be able to find it using the old file path. Any subsequent PATCH or PUT requests to the old URL will typically result in a 404 error, or depending on your settings, may create a new duplicate file with the old name.

Do I need n8n cloud or self-hosted?

For integrating with Obsidian’s local API, you must use self-hosted n8n running on your local network or via a secure VPN like Tailscale. n8n Cloud cannot natively bypass your home router’s firewall to reach the local Obsidian server.

Can I use Zapier or Make instead of n8n for this?

Using Zapier or Make is exceedingly difficult for this specific workflow. Because they operate entirely in the cloud, they cannot communicate with a local Obsidian instance without setting up complex and potentially insecure port-forwarding on your home router.