Get AI summaries of any video or article — Sign up free
Obsidian - CSV JSON Importer thumbnail

Obsidian - CSV JSON Importer

Josh Plunkett·
4 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

Install and enable the “json csv importer” plugin via Obsidian’s Community Plugins settings.

Briefing

Obsidian’s CSV/JSON Importer (by “Farlings”) turns spreadsheets into structured Obsidian notes in bulk—without manual copy/paste—by pairing a CSV (or JSON) data file with a simple Handlebars template that maps spreadsheet columns to note fields. The payoff is immediate: one row in a CSV becomes one new note, automatically named and populated with tags, text, and even formatted callouts.

Setup starts in Obsidian under Settings → Community Plugins → Browse, searching for “json csv importer” and installing/enabling the plugin. The installation includes a Readme that points to Handlebars template guidance (handlebarsjs.com), emphasizing that the templates can be simple for basic imports but also support more advanced templating patterns.

The workflow then becomes a three-part recipe. First, create or choose a destination folder in the vault (the demo uses an “import test” folder). Second, prepare a source file—CSV for the easiest path. CSV files carry data as plain text with no formatting, so the key requirement is the header row: the first row must contain column names that the template will reference.

Third, create a Handlebars template note inside Obsidian. The template is just a normal markdown note, but it includes placeholders in double curly braces that match the CSV column headers. In the demo, the template includes fields like name, price, and rarity, and it also demonstrates flexibility by mapping those values into a formatted table and a callout block. Once the template is written, the importer uses it as the “blueprint” for every generated note.

With the CSV and template ready, the importer runs from the plugin interface: select the CSV file, select the Handlebars template file from the vault (stored under Templates in the demo), choose which column should become the note name (the demo uses the “name” column), and select the output folder. After clicking import, the previously empty folder fills with newly created notes—one per CSV row—automatically populated with the mapped fields. The resulting notes show tags, the imported name, price, rarity, and the callout content working as intended.

Although the demo focuses on CSV, the importer also supports JSON. JSON can be more complex because it often contains nested structures (for example, a parent object with an “attributes” sub-object holding strength, dexterity, and constitution). In those cases, the Handlebars template must be written to access sub-layers, which requires consulting the plugin’s Readme. The demo notes that JSON can be made to work, but accuracy may take extra iteration.

Overall, the method is positioned as a practical way to ingest bulk datasets—such as large collections of D&D items, NPCs, monsters, or SRD content—into Obsidian notes quickly, especially for people who want an efficient import path without needing SQL or other data tooling.

Cornell Notes

Obsidian’s CSV/JSON Importer uses a Handlebars template to convert spreadsheet rows into individual Obsidian notes. A CSV file must include a header row with column names, since those names are referenced inside the template using double-curly-brace placeholders. When the importer runs, it creates one note per CSV line, naming each note from a chosen column (like “name”) and filling in tags, text, tables, and callouts from the template. JSON imports are supported too, but nested data structures require template adjustments based on the plugin’s Readme. This workflow makes bulk content ingestion—items, NPCs, monsters, SRD data—much faster than manual copy/paste.

What are the three core ingredients needed to bulk-import data into Obsidian with the CSV/JSON Importer?

The process relies on (1) a destination folder in the vault (e.g., “import test”), (2) a source data file—CSV for the simplest case—where the first row contains column headers, and (3) a Handlebars template note stored in the vault. The template uses placeholders like {{ColumnName}} that match the CSV header names, telling the importer how to map each row’s fields into markdown content.

Why does the CSV header row matter so much in this workflow?

The importer’s template placeholders must match the CSV column names. Because CSV is plain text with no formatting, the header row becomes the contract between the spreadsheet and the template. If the header names don’t match what the template expects, the placeholders won’t populate correctly.

How does the Handlebars template control what ends up in each generated note?

The template is a normal markdown note with embedded Handlebars placeholders in double curly braces. In the demo, placeholders are inserted for fields such as name, price, and rarity, and those values are placed into structured markdown elements—like tags, a table, and a callout block. The importer repeats this template for every row, substituting the placeholders with that row’s values.

How does the importer decide each new note’s filename?

During import, the user selects which CSV column should be used as the note name. In the demo, the “name” column is chosen, so each generated note is named after the corresponding magic item name. This makes the resulting notes easy to browse alphabetically and search.

What makes JSON imports harder than CSV imports in this setup?

JSON often includes nested data. For example, a parent object might contain an “attributes” object, which then contains fields like strength, dexterity, and constitution. To import those values correctly, the Handlebars template must reference sub-layers, which requires reading the importer’s Readme and adjusting the template accordingly.

What kinds of datasets become practical to import using this method?

Any dataset available as a spreadsheet can be converted into CSV and imported. The demo suggests using online tables for D&D-style content—magic items, NPC lists, monster collections, or SRD data—so thousands of entries can be turned into individual Obsidian notes quickly rather than manually.

Review Questions

  1. If a CSV column header is changed (e.g., “rarity” becomes “item_rarity”), what must be updated in the Handlebars template to keep imports working?
  2. How would you structure a Handlebars template to place imported values into both a table and a callout block?
  3. What additional steps are typically needed to import nested JSON data compared with flat CSV data?

Key Points

  1. 1

    Install and enable the “json csv importer” plugin via Obsidian’s Community Plugins settings.

  2. 2

    Prepare a CSV with a correct header row; column names must match the Handlebars placeholders.

  3. 3

    Create a Handlebars template note in Obsidian using {{ColumnName}} placeholders to map fields into markdown.

  4. 4

    Choose a CSV column to use as the generated note name so each row becomes a uniquely named note.

  5. 5

    Run the importer to generate one note per CSV row into a selected destination folder.

  6. 6

    Use the plugin’s Readme for JSON imports, since nested structures require template access to sub-layers.

  7. 7

    Bulk-importing spreadsheet datasets (items, NPCs, monsters, SRD content) eliminates repetitive copy/paste work.

Highlights

A single CSV row becomes a single Obsidian note, automatically populated from a Handlebars template.
The template is just markdown plus {{ColumnName}} placeholders that mirror the CSV header row.
Callouts and tables can be filled dynamically from spreadsheet data during import.
JSON support exists, but nested objects demand careful template mapping using the Readme.

Topics