Webhook + deariary: connect anything to your diary

#integration #guide

Your cat used the litter box three times yesterday. Your portfolio was up 1.4% for the week. You jotted down a thought from the terminal at 2pm that you would have forgotten by dinner.

None of these things belong to a calendar, a task manager, or a chat app. But they are all part of your day. And with webhooks, they are all part of your diary.

The webhook integration is deariary’s universal bridge. It accepts any valid JSON payload via a simple POST request, stores it, and includes it in the next diary generation. There is no fixed schema. No OAuth flow. No third-party connector. If something can make an HTTP request, it can write to your diary.

What makes webhooks different from other integrations

Every other deariary integration is a dedicated pipeline. GitHub pulls your commits. Google Calendar pulls your events. Todoist pulls your completed tasks. Each one knows exactly what data to collect and how to structure it.

Webhooks have no such opinion. You send whatever JSON makes sense for your use case, and deariary figures out how to weave it into the narrative. This makes webhooks the only integration that scales to anything: a smart pet feeder, a stock portfolio tracker, a CLI memo tool, a browser extension. If the data exists somewhere, you can pipe it in.

The trade-off is that webhooks do not set themselves up. The built-in integrations connect in thirty seconds with OAuth. Webhooks require you (or a script you write) to send the data. But the reward is total flexibility over what enters your diary.

How it works

When you enable the webhook integration, you create one or more bearer tokens from the Webhook settings page. Each token gets a name (like “pet tracker” or “terminal notes”) and a whk_-prefixed secret. You use that token to authenticate POST requests to deariary’s ingestion endpoint.

Here is a minimal example:

curl -X POST https://api.deariary.com/webhooks/ingest \
  -H "Authorization: Bearer whk_your_token_here" \
  -H "Content-Type: application/json" \
  -d '{"event": "litter_box", "cat": "Mochi", "weight_kg": 4.2, "time": "14:30"}'

The payload can be any valid JSON up to 100 KB. There is no required schema. Send structured data, send a single string, send nested objects. deariary stores each POST as a separate artifact, and the LLM reads all of them when generating the next diary entry. The token name you assigned is attached to each payload, so the LLM knows which source it came from.

You can send multiple requests throughout the day. Each one becomes its own artifact. A morning note, an afternoon reading highlight, and an evening pet update all arrive separately and all appear in the same diary entry.

Real examples

The power of webhooks is that they connect the parts of your life that no pre-built integration can reach. Here are five setups that users and our team have built.

A CLI micro-diary

A developer on our team built a tiny terminal command that sends a one-liner to deariary. Throughout the day, whenever a thought strikes, they type something like:

d "API design should feel like a conversation, not a contract"

The script wraps the text in JSON and POSTs it. No context switching, no opening an app. Just a thought, captured in the same terminal where they are already working.

Their diary entries now include lines like: “Jotted down 3 notes from the terminal today. The best one: ‘API design should feel like a conversation, not a contract.’” Those fragments would have evaporated by the end of the day. Instead, they became part of the record.

Smart pet devices

One user pipes data from their Petkit litter box and smart feeder into deariary. The litter box reports usage count and the cat’s weight. The feeder reports feeding times. The data arrives as structured JSON automatically, no manual input at all.

Their diary includes a “Mochi” section: “Mochi used the litter box 3 times today, all normal. Weight steady at 4.2 kg from the Petkit scale. She demolished the new feather toy in under an hour.” The feather toy was a manual webhook. The rest was fully automated.

This is one of the most surprising use cases we have seen. The cat’s daily routine, documented alongside meetings and code reviews, gives the diary an unexpected warmth. Six months from now, reading that Mochi weighed 4.2 kg and destroyed a feather toy is exactly the kind of detail that makes an ordinary day feel real.

A personal finance tracker

Another user runs a nightly cron job that fetches their daily portfolio snapshot from a brokerage API and forwards it to deariary. The JSON includes positions opened, positions closed, and a daily percentage change.

The diary might read: “Sold AAPL at +3.2% and opened a small position in MSFT. Portfolio is up 1.4% for the week.” Over months, the diary becomes a financial journal alongside everything else, without the user doing anything after the initial script setup.

A browser extension for reading

A user built a browser extension that sends bookmarked articles and highlighted passages to deariary. Every time they save an article or highlight a quote, it fires a webhook with the title, URL, and selected text.

Their diary entries capture what they read that day: “Saved 2 articles via the browser extension, one on WebAssembly outside the browser, another comparing edge compute providers. Highlighted a passage about cold starts.” Reading patterns that would otherwise scatter across bookmarks and tabs are woven into the day’s narrative.

iOS Shortcuts for on-the-go capture

An iOS Shortcut that prompts for a one-line note, attaches the current timestamp, and fires a POST request. The interaction takes five seconds. Some users trigger it after a workout (“5k morning run, new route through the park”), after finishing a book, or whenever something happens that they want in their diary.

This is the simplest webhook setup: no server, no cron job, just a phone shortcut. It turns the webhook into a quick-capture tool for moments that no app is watching.

What a webhook-enriched diary looks like

Here is how the same day reads with and without webhook data:

Google Calendar + Todoist only:

Your morning started with a team standup, followed by a design review. You completed 6 tasks, including finalizing the homepage copy and replying to client feedback. After lunch you had a 1-on-1 with your manager.

Google Calendar + Todoist + Webhooks (pet tracker, terminal notes, reading extension):

You started the day with a quick note from the terminal: “ship the onboarding fix before standup.” After the team standup and a design review, you knocked out 6 tasks including the homepage copy. Mochi’s weight held steady at 4.2 kg and she used the litter box twice before noon. Your 1-on-1 with your manager ran long, but you squeezed in an article on edge computing before the end of the day. On the train home you bookmarked a piece on WebAssembly that you want to revisit.

The first entry is a work log. The second is a day with texture: the cat, the fleeting thought, the article on the train. Webhooks fill the spaces between the big apps with the small details that make a diary worth re-reading.

What deariary does with your webhook data

Schema-free ingestion. Any valid JSON up to 100 KB per request. deariary does not validate or reject payloads based on structure.
Source labeling. Each payload is tagged with the token name you defined, so the LLM can distinguish “pet tracker” data from “terminal notes” data in the same diary entry.
Multiple artifacts per day. Every POST creates a separate artifact. Send ten events throughout the day and all ten are included in the next diary generation.
Equal treatment. Webhook data goes through the same LLM pipeline as data from GitHub, Google Calendar, and every other integration. There is no separate section or lower priority.

What deariary does NOT do with webhook data

No outbound webhooks. deariary does not send notifications to external systems. The webhook integration is inbound only.
No payload validation. deariary accepts whatever JSON you send. It does not verify that your cat actually weighs 4.2 kg or that your portfolio is really up 1.4%.
No modification of other integrations. Webhook data is added alongside data from your connected services. It does not replace or override anything.
No webhook management API. Tokens are created and revoked from the deariary web interface, not via API.

Setting it up

The webhook integration requires the Advanced plan. You can create up to 10 tokens per account, which lets you separate data sources (one token for your pet tracker, another for your terminal notes, a third for your finance script).

Go to app.deariary.com
Open Settings and find the Integrations section
Click Webhook and create a token with a descriptive name
Copy the token immediately (it is shown only once)
Use the token as a Bearer token in the Authorization header of your POST requests

The endpoint is POST /webhooks/ingest. The body is any valid JSON. That is it.

From there, the possibilities depend on what you connect. A cron job, an iOS Shortcut, a home automation rule, a browser extension, a Zapier zap, a Raspberry Pi script. Anything that can send an HTTP request can write to your diary.

What surprised us

We have been using webhooks internally since deariary’s early prototype. A few things stood out.

Automation beats manual entry. We originally imagined webhooks as a manual quick-capture tool: type a note, send it. That works, but the most engaged users are the ones who automated the pipeline entirely. Their pet feeders, portfolio scripts, and home sensors send data without any human intervention. The diary fills up with details they never had to think about. That is the same principle as deariary’s built-in integrations (connect once, forget), just extended to anything.

Token names matter more than you expect. The token name is how the LLM knows what kind of data it is looking at. A token named “pet tracker” produces diary entries about your cat. A token named “webhook-1” produces confused entries. Descriptive token names consistently improve diary quality.

People combine manual and automated webhooks. The same user might have an automated pet tracker running 24/7 and an iOS Shortcut for occasional manual notes. Both feed into the same diary. The automated data provides the baseline. The manual notes add the moments that only a human would think to record: “Mochi destroyed the feather toy” or “first snow of the year.”

deariary’s built-in integrations capture what happens inside the apps you use every day. Webhooks capture everything else: the pet, the portfolio, the passing thought, the thing you built a script for because no app existed. Together, they give your diary the full picture of a day.

Enable webhooks on deariary