Get AI summaries of any video or article — Sign up free
Obsidian - Data Conversion with ChatGPT thumbnail

Obsidian - Data Conversion with ChatGPT

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

Use ChatGPT for conversion only after providing the exact target Obsidian template, including required front matter “---” delimiters.

Briefing

Converting Pathfinder 2e (PF2e) stat blocks and items into Obsidian’s TTRPG stat block template format can be done quickly with ChatGPT—so long as the prompt includes the exact target template and the user iteratively corrects formatting mistakes. The payoff is substantial: instead of manually wrestling with YAML/front-matter syntax, a Dungeon Master can paste a monster (or even an NPC/item description) and get back a mostly usable Obsidian-ready block with the right structure for dice, actions, and encounter-style fields.

The workflow starts with the “official” conversion path: pull PF2e data from pf2e tools’ GitHub JSON files, then use a text converter to transform a stat block into JSON, and finally run it through the Homebrew converter to reach the Obsidian plugin’s expected format. That method works but involves multiple steps. The alternative—using ChatGPT—aims to collapse that effort into a conversational conversion.

ChatGPT’s early attempts often miss Obsidian’s strict syntax. Common failures include dropping the required front matter (the top “---” section), omitting the closing syntax at the end of the stat block, or outputting a different template variant than the one the user needs. The transcript shows a back-and-forth pattern: provide an example of the exact Obsidian template, paste a monster, request conversion into that specific format, then correct ChatGPT when it outputs the “wrong” structure. Over time, the model begins to follow the requested layout more reliably—especially when the user repeatedly anchors the conversation with the correct template and uses shorter inputs to reduce truncation.

A key practical limitation emerges: longer notes increase the chance of incomplete output, with ChatGPT sometimes stopping mid-block or failing to include the final closing lines. Even when the stat block is structurally correct, the content can still contain issues unrelated to formatting—such as duplicated monster data or mismatched HP values—so manual verification remains necessary.

Once the formatting is dialed in, the results look functional. A converted Web Loco stat block includes expected fields like perception, darkvision, languages, skills, speed, abilities, and action triggers, and it can be pasted into Obsidian notes with only light cleanup (like removing an extra “copy code” wrapper). The same approach works for other creatures (including an Owlbear and a Goblin Commando) when the prompt explicitly references the correct template and the conversation context is kept consistent.

The method extends beyond monsters. ChatGPT can convert magic items into the same Obsidian-compatible format—for example, turning a “bird feather token” into a structured item block with activation timing and rule text—though rule details may require review (such as activation duration or usage handling). Finally, the transcript demonstrates broader NPC generation: ChatGPT can draft a shopkeeper NPC with a list of items for sale and then format the inventory in a way that could be imported into Obsidian, potentially saving significant writing time.

Overall, ChatGPT is positioned as a time-saver for data conversion and content structuring in Obsidian, but it’s not plug-and-play. The conversion quality improves with template “training” through conversation, careful prompt specificity, and post-generation cleanup and validation.

Cornell Notes

ChatGPT can convert PF2e monsters and items into Obsidian’s TTRPG stat block template format, reducing manual YAML/front-matter work. The biggest success factor is providing the exact target template (including required “---” front matter) and correcting ChatGPT when it outputs a different variant. Output quality improves when inputs are shorter, since long notes increase the chance of truncation or missing closing syntax. Even when formatting is right, content still needs verification for rule accuracy and potential duplication issues. With an ongoing conversation, the model tends to follow the agreed structure more consistently over repeated conversions.

Why does ChatGPT sometimes produce “almost right” Obsidian stat blocks, and what specific formatting elements tend to fail?

The model often outputs a different template variant than the one Obsidian expects. In the transcript, failures include missing the required front matter delimiters at the top (the “---” block), omitting the closing syntax at the end of the stat block, and wrapping the output in a code block that changes how the “---” lines appear. Even when the core fields (like HP, abilities, and actions) are present, missing front matter or end delimiters can break the plugin’s parsing.

What prompt strategy makes conversions more reliable over multiple attempts?

Reliability improves when the user anchors the conversation with the exact target template and explicitly asks for conversion into that format. The transcript shows repeated correction: after ChatGPT outputs the wrong structure, the user pastes the correct template again and requests conversion using that template. Once the model “remembers” the agreed format in the ongoing chat, it starts producing blocks that include the correct front matter and stat block section more consistently.

How do input length and truncation affect results?

Longer notes increase the chance ChatGPT stops early or drops the final lines needed to close the stat block. The transcript notes that the model sometimes halts on really long notes, leading to incomplete YAML. Shorter inputs and repeated template anchoring reduce these failures and make it easier to spot where cleanup is needed.

What kinds of errors can be unrelated to formatting, even when the YAML looks correct?

The transcript highlights duplication and rule-value issues that aren’t caused by template syntax. For example, HP values can be wrong or duplicated due to underlying data/tool behavior, not just ChatGPT’s formatting. That means users still need to validate the generated stat block against expected PF2e rules and their own data sources.

How does the approach extend from monsters to items and NPC content?

Beyond creatures, ChatGPT can convert magic items into the same Obsidian-compatible structured format (including activation timing and rule text), though some rule details may be slightly off and require review. It also can generate NPCs like a shopkeeper with a list of items for sale and then format that inventory for Obsidian import—useful for speeding up campaign prep.

What does the transcript suggest about the “official” conversion pipeline versus the ChatGPT method?

The official pipeline uses pf2e tools data (JSON from GitHub), then a text converter to produce JSON, followed by a Homebrew converter to reach the Obsidian plugin format. It works but involves multiple steps. ChatGPT aims to collapse that into a conversational conversion, trading speed for the need to correct syntax and verify content.

Review Questions

  1. When ChatGPT omits the front matter delimiters or the closing syntax, what exact part of the template should be re-anchored in the prompt to fix parsing?
  2. What two categories of problems can appear in generated stat blocks—one formatting-related and one content-related—and how would you check for each?
  3. Why might shorter monster inputs produce more complete conversions than very long ones?

Key Points

  1. 1

    Use ChatGPT for conversion only after providing the exact target Obsidian template, including required front matter “---” delimiters.

  2. 2

    Expect formatting failures early (missing front matter, missing closing syntax, wrong template variant) and correct them by pasting the correct template again.

  3. 3

    Keep inputs shorter to reduce truncation risk; long notes increase the chance the stat block ends prematurely.

  4. 4

    Always validate generated content for rule accuracy and duplication issues, even when YAML structure looks correct.

  5. 5

    The same template-anchored approach can convert monsters, magic items, and structured NPC inventory lists into Obsidian-ready blocks.

  6. 6

    The official PF2e tools → text converter → Homebrew converter pipeline remains a reliable multi-step alternative when precision matters more than speed.

Highlights

ChatGPT can produce Obsidian-compatible stat blocks with dice/actions and structured fields, but only after the conversation is anchored to the exact template variant.
Missing the “---” front matter or the closing syntax is a recurring failure mode; re-supplying the correct template fixes it.
Longer inputs increase the odds of incomplete output, so shorter pastes improve reliability.
Even with correct formatting, HP/rule duplication issues can still appear and require manual verification.
The workflow scales from monsters to magic items and NPC shop inventories, potentially cutting prep time dramatically.

Topics

  • Obsidian TTRPG stat blocks
  • PF2e data conversion
  • ChatGPT templating
  • YAML front matter
  • NPC and item generation

Mentioned