Get AI summaries of any video or article — Sign up free
Obsidian - Dataview Publish Plugin thumbnail

Obsidian - Dataview Publish Plugin

Josh Plunkett·
5 min read

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

TL;DR

Data view publisher turns proper DataView query results into publishable Markdown so Obsidian Publish can display them on a website.

Briefing

Obsidian Publish can’t natively run Obsidian plugins, which breaks “live” DataView-driven pages on a published website. Data view publisher fixes that gap by turning DataView queries into publishable Markdown: it hides the query in HTML comments, then injects the query results into the note so the published site shows updated tables and lists.

The workflow starts with installing the community plugin “Data view publisher” (by UD) and meeting its requirement of having the Time Tracker plugin installed. In the plugin settings, users define a “Data view source” tag (a hashtag-style marker) that tells the plugin which notes should be refreshed. An optional “Update on Save” setting can refresh the active note whenever it’s saved, but the plugin behaves best with Obsidian Live Preview—Ctrl+S and switching into Live Preview tend to trigger updates more reliably than Source-mode-only editing.

Once configured, the core mechanism is straightforward. Users create or edit a note, insert a “data view publish block” via the command palette, and paste a proper (non-inline) DataView query into that block. The query itself can be verified in normal reading mode first, but the publishable output won’t appear until the note includes the configured tag. After adding the tag, running “Update data view publish blocks” forces the plugin to execute the query and write the results into the note as Markdown—exactly what Obsidian Publish can publish.

A key detail is how updates propagate. Editing the DataView query in Source mode may not immediately refresh the rendered results, even with “Update on Save” enabled. Moving to Live Preview, making a change, and then triggering refresh (often via Ctrl+S) produces the expected re-rendering. If users prefer not to rely on Live Preview, they can still force a refresh by running the plugin’s update command, but they may need to experiment with editing modes to match their setup.

The video also demonstrates a practical migration path for an existing TTRPG website that previously used a templating workaround (Templator) to refresh DataView outputs before publishing. With Data view publisher, the DataView query can live in a dedicated note (or inside the published note), and the site can be updated by publishing only the notes marked with the source tag. The result is a “for-like” replacement: published pages show the DataView-generated lists and tables, and updates can be pushed through Obsidian Publish without manually re-running DataView.

Finally, the plugin is positioned as a targeted solution: it works for full DataView queries, not inline DataView. For inline updates, the Metabond plugin is suggested as a complementary option because it updates in real time. Overall, Data view publisher is framed as a practical answer to Obsidian Publish’s plugin limitation—especially for TTRPG use cases like monster lists, stat-block tables, and other structured content that players need on a website.

Cornell Notes

Obsidian Publish can’t run most Obsidian plugins on the published site, so DataView queries won’t automatically render “live” results. Data view publisher (UD) solves this by executing proper DataView queries inside Obsidian and injecting the resulting Markdown into the note for publishing. Users configure a specific “Data view source” tag in plugin settings, insert a “data view publish block” into a note, and then run “Update data view publish blocks” (often triggered by Live Preview or Ctrl+S). After the refresh, the published page shows the query output as normal Markdown, enabling websites to stay in sync with DataView-driven content. Inline DataView isn’t the target; the plugin focuses on full DataView queries.

Why does Obsidian Publish struggle with DataView-driven websites, and what does Data view publisher change?

Obsidian Publish uploads Markdown, but it doesn’t natively support running Obsidian plugins on the hosted site. That means DataView queries won’t execute after publishing. Data view publisher changes the workflow by running the DataView query during editing/refresh inside Obsidian, then writing the query results back into the note as publishable Markdown. The query can be kept hidden (the plugin uses comments to avoid showing the raw query), while the rendered output becomes what gets published.

What is the “Data view source” tag used for?

The plugin settings include a “Data view source” field where users define a tag (hashtag-style marker). Only notes containing that tag are treated as refresh targets. After inserting a data view publish block and pasting a DataView query, the note must include the configured tag; otherwise, running the update command won’t populate the results block.

How do users insert and populate a DataView publish block?

Users open the command palette and choose “Insert data view publish block.” They then paste a proper DataView query into that block and switch to reading mode to confirm the query works. To generate publishable output, they add the configured source tag to the note and run “Update data view publish block(s)” from the command palette. The plugin then replaces/creates the section with the query’s results as Markdown.

Why does Live Preview matter for updates?

The plugin’s refresh behavior depends on editing mode. The transcript reports that “Update on Save” (Ctrl+S) was inconsistent in Source mode, but worked better in Live Preview mode. In practice: switching to Live Preview, making a change, clicking out, and then pressing Ctrl+S tends to trigger the plugin to re-run the DataView query and update the rendered results. If updates don’t appear, running the explicit “Update data view publish blocks” command can force regeneration.

How can a site migrate from a templating workaround to Data view publisher?

Instead of relying on a template that refreshes DataView outputs before publishing, the DataView query can be moved into a note that uses a data view publish block. The note is then marked with the Data view source tag so the plugin can refresh it. The transcript also demonstrates adding the tag via YAML frontmatter properties (using a tags property) rather than visibly inserting a hashtag tag into the note body, keeping the published content cleaner. After that, publishing updates the website with the new DataView output.

What limitation should users expect regarding inline DataView?

Data view publisher is described as working for proper DataView queries, not inline DataView. Inline DataView updates aren’t handled the same way, so the transcript recommends Metabond for users who depend on inline DataView behavior that updates in real time.

Review Questions

  1. What steps ensure a DataView query becomes publishable Markdown when using Data view publisher?
  2. How do editing mode (Source vs Live Preview) and Ctrl+S affect whether Data view publisher refreshes results?
  3. Why might a note fail to update even after inserting a data view publish block? What role does the configured tag play?

Key Points

  1. 1

    Data view publisher turns proper DataView query results into publishable Markdown so Obsidian Publish can display them on a website.

  2. 2

    Install and enable Data view publisher, and ensure the required Time Tracker plugin is installed.

  3. 3

    Configure a “Data view source” tag in plugin settings; only notes with that tag get refreshed.

  4. 4

    Insert a “data view publish block” via the command palette and paste a full DataView query into it.

  5. 5

    Run “Update data view publish blocks” to execute the query and inject results; Live Preview and Ctrl+S tend to trigger updates more reliably than Source-mode-only editing.

  6. 6

    Use Data view publisher for full DataView queries, not inline DataView; consider Metabond for inline real-time updates.

  7. 7

    Publishing becomes simpler when DataView queries live in dedicated notes marked with the source tag, letting website pages update through Obsidian Publish.

Highlights

Data view publisher solves Obsidian Publish’s plugin limitation by executing DataView inside Obsidian and injecting the results into the note as Markdown for publishing.
The configured “Data view source” tag is the switch that determines which notes get refreshed when running the update command.
Live Preview is repeatedly shown as the most dependable editing mode for getting refreshes to appear when “Update on Save” is enabled.
The plugin focuses on proper DataView queries; inline DataView remains unsupported, with Metabond suggested as an alternative.

Topics

Mentioned