Get AI summaries of any video or article — Sign up free
How I Capture & PROCESS using Readwise & Obsidian thumbnail

How I Capture & PROCESS using Readwise & Obsidian

FromSergio·
5 min read

Based on FromSergio's video on YouTube. If you like this content, support the original creators by watching, liking and subscribing to their content.

TL;DR

Readwise Reader serves as a capture inbox for web content (RSS, newsletters, Twitter, YouTube), while Readwise performs the import/export into Obsidian.

Briefing

Readwise and Readwise Reader are positioned as a two-part system for capturing highlights from anywhere on the web and turning them into searchable, revisitable notes inside Obsidian—then processing them so they don’t become a dead archive. The core workflow hinges on Readwise acting as the bridge that imports and exports saved highlights, while Readwise Reader functions as an “inbox” for reading everything from RSS feeds and newsletters to Twitter threads and YouTube videos. Highlights saved in Reader can be exported to Obsidian automatically, along with any notes added per highlight, using a configurable folder structure and formatting rules.

The setup starts by installing the “Readwise official plugin” in an Obsidian vault and connecting it to a Readwise account. A key configuration change is setting the resync frequency to hourly, ensuring new highlights appear quickly. On the Readwise side, Obsidian is added as an export location under “connect and sync highlights,” where Readwise creates a dedicated “read wise” folder in the vault with subfolders such as “books” and “tweets,” based on how content is classified. Import formatting can be customized via YAML front matter and highlight rendering. In this workflow, each new highlight is tagged with “read wise inbox” (plus a “read-wise” tag), and the notes include created/last modified fields to match the vault’s conventions. The result is a more organized highlight layout than the default export.

Readwise Reader is then used as the landing ground for nearly all online consumption. It supports newsletters, RSS feeds, Twitter, and even YouTube content, with optional browser extensions and a mobile app. A practical use case is privacy and convenience: subscribers can use a Readwise email address instead of their real email, so newsletter content lands in Reader and can be highlighted for immediate export to Obsidian. Twitter saving is handled either by “save to read wise” actions or by sending tweets to Readwise via private message. For long threads, the workflow can be tuned so that single tweets are saved to Obsidian while threads are handled differently—disabled for Readwise export and enabled within Reader—so low-value threads can be archived without cluttering the vault.

Processing is treated as the missing step that turns imported highlights into usable knowledge. The “read wise inbox” tag becomes the control mechanism: a dedicated Obsidian page is created using a Data View query (review table filtered by the “read wise inbox” tag) to list unprocessed highlights. From there, the workflow uses Obsidian’s local graph view to surface connections—neighboring and outgoing links—so older highlights can be rediscovered through related notes rather than manual searching. The local graph is presented as a way to stumble upon relevant saved material by navigating through linked concepts.

Finally, Readwise Reader’s pricing and availability are addressed via Readwise’s FAQ: Reader is in beta, with plans to reprice Readwise and Reader for new subscribers after beta ends, while existing subscribers who sign up before the beta ends are protected from price increases. The overall message is that Readwise alone felt like a “nice to have,” but pairing it with Reader and a deliberate processing system makes it a core part of a knowledge workflow.

Cornell Notes

Readwise and Readwise Reader work together to capture highlights from web reading and export them into an Obsidian vault. Readwise Reader acts as a unified inbox for newsletters, RSS feeds, Twitter, and YouTube; any highlights saved there can be exported through Readwise into Obsidian with configurable folder structure and formatting. Each imported highlight is tagged “read wise inbox,” enabling a dedicated Obsidian page (via Data View) to list items that still need processing. Processing relies on Obsidian’s local graph view to rediscover older highlights through linked concepts rather than searching. The approach matters because it prevents highlights from becoming an unreviewed archive and turns them into connected, reusable knowledge.

How does the system decide what gets exported to Obsidian, and where does it land?

Readwise Reader is used to save highlights from sources like RSS feeds, newsletters, Twitter, and YouTube. When a highlight is saved in Reader, Readwise handles the import/export to Obsidian. In Obsidian, Readwise creates a top-level “read wise” folder and then subfolders based on content type (for example, “books” and “tweets”).

What is the purpose of the “read wise inbox” tag, and how is it used for processing?

The export configuration adds a YAML front matter tag “read wise inbox” to every new highlight. In Obsidian, that tag becomes the filter for a dedicated “read wise inbox” page built with a Data View query (review table filtered by the tag). This page lists highlights that have not yet been processed, so new items are easy to find.

Why does the workflow treat Twitter threads differently from single tweets?

Single tweets can be saved directly to Readwise/Obsidian once they’re read and valued. Threads are handled with more control: the workflow disables thread saving from Readwise and enables threads in Reader. That way, a bookmarked thread that turns out to have little value can be archived in Reader without cluttering the Obsidian vault.

How does the local graph view change the way saved highlights get revisited?

Instead of searching for a specific note, the local graph view shows links between notes—both incoming and outgoing neighbors. By opening a related note, the graph reveals connected highlights around it, helping the user stumble upon older saved material through concept relationships.

What’s the practical advantage of using a Readwise email for newsletters?

When subscribing to newsletters or RSS-related email lists, the user can provide a Readwise email address rather than a personal email. That routes newsletter content into Reader’s inbox UI, where items can be highlighted and exported to Obsidian immediately if they’re worth saving.

Review Questions

  1. What configuration steps connect Readwise exports to an Obsidian vault, and what folder structure does Readwise create?
  2. How does the “read wise inbox” tag drive a processing workflow inside Obsidian?
  3. What role does local graph view play in turning imported highlights into connected knowledge rather than a static archive?

Key Points

  1. 1

    Readwise Reader serves as a capture inbox for web content (RSS, newsletters, Twitter, YouTube), while Readwise performs the import/export into Obsidian.

  2. 2

    Obsidian integration uses the Readwise official plugin and an hourly resync setting to keep highlights current.

  3. 3

    Readwise exports into a dedicated “read wise” vault folder with subfolders by content type (such as books and tweets).

  4. 4

    Custom highlight formatting can add YAML front matter tags like “read wise inbox” to support downstream processing.

  5. 5

    A dedicated Obsidian Data View page filtered by “read wise inbox” lists unprocessed highlights for review.

  6. 6

    Twitter handling can be tuned so single tweets save to Obsidian while threads are managed in Reader to avoid vault clutter.

  7. 7

    Processing relies on local graph navigation to rediscover highlights through linked concepts instead of manual searching.

Highlights

Readwise Reader is framed as the “landing ground” for almost everything consumed online, with highlights exported into Obsidian through Readwise.
Tagging every imported highlight with “read wise inbox” enables a repeatable processing queue inside Obsidian.
Local graph view is used to rediscover older highlights via neighbor links, turning saved material into a connected knowledge network.
Twitter threads can be prevented from cluttering Obsidian by disabling thread export from Readwise and handling them in Reader instead.