How to Use Obsidian Dataview for Beginners: A Step-by-Step Guide with Copy-Paste Queries

---

TL;DR

• Dataview turns your Obsidian notes into a queryable database using simple, plain-English-style commands — no prior coding experience required.
• You add “labels” (metadata) to your notes using YAML frontmatter or inline fields, then write short queries to pull those notes into automatic lists and tables.
• This guide gives you copy-paste recipes for meeting logs, book trackers, and project hubs — working dashboards you can build in under 10 minutes.

---

Table of Contents

1. What is Dataview and Why is it a Game-Changer for Your Notes?
2. Step 1: Installing and Setting Up Dataview in 60 Seconds
3. The Secret Sauce: How to Tag Your Notes for Dataview
4. Your First Queries: From Zero to Automated Lists
5. Practical Recipes: 3 Dataview Dashboards You Can Build Today
6. Filtering and Sorting: Finding Exactly What You Need
7. Help! My Query Isn’t Working: Common Mistakes & Fixes
8. FAQ
9. Conclusion

---

What is Dataview and Why is it a Game-Changer for Your Notes? {#what-is-dataview}

Think of Dataview as an automatic librarian for your vault. You write notes the way you always have, but you attach small labels to them — a status, a date, a category. Dataview reads those labels and builds live indexes for you. Every time you add a new note, the index updates itself. You never manually maintain a list of your projects or meeting notes again.

Before Dataview: You have 200 notes sitting in folders. Finding every note tagged #project/alpha means either remembering where you filed things or running a search and hoping your naming was consistent that day.

After Dataview: One note — your “Project Alpha Hub” — shows a live table of every related note, its status, and when it was last modified. It updates the moment you create or change anything.

The three concrete wins Dataview delivers:

1. Automatic indexes. A note titled “Reading List” that always shows every book note in your vault, sorted by rating — without you touching it after setup.
2. Dynamic dashboards. A weekly review page that pulls every task marked incomplete across all notes, no manual gathering required.
3. Task tracking across files. A single view of every - [ ] checkbox in your entire vault, filterable by project or due date.

If you’re serious about building a real personal knowledge system, the concepts behind this kind of structured note-taking are laid out clearly in Building a Second Brain by Tiago Forte and How to Take Smart Notes by Sönke Ahrens — both worth reading alongside this guide.

---

Step 1: Installing and Setting Up Dataview in 60 Seconds {#installing-dataview}

Dataview is a community plugin, so you need to enable community plugins first.

Installation steps:

1. Open Obsidian. Go to Settings (gear icon, bottom-left).
2. Click Community plugins in the left sidebar.
3. If you see a “Safe mode” warning, click Turn on community plugins.
4. Click Browse.
5. In the search bar, type Dataview.
6. Click the result by blacksmithgu, then click Install.
7. After installation, click Enable.

That’s it — Dataview is running.

Two settings worth enabling immediately:

• Enable JavaScript Queries — This unlocks dataviewjs blocks, which give you more power when basic queries aren’t enough. Go to Settings → Dataview, and toggle this on. You won’t need it today, but you’ll want it later.
• Enable Inline Queries — This lets you run tiny queries inside a line of text, like embedding a live note count in a sentence. Also in Settings → Dataview.

Leave everything else at default. You can explore the other settings later, but these two are the ones beginners trip over when they follow a tutorial and something doesn’t work.

---

The Secret Sauce: How to Tag Your Notes for Dataview {#tagging-notes}

Dataview can only report what it can read. That means your notes need metadata — structured information that Dataview can find and filter. Think of metadata as sticky labels on a file folder.

There are two ways to add metadata.

Method 1: YAML Frontmatter (Recommended for Structured Notes)

YAML frontmatter sits at the very top of a note, between two sets of triple dashes. It’s the most reliable method and works with every Dataview query type.

---
title: "Q3 Marketing Meeting"
date: 2024-09-15
type: meeting
status: done
attendees:
  - Sarah
  - Dev team
tags:
  - meetings
  - marketing
---

Every line is a key: value pair. You define the keys — Dataview reads them. The names are yours to choose; just be consistent. If you call it status in one note and Status (capital S) in another, Dataview treats them as different fields.

Copy-paste template for a meeting note:

---
title: ""
date: 
type: meeting
project: ""
status: done
---

Method 2: Inline Fields (For Quick, On-the-Fly Labeling)

You can add metadata anywhere inside the body of a note using the format key:: value.

Today I finished reading **Atomic Habits**.

rating:: 5
status:: read
author:: James Clear
genre:: self-help

Inline fields are faster when you’re writing flow-first and want to drop in a data point without going back to the top. The double colon (::) is the signal Dataview looks for.

When to use which:

Method	Best for	Limitation
YAML frontmatter	Templates, structured note types	Must be at the top of the file
Inline fields	Casual notes, mid-paragraph data	Slightly less reliable with complex queries

Pick one method and stick with it per note type. Mixing both in the same note is valid but can get confusing fast.

---

Your First Queries: From Zero to Automated Lists {#first-queries}

A Dataview query lives inside a special code block. You open it with three backticks and the word dataview, write your query, and close with three backticks.

```dataview
LIST FROM #meetings
```

That’s the simplest possible query. It shows every note tagged #meetings as a clickable list.

The Three Building Blocks

Every Dataview query follows this pattern:

[WHAT to show] [WHERE to get it] [HOW to filter/sort it]

In actual syntax:

LIST / TABLE [fields]
FROM [source]
WHERE [condition]
SORT [field] [asc/desc]

Translating Plain English to Dataview Queries

What you want	Dataview query
Show all notes with a tag	LIST FROM #your-tag
Show all notes in a folder	LIST FROM "FolderName"
Show notes with a specific status	LIST FROM #projects WHERE status = "active"
Show a table with specific columns	TABLE author, status FROM #books
Show incomplete tasks across all notes	TASK WHERE !completed

Your First Table

```dataview
TABLE date, status, project
FROM #meetings
SORT date desc
```

This shows every meeting note as a table with three columns — date, status, and project — sorted with the newest at the top. If your meeting notes have YAML frontmatter with those exact field names, this works immediately after you paste it.

---

Practical Recipes: 3 Dataview Dashboards You Can Build Today {#practical-recipes}

Create a new note for each of these dashboards. Paste the frontmatter template and query, then start adding notes with the matching metadata.

Recipe 1: Meeting Notes Index

What it does: Automatically lists every meeting note from the past 30 days.

Create a YAML template for your meeting notes:

---
type: meeting
date: 2024-09-15
attendees: ""
project: ""
action-items: ""
---

Dashboard query:

```dataview
TABLE date, attendees, project
FROM #meetings OR "Meetings"
WHERE date >= date(today) - dur(30 days)
SORT date desc
```

Every new meeting note you create — drop it in your “Meetings” folder or tag it #meetings, fill in the frontmatter — and this table updates itself.

Recipe 2: Book Tracker Table

What it does: Tracks every book you’ve noted, with author, reading status, and your rating.

Frontmatter template for book notes:

---
type: book
author: ""
genre: ""
status: reading
rating: 
date-finished:
---

Dashboard query:

```dataview
TABLE author, genre, status, rating, date-finished
FROM "Books"
SORT rating desc
```

You’ll end up with a ranked reading list that updates the moment you change a rating or mark a book as finished. No spreadsheet needed.

Recipe 3: Project Hub

What it does: Pulls every note and open task related to one project into a single view.

```dataview
TABLE file.mtime as "Last Modified", status
FROM "Projects/Alpha"
SORT file.mtime desc
```

And below that, on the same hub note, add a task view:

```dataview
TASK
FROM "Projects/Alpha"
WHERE !completed
```

Now your Project Alpha hub shows every note in that folder and every open checkbox across all of them. This is the “dashboard in Obsidian” use case that most people are trying to build.

If you want to go deeper on building these kinds of systems properly, courses on PKM and Obsidian on Skillshare or Udemy cover vault architecture that makes these queries far more powerful.

---

Filtering and Sorting: Finding Exactly What You Need {#filtering-sorting}

The WHERE Clause

WHERE filters your results. Only notes that match the condition appear.

WHERE status = "in-progress"
WHERE rating >= 4
WHERE date > date(2024-01-01)
WHERE contains(tags, "work")

You can combine conditions:

WHERE status = "in-progress" AND project = "Alpha"
WHERE status = "done" OR status = "archived"

The SORT Clause

SORT controls order. asc = A to Z, oldest to newest. desc = Z to A, newest to oldest.

SORT date desc
SORT rating asc
SORT file.mtime desc

file.mtime is a built-in field Dataview creates for every note — it means “the time this file was last modified.” You don’t need to add it to your frontmatter.

A Complete, Practical Query

Here’s everything combined into one query that finds all active work projects, shows their due date and owner, and puts the most recently modified at the top:

```dataview
TABLE due-date, owner, status
FROM #projects
WHERE status = "active"
SORT file.mtime desc
```

Read it like a sentence: “Give me a table of due-date, owner, and status, from notes tagged #projects, but only show the ones where status equals active, and put the most recently changed ones first.”

---

Help! My Query Isn’t Working: Common Mistakes & Fixes {#troubleshooting}

Error 1: “Dataview: No results to show”

This is the most common issue. It means Dataview ran successfully but found zero matching notes.

Checklist:

• Does the tag in the query exactly match the tag in your notes? (#meetings vs #Meetings — case matters)
• Does the folder name in quotes exactly match, including capitalization? ("Books" vs "books")
• Did you save the note with the frontmatter before running the query?
• Is the field name in WHERE spelled identically to the field name in your YAML?

Quick test: Change FROM #your-tag to FROM "" (empty string means “entire vault”). If results appear, your tag or folder path is wrong.

Error 2: Query Block Renders as Plain Text

You’re missing the word dataview after the opening backticks, or the plugin isn’t enabled. Go back to Settings → Community plugins and confirm Dataview is toggled on.

Error 3: A Field Shows as “null” in Your Table

The field exists in your query but not in that note’s frontmatter. Either add the field to the note, or add WHERE field to your query to exclude notes that don’t have it.

Error 4: Folder Path Not Working

Folder paths in Dataview are case-sensitive and must match exactly. If your folder is Projects/Alpha Team, the query needs FROM "Projects/Alpha Team" — not from "projects/alpha team" or FROM "Projects/AlphaTeam".

Pro tip: In Obsidian, right-click the folder in the file explorer and check the exact name. Copy-paste it directly into your query.

Error 5: Date Comparisons Not Working

Your date field needs to be in YYYY-MM-DD format in the frontmatter. date: September 15, 2024 will not parse correctly. Use date: 2024-09-15.

---

Conclusion {#conclusion}

Dataview is not magic, but it’s close. The core workflow is straightforward: add consistent labels to your notes using YAML frontmatter, write a short query using the LIST / TABLE / FROM / WHERE / SORT structure, and let Dataview do the maintenance work for you.

Start small. Build the book tracker this week. Next week, set up the meeting index. Within a month you’ll have a vault that organizes itself, and you’ll wonder how you worked without it.

The three things that make the biggest difference early on: consistent field names in your frontmatter, putting notes in logical folders, and using the troubleshooting checklist when queries return nothing.

Ready to go further?

• Deepen your understanding of the PKM philosophy that makes Dataview genuinely useful: grab a copy of Building a Second Brain or How to Take Smart Notes.
• For structured, video-based learning on Obsidian and personal knowledge management, Skillshare and Udemy both have dedicated Obsidian courses that walk through advanced Dataview setups with real vault examples.
• If you want your organized vault available everywhere, Obsidian Sync is the official, end-to-end encrypted option — your Dataview dashboards work identically on every device.

Start with one query. Everything else follows from there.

---

Frequently Asked Questions

Q: Do I need to know how to code to use Dataview?

No. The basic query language (DQL) reads almost like plain English. The examples in this guide require zero programming background. The only “advanced” option — DataviewJS — uses JavaScript, but you can accomplish most real-world use cases without ever touching it.

Q: Will Dataview slow down my Obsidian vault?

On vaults under 1,000 notes, you won’t notice anything. On very large vaults (5,000+ notes), complex queries with no FROM filter — meaning they scan every file — can add a slight delay. Scoping your queries to specific folders or tags keeps things fast.

Q: What’s the difference between Dataview tags and Obsidian tags?

They’re the same tags. #meetings in your note body or frontmatter is the same tag Obsidian shows in the Tags panel. Dataview reads Obsidian’s native tags — you don’t need a separate system.

Q: Can I use Dataview with Obsidian Sync across devices?

Yes. Obsidian Sync syncs your entire vault including the Dataview plugin and all your notes. Your dashboards are fully functional on mobile, tablet, and any other device. The queries run locally on each device, not in the cloud.

Q: Why should I use YAML frontmatter instead of just relying on folders and tags?

Tags and folders answer “where is this note?” Frontmatter answers “what is this note about, and what are its properties?” A book note can be in a Books folder AND tagged #books — but only frontmatter can tell Dataview that this specific book has a rating of 4, was finished on March 3rd, and has a status of “read.” That’s what makes filtering and sorting actually useful.

Related Reading

• What is the Periodic Notes Plugin (And Why It’s a Game-Changer)
• What Are Obsidian Callouts (And Why They Are a Game-Changer)
• Why Your Daily Notes Need the Templater Plugin
• Why Your Theme is Your Most Important Writing Tool in Obsidian