How to Receive External Data in Obsidian

Obsidian has over 2000 community plugins. You can export notes, sync to GitHub, send data to every SaaS tool imaginable. But there's one glaring gap: you can't receive data from external services. Everything flows out. Nothing flows in.

This wasn't a problem when Obsidian was just for personal notes. But in 2026, people run entire knowledge management systems, project trackers, and AI agent workflows in their vaults. They need external data flowing in — automatically, reliably, in real-time.

The Problem: Obsidian Can't Receive Data

Obsidian is local-first by design. Your vault lives on your machine. No cloud backend, no HTTP server, no API endpoint. This is great for privacy and speed, but it creates a fundamental limitation: external services have nowhere to send data.

Say you want to capture emails as notes via Zapier. Or log GitHub issues to a project tracking vault. Or save AI agent outputs to your knowledge base. There's no built-in way to do this.

The Obsidian community has been asking for this since 2021. A forum thread about Zapier integration has hundreds of upvotes but no official solution. The architecture just doesn't support it.

Why Existing Workarounds Fall Short

People have tried to solve this with various hacks. None of them work reliably. For a deeper technical comparison, see our REST API vs Webhooks guide.

File Sync Services (Dropbox, iCloud)

You can point Zapier at your Dropbox folder and hope Obsidian picks up the changes. But file sync is designed for human edits, not automation. You get:

• Delayed propagation (seconds to minutes)
• No delivery guarantees
• Sync conflicts when multiple sources write at once
• No way to confirm delivery

This breaks the moment you have time-sensitive data or multiple integrations.

trashhalo/obsidian-webhooks Plugin

This plugin adds incoming webhooks to Obsidian. It was the closest thing to a real solution. But it relies on a third-party relay service (webhook.site or similar), and the plugin hasn't been maintained since 2023. The relay dependency means you're trusting your data to an external service that could disappear at any time.

obsidian-post-webhook Plugin

Despite the name, this plugin only sends data from Obsidian to external webhooks. It's outgoing only. Doesn't solve the incoming data problem at all.

obsidian-local-rest-api Plugin

This exposes a REST API when Obsidian is running. Sounds perfect, except:

• Obsidian must be running and focused on the vault
• Not async — external services must wait for a response
• No queuing if Obsidian is closed
• No encryption or authentication by default

You can't use this for "fire and forget" automation where a service sends data and moves on.

The Solution: Self-Hosted Webhook Server

The missing piece is a persistent webhook endpoint that queues data and delivers it to Obsidian when the vault is online. This is what Obsidian Webhooks Server does. For a deeper look at the architecture, see How It Works.

Here's the flow:

1. External service (Zapier, Make, AI agent) sends POST request to webhook endpoint
2. Go server receives payload, encrypts it, stores in PostgreSQL queue
3. Server sends data to Obsidian plugin via SSE (Server-Sent Events)
4. Plugin writes note to vault, sends ACK confirmation
5. Server marks webhook as delivered and deletes from queue

This architecture solves all the problems:

• Persistent endpoint: External services always have somewhere to send data
• Exactly-once delivery: ACK confirmation ensures no duplicates or lost messages
• Offline sync: Queue holds data if Obsidian is closed, delivers on reconnect
• Real-time: SSE keeps connection open, delivers within milliseconds when online
• Encrypted: AES-256-GCM encryption of queue data at rest
• Multi-vault: Separate webhook keys per vault, one server supports multiple vaults

How to Send Data to Obsidian

The server accepts JSON payloads with three required fields: key (your webhook key), path (note location), and content (note body). Optional fields control behavior. For copy-paste examples with Zapier, Make, n8n, and IFTTT, see our 10 Automation Recipes.

Basic Example: Create a Note

curl -X POST https://your-server.com/webhook \
  -H "Content-Type: application/json" \
  -d '{
    "key": "your-webhook-key",
    "path": "inbox/new-note.md",
    "content": "This is the note body",
    "frontmatter": {
      "tags": ["imported", "zapier"],
      "source": "email"
    }
  }'

This creates inbox/new-note.md with YAML frontmatter and the content. If Obsidian is offline, the server queues it and delivers when the vault reconnects.

Append Mode: Add to Existing Notes

curl -X POST https://your-server.com/webhook \
  -H "Content-Type: application/json" \
  -d '{
    "key": "your-webhook-key",
    "path": "projects/project-log.md",
    "content": "\n## 2026-02-26\n- New task from GitHub",
    "mode": "append"
  }'

Use "mode": "append" to add content to an existing note instead of overwriting. Perfect for daily logs, running lists, or aggregating data from multiple sources.

Overwrite Mode: Replace Existing Content

curl -X POST https://your-server.com/webhook \
  -H "Content-Type: application/json" \
  -d '{
    "key": "your-webhook-key",
    "path": "dashboards/weekly-stats.md",
    "content": "# Weekly Stats\n- Metric A: 42\n- Metric B: 17",
    "mode": "overwrite"
  }'

Use "mode": "overwrite" when you want to replace the entire note. Useful for dashboards that regenerate from external data sources.

Real-World Use Cases for Obsidian Incoming Webhooks

Once you can push data to Obsidian, entire classes of automation become possible.

Email to Notes via Zapier

Set up a Zapier trigger for "New Email in Gmail" (filtered by label or sender). The action hits your webhook with email subject, body, and metadata. Every email becomes a timestamped note in your inbox folder. You now have a searchable, linkable email archive inside Obsidian.

GitHub Issues to Project Tracker

Use GitHub webhooks to send issue events (created, closed, commented) to your vault. Each issue becomes a note with automatic backlinks to related issues. Your project documentation lives in the same vault as your project tracking.

AI Agent Outputs to Knowledge Base

When your AI agents generate research summaries, code documentation, or meeting notes, they POST the results to Obsidian. You get a versioned, searchable knowledge base that grows automatically. No manual copy-paste, no sync lag.

RSS Feed Aggregator

Run a cron job that fetches RSS feeds and sends interesting articles to your vault. Tag them by topic, add to your reading list, or feed them into your spaced repetition system. Your reading queue is now inside Obsidian alongside your notes.

Slack Messages to Archive

Webhook integration with Slack sends starred messages or specific channel threads to Obsidian. Important conversations become notes you can link to, annotate, and search years later.

Calendar Events to Daily Notes

Sync your calendar events to daily notes in Obsidian. Each day's note gets updated with meetings, deadlines, and context. Your calendar and your knowledge system are finally in one place.

Getting Started with Obsidian Webhooks

The Obsidian Webhooks Server is open source (MIT license) and designed for self-hosting.

Option 1: Self-Host with Docker

The repository includes docker-compose.yml for a complete setup. For a detailed walkthrough, see our Self-Hosted Setup Guide:

1. Clone the repo
2. Set environment variables (database URL, encryption key)
3. Run docker-compose up -d
4. Server runs on port 8080, PostgreSQL on 5432

You get full control over your data and infrastructure. The server is lightweight (Go binary) and can run on a $5/month VPS.

Option 2: Use Hosted Version

If you don't want to manage servers, there's a free hosted version at obsidian-webhooks.khabaroff.studio. Data is encrypted at rest and hosted on EU servers (Germany, via Supabase). You sign up with passwordless email auth (magic links).

The hosted version has the same features as self-hosted: exactly-once delivery, multi-vault support, offline sync, and 10 MB per note limit.

Install the Obsidian Plugin

After setting up the server (self-hosted or hosted), install the companion plugin:

1. Open Obsidian Settings → Community Plugins
2. Search for "obsidian-webhooks-2025"
3. Install and enable
4. Enter your webhook key in plugin settings
5. Enter your server URL (or use default for hosted version)

The plugin handles SSE connection, note creation, and ACK confirmations automatically.

Technical Deep Dive: How Obsidian Receive Data Works

For developers integrating with the webhook server, here's what happens under the hood. See also: How It Works for the full architecture diagram.

Request Flow

1. POST to /webhook: Server validates JSON structure, checks webhook key exists in database
2. Encryption: Payload encrypted with AES-256-GCM, stored in PostgreSQL queue
3. SSE Push: If vault is online (SSE connection active), server decrypts and sends payload via SSE
4. Plugin Processing: Plugin receives JSON, writes note to vault file system
5. ACK Response: Plugin sends ACK with delivery status via HTTP POST to server
6. Queue Cleanup: Server marks webhook as delivered, deletes from queue

Offline Behavior

If Obsidian is closed when webhook arrives:

1. Server stores encrypted payload in queue
2. When plugin reconnects, it polls /pending endpoint
3. Server sends all queued webhooks via SSE
4. Plugin processes each one, sends individual ACKs
5. Server deletes from queue only after receiving ACK

This ensures exactly-once delivery even across network interruptions or vault restarts.

Security Model

• Webhook keys are UUID v4 (128-bit entropy)
• Queue data encrypted at rest with AES-256-GCM
• SSE connection over HTTPS (TLS 1.3)
• No payload data in logs or metrics
• Each vault has separate key, no cross-vault access

Self-hosted deployments can add additional layers (IP whitelisting, custom auth, VPN-only access).

Limitations and Roadmap

The current version (v1.0) has a few constraints:

• 10 MB per note: Large files (videos, PDFs) must be hosted externally and linked
• No batching: Each webhook is one note. To create multiple notes, send multiple webhooks
• Text only: Binary attachments not supported (use base64 + decode in Obsidian)

Planned for future releases:

• Webhook templates (transform JSON before writing to vault)
• Conditional routing (send to different folders based on payload fields)
• Webhook history and replay
• REST API for querying queue status

Check the GitHub issues for feature requests and discussion.

Conclusion: Obsidian External Integration Is Solved

For five years, Obsidian users have wanted a way to receive data from external services. File sync was too unreliable. Existing plugins depended on third-party services or required Obsidian to be running. The architecture just didn't support it.

The Obsidian Webhooks Server changes this. You get a persistent webhook endpoint, exactly-once delivery, offline sync, and encryption — everything needed for production automation. It's open source, self-hostable, and works with any service that can send HTTP POST requests.

If you're building workflows that need to send data to Obsidian — whether from Zapier, AI agents, or custom scripts — this is the infrastructure layer you've been missing.

Resources

• Obsidian Webhooks Server on GitHub
• Hosted version
• Obsidian forum thread on Zapier integration
• obsidian-webhooks-2025 plugin