# Table of Contents - [Getting Started | QuickAdd](#getting-started-quickadd) - [Coming from Templater | QuickAdd](#coming-from-templater-quickadd) - [Settings | QuickAdd](#settings-quickadd) - [Template | QuickAdd](#template-quickadd) - [Share QuickAdd Packages | QuickAdd](#share-quickadd-packages-quickadd) - [Capture | QuickAdd](#capture-quickadd) - [Unknown](#unknown) - [Multis | QuickAdd](#multis-quickadd) - [Apply Template to Note | QuickAdd](#apply-template-to-note-quickadd) - [Controlling Prompts | QuickAdd](#controlling-prompts-quickadd) - [Variables and data flow | QuickAdd](#variables-and-data-flow-quickadd) - [Global Variables | QuickAdd](#global-variables-quickadd) - [Macros | QuickAdd](#macros-quickadd) - [Format syntax | QuickAdd](#format-syntax-quickadd) - [Suggester System | QuickAdd](#suggester-system-quickadd) - [Examples | QuickAdd](#examples-quickadd) - [Inline scripts | QuickAdd](#inline-scripts-quickadd) - [Book Finder Script | QuickAdd](#book-finder-script-quickadd) - [AI Assistant Reference | QuickAdd](#ai-assistant-reference-quickadd) - [Movie & Series Script | QuickAdd](#movie-series-script-quickadd) - [Capture: Add entries to your daily note | QuickAdd](#capture-add-entries-to-your-daily-note-quickadd) - [Capture: Add a Task to a Kanban Board | QuickAdd](#capture-add-a-task-to-a-kanban-board-quickadd) - [Template Property Types (Beta) | QuickAdd](#template-property-types-beta-quickadd) - [Template: Add an Inbox Item | QuickAdd](#template-add-an-inbox-item-quickadd) - [Capture: Fetch Tasks From Todoist | QuickAdd](#capture-fetch-tasks-from-todoist-quickadd) - [Capture: Canvas Capture | QuickAdd](#capture-canvas-capture-quickadd) - [Template: Create an MOC Note with a Link Dashboard | QuickAdd](#template-create-an-moc-note-with-a-link-dashboard-quickadd) - [Macro: Log book to daily journal | QuickAdd](#macro-log-book-to-daily-journal-quickadd) - [Zettelizer | QuickAdd](#zettelizer-quickadd) - [Macro: Change properties in your daily notes (requires MetaEdit) | QuickAdd](#macro-change-properties-in-your-daily-notes-requires-metaedit-quickadd) - [Toggl Manager | QuickAdd](#toggl-manager-quickadd) - [Macro: Move notes with a tag to a folder | QuickAdd](#macro-move-notes-with-a-tag-to-a-folder-quickadd) - [API Overview | QuickAdd](#api-overview-quickadd) - [Migrate Dataview Properties to Frontmatter | QuickAdd](#migrate-dataview-properties-to-frontmatter-quickadd) - [Capture: Insert a Related Notes Base into an MOC Note | QuickAdd](#capture-insert-a-related-notes-base-into-an-moc-note-quickadd) - [Scripting Overview | QuickAdd](#scripting-overview-quickadd) - [QuickAdd API | QuickAdd](#quickadd-api-quickadd) - [User Scripts | QuickAdd](#user-scripts-quickadd) - [Macro: Add location long-lat from address | QuickAdd](#macro-add-location-long-lat-from-address-quickadd) - [Template - My Book Notes template | QuickAdd](#template-my-book-notes-template-quickadd) - [Scripts with user settings | QuickAdd](#scripts-with-user-settings-quickadd) - [FAQ | QuickAdd](#faq-quickadd) - [Manual Installation | QuickAdd](#manual-installation-quickadd) - [Open QuickAdd from a URI | QuickAdd](#open-quickadd-from-a-uri-quickadd) - [QuickAdd CLI | QuickAdd](#quickadd-cli-quickadd) - [Open QuickAdd from your Desktop | QuickAdd](#open-quickadd-from-your-desktop-quickadd) - [One-page Inputs | QuickAdd](#one-page-inputs-quickadd) - [Trigger QuickAdd from outside Obsidian | QuickAdd](#trigger-quickadd-from-outside-obsidian-quickadd) - [Unknown](#unknown) - [Unknown](#unknown) - [Unknown](#unknown) - [Unknown](#unknown) - [Unknown](#unknown) - [Unknown](#unknown) - [Unknown](#unknown) - [Unknown](#unknown) - [Unknown](#unknown) - [Unknown](#unknown) - [Unknown](#unknown) - [Unknown](#unknown) - [Unknown](#unknown) - [Unknown](#unknown) - [Unknown](#unknown) - [Unknown](#unknown) - [Unknown](#unknown) - [Unknown](#unknown) - [Unknown](#unknown) - [Unknown](#unknown) - [Unknown](#unknown) - [Unknown](#unknown) - [Unknown](#unknown) - [Unknown](#unknown) - [Unknown](#unknown) - [Unknown](#unknown) - [Unknown](#unknown) - [Unknown](#unknown) - [Unknown](#unknown) - [Unknown](#unknown) - [Unknown](#unknown) - [Unknown](#unknown) - [Unknown](#unknown) - [Unknown](#unknown) - [Unknown](#unknown) - [Unknown](#unknown) - [Unknown](#unknown) - [Unknown](#unknown) - [Unknown](#unknown) - [Unknown](#unknown) - [Unknown](#unknown) - [Unknown](#unknown) - [Unknown](#unknown) - [Unknown](#unknown) - [Unknown](#unknown) - [Unknown](#unknown) - [Macro: Capture to Inbox with GPS | QuickAdd](#macro-capture-to-inbox-with-gps-quickadd) - [Unknown](#unknown) --- # Getting Started | QuickAdd [Skip to content](https://quickadd.obsidian.guide/docs/#_top) Getting Started =============== Copy Markdown[View as Markdown](https://quickadd.obsidian.guide/docs.md) [Open in Claude](https://claude.ai/new?q=Read%20https%3A%2F%2Fquickadd.obsidian.guide%2Fdocs.md%20so%20I%20can%20ask%20questions%20about%20it.) [Open in ChatGPT](https://chatgpt.com/?hints=search&q=Read%20https%3A%2F%2Fquickadd.obsidian.guide%2Fdocs.md%20so%20I%20can%20ask%20questions%20about%20it.) QuickAdd turns your repetitive Obsidian actions - creating a note from a template, logging a line to your journal, running a script - into single commands you trigger with a hotkey. Set a workflow up once, then run it in a keystroke from anywhere in your vault. New here? Build your [first workflow](https://quickadd.obsidian.guide/docs/#first-workflow) below in about a minute. Install QuickAdd ---------------- [Section titled “Install QuickAdd”](https://quickadd.obsidian.guide/docs/#install-quickadd) Install QuickAdd from Obsidian’s Community Plugins browser, then enable it. If you cannot use the plugin browser, follow the [manual installation guide](https://quickadd.obsidian.guide/docs/ManualInstallation/) . Choose the right choice type ---------------------------- [Section titled “Choose the right choice type”](https://quickadd.obsidian.guide/docs/#choose-the-right-choice-type) | If you want to… | Use this | Start here | | --- | --- | --- | | Create a new note from a reusable file | Template choice | [Template Choices](https://quickadd.obsidian.guide/docs/Choices/TemplateChoice/) | | Append text to a journal, log, task list, or existing file | Capture choice | [Capture Choices](https://quickadd.obsidian.guide/docs/Choices/CaptureChoice/) | | Run one or more Obsidian commands, scripts, or choices | Macro choice | [Macro Choices](https://quickadd.obsidian.guide/docs/Choices/MacroChoice/) | | Group choices into a nested menu | Multi choice | [Multi Choices](https://quickadd.obsidian.guide/docs/Choices/MultiChoice/) | | Share configured workflows across vaults | Package | [Share QuickAdd Packages](https://quickadd.obsidian.guide/docs/Choices/Packages/) | Most workflows start with either a Template choice or a Capture choice. Add a Macro choice when you need scripting, multiple steps, or data from another plugin or API. First workflow -------------- [Section titled “First workflow”](https://quickadd.obsidian.guide/docs/#first-workflow) Let’s build a capture that adds a timestamped line to your daily journal. It takes about a minute. 1. Open **Settings → QuickAdd**. Type a name like `Add to journal`, choose **Capture** in the dropdown, and click **Add Choice**. 2. Click the gear (⚙) next to your new choice to open its settings. 3. Set **Capture To** to `Journal/{{DATE}}.md` - the note today’s entries land in. 4. Turn on **Capture format** and enter `- {{DATE:HH:mm}} {{VALUE}}` - the shape of one entry. 5. Close the settings. Open the command palette (Ctrl/Cmd+P), run **QuickAdd: Run**, pick `Add to journal`, and type your entry. QuickAdd writes a line like `- 09:42 Standup moved to Wednesday` into today’s journal note, without opening it. Once it works the way you want, give it a hotkey from the ⚡ icon next to the choice or Obsidian’s Hotkeys settings. The `{{DATE}}` and `{{VALUE}}` above are [format syntax](https://quickadd.obsidian.guide/docs/FormatSyntax/) : placeholders QuickAdd fills in each time you run the choice. There are placeholders for dates, your answers, links, clipboard content, and more. When a prompt asks you for text, the [suggester system](https://quickadd.obsidian.guide/docs/SuggesterSystem/) lets you type `[[` or `#` to pull in a file, tag, or heading from your vault.\ \ Common paths\ ------------\ \ [Section titled “Common paths”](https://quickadd.obsidian.guide/docs/#common-paths)\ \ ### I want examples first\ \ [Section titled “I want examples first”](https://quickadd.obsidian.guide/docs/#i-want-examples-first)\ \ Use the [examples overview](https://quickadd.obsidian.guide/docs/Examples/)\ to pick a complete workflow by choice type, difficulty, prerequisites, and outcome.\ \ Good first examples:\ \ * [Capture: Add entries to your daily note](https://quickadd.obsidian.guide/docs/Examples/Capture_ToDailyNote/)\ \ * [Template: Add an Inbox Item](https://quickadd.obsidian.guide/docs/Examples/Template_AddAnInboxItem/)\ \ * [Macro: Book Finder](https://quickadd.obsidian.guide/docs/Examples/Macro_BookFinder/)\ \ * [Capture: Canvas Capture](https://quickadd.obsidian.guide/docs/Examples/Capture_CanvasCapture/)\ \ \ ### I want to automate with scripts\ \ [Section titled “I want to automate with scripts”](https://quickadd.obsidian.guide/docs/#i-want-to-automate-with-scripts)\ \ Start with the [scripting overview](https://quickadd.obsidian.guide/docs/Advanced/ScriptingGuide/)\ , then move to [User Scripts](https://quickadd.obsidian.guide/docs/UserScripts/)\ and the [QuickAdd API reference](https://quickadd.obsidian.guide/docs/QuickAddAPI/)\ when you need exact method details.\ \ ### I want to call QuickAdd from outside Obsidian\ \ [Section titled “I want to call QuickAdd from outside Obsidian”](https://quickadd.obsidian.guide/docs/#i-want-to-call-quickadd-from-outside-obsidian)\ \ Use [Obsidian URI](https://quickadd.obsidian.guide/docs/Advanced/ObsidianUri/)\ for URI-triggered workflows, or the [QuickAdd CLI](https://quickadd.obsidian.guide/docs/Advanced/CLI/)\ for shell scripts and external automation. --- # Coming from Templater | QuickAdd [Skip to content](https://quickadd.obsidian.guide/docs/ComingFromTemplater/#_top) Coming from Templater ===================== Copy Markdown[View as Markdown](https://quickadd.obsidian.guide/docs/ComingFromTemplater.md) [Open in Claude](https://claude.ai/new?q=Read%20https%3A%2F%2Fquickadd.obsidian.guide%2Fdocs%2FComingFromTemplater.md%20so%20I%20can%20ask%20questions%20about%20it.) [Open in ChatGPT](https://chatgpt.com/?hints=search&q=Read%20https%3A%2F%2Fquickadd.obsidian.guide%2Fdocs%2FComingFromTemplater.md%20so%20I%20can%20ask%20questions%20about%20it.) If you built your note workflows around the Templater plugin, this page maps each familiar job to the QuickAdd-native way to do it. Every pattern below runs on QuickAdd alone: one engine owns your prompts, dates, and file creation, which is what keeps you clear of double prompts and half-rendered template syntax (see [common migration snags](https://quickadd.obsidian.guide/docs/ComingFromTemplater/#common-migration-snags) ). New to QuickAdd entirely? Start with [Getting Started](https://quickadd.obsidian.guide/docs/) for the choice types, then come back here for the mappings. Point QuickAdd at your template folder -------------------------------------- [Section titled “Point QuickAdd at your template folder”](https://quickadd.obsidian.guide/docs/ComingFromTemplater/#point-quickadd-at-your-template-folder) You don’t need to move or rewrite your template files to start. Add your existing template folder(s) under **Template folder paths** in [Settings → Templates & properties](https://quickadd.obsidian.guide/docs/Settings/#templates--properties) . That single step powers: * the **QuickAdd: New note from template** command, which lists every template in those folders and prompts for the new note’s name - no per-template setup; * the **QuickAdd: Apply template to active note** command, whose picker offers those template files too; * template-path autocomplete when you configure choices. Make a [Template choice](https://quickadd.obsidian.guide/docs/Choices/TemplateChoice/) for the templates that deserve their own hotkey, a fixed destination folder, or a file name format. The quick map ------------- [Section titled “The quick map”](https://quickadd.obsidian.guide/docs/ComingFromTemplater/#the-quick-map) The left column names the job; the middle names the Templater expression you may know it by (as a landmark only - the QuickAdd patterns don’t use or require it). | The job | You may know it as | The QuickAdd way | | --- | --- | --- | | Insert the note’s title | `tp.file.title` | [`{{TITLE}}`](https://quickadd.obsidian.guide/docs/FormatSyntax/#title) | | Today’s date, any format | `tp.date.now` | [`{{DATE:YYYY-MM-DD}}`](https://quickadd.obsidian.guide/docs/FormatSyntax/#date-format)
, offsets like `{{DATE+7}}` | | Ask for a date in plain language | `tp.system.prompt` | [`{{VDATE:due,YYYY-MM-DD}}`](https://quickadd.obsidian.guide/docs/FormatSyntax/#vdate)
- natural language built in | | Prompt for text | `tp.system.prompt` | [`{{VALUE:name}}`](https://quickadd.obsidian.guide/docs/FormatSyntax/#named-value) | | Pick from a list | `tp.system.suggester` | [`{{VALUE:Option A,Option B}}`](https://quickadd.obsidian.guide/docs/FormatSyntax/#named-value)
, [`{{FIELD:...}}`](https://quickadd.obsidian.guide/docs/FormatSyntax/#field)
, [`{{FILE:...}}`](https://quickadd.obsidian.guide/docs/FormatSyntax/#file) | | Include one template in another | `tp.file.include` | [`{{TEMPLATE:Templates/Partial.md}}`](https://quickadd.obsidian.guide/docs/FormatSyntax/#template) | | Apply a template to an existing note | the insert template command | [Apply template to active note](https://quickadd.obsidian.guide/docs/ApplyTemplateToNote/) | | Insert the clipboard | `tp.system.clipboard` | [`{{CLIPBOARD}}`](https://quickadd.obsidian.guide/docs/FormatSyntax/#clipboard) | | Insert the selected text | `tp.selection` | [`{{SELECTED}}`](https://quickadd.obsidian.guide/docs/FormatSyntax/#selected) | | Reuse a property from the note you’re in | `tp.frontmatter` | [`{{FIELD:project\|default-from:active}}`](https://quickadd.obsidian.guide/docs/FormatSyntax/#field-default-from-active)
; to re-render a value you prompted for, just [repeat `{{VALUE:name}}`](https://quickadd.obsidian.guide/docs/ComingFromTemplater/#prompt-once-reuse-everywhere) | | Link back to the note you came from | `tp.file.path` workarounds | [`{{LINKCURRENT}}`](https://quickadd.obsidian.guide/docs/FormatSyntax/#linkcurrent)
(a link), [`{{FILENAMECURRENT}}`](https://quickadd.obsidian.guide/docs/FormatSyntax/#filenamecurrent)
(raw name, for embeds like `![[{{FILENAMECURRENT}}#Heading]]`), [`{{LINKSECTION}}`](https://quickadd.obsidian.guide/docs/FormatSyntax/#linksection)
(link to the heading you’re in) | | Run JavaScript | `tp.user` | [Inline scripts](https://quickadd.obsidian.guide/docs/InlineScripts/)
, [user scripts in macros](https://quickadd.obsidian.guide/docs/Choices/MacroChoice/)
, [`{{MACRO:...}}`](https://quickadd.obsidian.guide/docs/FormatSyntax/#macro) | | Folder templates | folder templates | No automatic equivalent - see [Templates chosen by folder](https://quickadd.obsidian.guide/docs/ComingFromTemplater/#templates-chosen-by-folder) | | Cursor marker in a template | `tp.file.cursor` | No direct equivalent - see [Where the cursor lands](https://quickadd.obsidian.guide/docs/ComingFromTemplater/#where-the-cursor-lands) | Create new notes from templates ------------------------------- [Section titled “Create new notes from templates”](https://quickadd.obsidian.guide/docs/ComingFromTemplater/#create-new-notes-from-templates) A [Template choice](https://quickadd.obsidian.guide/docs/Choices/TemplateChoice/) creates a note from a template file, with a configurable destination folder, file name format, link insertion, and open behavior. QuickAdd resolves every token - prompts included - before the note is created, so the finished note is plain text from its first moment. To position user input at an exact spot in the new note, put the token exactly where the text belongs. One named value can drive both the file name and the body: File name format: `{{VALUE:topic}}` ---type: meeting---# {{TITLE}} Topic: {{VALUE:topic}}Date: {{DATE:YYYY-MM-DD}} You are asked for `topic` once; the answer becomes the file name and fills the body, and `{{TITLE}}` renders the final file name. Add to existing notes --------------------- [Section titled “Add to existing notes”](https://quickadd.obsidian.guide/docs/ComingFromTemplater/#add-to-existing-notes) ### Shared template content in new and existing notes [Section titled “Shared template content in new and existing notes”](https://quickadd.obsidian.guide/docs/ComingFromTemplater/#shared-template-content-in-new-and-existing-notes) Keep one template file and use it both ways - no parallel template sets: * **New notes**: point a Template choice at it, or include it inside a bigger template with [`{{TEMPLATE:Templates/Partial.md}}`](https://quickadd.obsidian.guide/docs/FormatSyntax/#template) . * **Existing notes**: run **QuickAdd: Apply template to active note** (also in a file’s right-click menu). You pick the template and where it goes - cursor, top, bottom, or replace. For the insert modes, the template’s frontmatter is merged into the note’s existing frontmatter, with the note’s own values winning (replace overwrites the whole note, frontmatter included). See [Apply Template to Note](https://quickadd.obsidian.guide/docs/ApplyTemplateToNote/) . A [Capture choice](https://quickadd.obsidian.guide/docs/Choices/CaptureChoice/) whose format is `{{TEMPLATE:Templates/Partial.md}}` also inserts that shared content into a target note. Prefer it for body-only snippets: a capture inserts the template text as-is, so a template that starts with its own `---` frontmatter block ends up as a literal second block instead of being merged. When the shared content carries frontmatter, use **Apply template to active note**. ### Today’s daily note [Section titled “Today’s daily note”](https://quickadd.obsidian.guide/docs/ComingFromTemplater/#todays-daily-note) Appending to today’s note is a Capture choice with a date-formatted target path - the file doesn’t have to exist beforehand: * **Capture to**: `Daily/{{DATE}}.md` * **Create file if it doesn’t exist**, with your daily template * **Insert after**: `## Log`, with **Create line if not found** * **Capture format**: `- {{VALUE}}` Say today is 2026-07-06: running it and typing `did a thing` creates `Daily/2026-07-06.md` from the template on first capture and appends `- did a thing` under `## Log` - one hotkey, with or without an existing note. For a step-by-step walkthrough with variations, see [Capture: Add entries to your daily note](https://quickadd.obsidian.guide/docs/Examples/Capture_ToDailyNote/) ; [Capture choices](https://quickadd.obsidian.guide/docs/Choices/CaptureChoice/) covers every target and position option. Templates chosen by folder -------------------------- [Section titled “Templates chosen by folder”](https://quickadd.obsidian.guide/docs/ComingFromTemplater/#templates-chosen-by-folder) QuickAdd does not watch folders: nothing runs automatically when a note appears in a folder, no matter how it was created. What it offers instead is explicit and per-choice: * **One Template choice per destination.** Set **New note location** to **In a specific folder** and name the choice after the destination (“New person”, “New project”). Each gets its own command and can get its own hotkey. * **One choice, several folders.** List multiple folders on the choice (optionally **Include subfolders**) and QuickAdd asks which one at run time. * **Dynamic paths.** Both the template path and the folder path accept [format syntax](https://quickadd.obsidian.guide/docs/FormatSyntax/) , and one named value can drive both. A choice with template path `Templates/{{VALUE:kind}}.md` and folder path `{{VALUE:kind}}s` asks for `kind` once - answering `Person` creates the note from `Templates/Person.md` in the `Persons` folder, keeping the whole folder-to-template mapping in a single choice. * **No setup at all**: the **New note from template** command picks any template from your template folder and creates the note in Obsidian’s default location. Dates without another plugin ---------------------------- [Section titled “Dates without another plugin”](https://quickadd.obsidian.guide/docs/ComingFromTemplater/#dates-without-another-plugin) `{{DATE}}` renders today (`YYYY-MM-DD` by default), `{{DATE:}}` takes any [Moment format](https://momentjs.com/docs/#/displaying/format/) , and offsets travel in days: `{{DATE+7}}`, `{{DATE:gggg-[W]WW+7}}`. Snap to period boundaries with [`|startof:` / `|endof:`](https://quickadd.obsidian.guide/docs/FormatSyntax/#date-snap) , for example `{{DATE:YYYY-MM|startof:week}}` for weekly notes that file under the month the week belongs to. For dates you enter, [`{{VDATE:name,format}}`](https://quickadd.obsidian.guide/docs/FormatSyntax/#vdate) understands natural language out of the box - no companion plugin. Type `tomorrow`, `next friday`, or `in two weeks`. Enter the date once, render it many times: Due: {{VDATE:due,YYYY-MM-DD}}Week: {{VDATE:due,gggg-[W]WW}} Typing `tomorrow` fills both lines from one prompt - with 2026-07-06 as today, that’s `Due: 2026-07-07` and `Week: 2026-W28`. There is no token for a file’s creation or modification date - reach for a [script](https://quickadd.obsidian.guide/docs/ComingFromTemplater/#run-scripts) if you need those. Prompt once, reuse everywhere ----------------------------- [Section titled “Prompt once, reuse everywhere”](https://quickadd.obsidian.guide/docs/ComingFromTemplater/#prompt-once-reuse-everywhere) Named values are shared across an entire run. `{{VALUE:topic}}` in the file name, the template body, and any other step of the same run all resolve from a single prompt - the mechanism behind the [Template choice example above](https://quickadd.obsidian.guide/docs/ComingFromTemplater/#create-new-notes-from-templates) . That sharing spans [Macro choice](https://quickadd.obsidian.guide/docs/Choices/MacroChoice/) steps too. A classic two-step flow - log a task in today’s daily note and create its note - is a macro of two choices sharing one name: 1. A Capture choice into `Daily/{{DATE}}.md` with the format `- [ ] [[{{VALUE:task}}]]` 2. A Template choice with file name format `{{VALUE:task}}` creating the note in your `Tasks` folder You type the task name once. Scripts join the same pool: anything a script assigns to `params.variables.task` is what `{{VALUE:task}}` resolves to in later steps - see the [scripting guide](https://quickadd.obsidian.guide/docs/Advanced/ScriptingGuide/) . To gather every prompt on a single form up front instead of one dialog at a time, enable [one-page input](https://quickadd.obsidian.guide/docs/Advanced/onePageInputs/) - and see [Controlling Prompts](https://quickadd.obsidian.guide/docs/ControllingPrompts/) for everything about prompt order, labels, defaults, and skipping. Where the cursor lands ---------------------- [Section titled “Where the cursor lands”](https://quickadd.obsidian.guide/docs/ComingFromTemplater/#where-the-cursor-lands) QuickAdd has no in-template cursor marker of its own - you can’t mark an arbitrary spot in a template and land there. What you can control: * **Captures follow the insertion.** With **Capture to active file**, the cursor ends up right after the inserted text; with **Open** enabled on other targets (opened focused, in an editing mode), QuickAdd places the cursor immediately after the inserted text. * **Apply template to active note** offers an **Insert at cursor** mode, so content lands where you already are. * **After creating a note**, a Template choice with **Open** doesn’t move the cursor - you typically land at the top of the note. To end at the bottom instead, wrap the Template choice in a [Macro choice](https://quickadd.obsidian.guide/docs/Choices/MacroChoice/) and add the **Move cursor to file end** editor command as the next step (file start and line start/end variants exist too). Run scripts ----------- [Section titled “Run scripts”](https://quickadd.obsidian.guide/docs/ComingFromTemplater/#run-scripts) QuickAdd runs JavaScript in two shapes: * **[Inline scripts](https://quickadd.obsidian.guide/docs/InlineScripts/) **: a fenced code block tagged `js quickadd` inside a template body or capture format. The block runs when the choice does, and a returned string is spliced into the output in its place. * **[User scripts](https://quickadd.obsidian.guide/docs/Choices/MacroChoice/) **: a `.js` file in your vault, run as a step of a Macro choice. Scripts receive `app`, the [QuickAdd API](https://quickadd.obsidian.guide/docs/QuickAddAPI/) (`inputPrompt`, `suggester`, `executeChoice`, and more), the shared `variables` map, and the `obsidian` module - see the [scripting guide](https://quickadd.obsidian.guide/docs/Advanced/ScriptingGuide/) . `{{MACRO:My macro}}` embeds a macro’s return value anywhere format syntax is accepted, so a computed value can flow straight into a file name, template body, or capture line. Common migration snags ---------------------- [Section titled “Common migration snags”](https://quickadd.obsidian.guide/docs/ComingFromTemplater/#common-migration-snags) These are the classic symptoms of splitting one template between two engines - each has a QuickAdd-native fix: * **You get prompted twice.** QuickAdd resolves all of its prompts before the file is created. If another engine prompts in the same template, you answer twice - once per engine. Let QuickAdd own the prompt with `{{VALUE:name}}` and reuse the answer everywhere it’s needed. * **Template syntax shows up unrendered.** QuickAdd renders QuickAdd tokens; another engine’s syntax is only rendered by that engine. If it isn’t installed or doesn’t run on the file, its markup stays behind as literal text. Port the line to the matching token from [the map](https://quickadd.obsidian.guide/docs/ComingFromTemplater/#the-quick-map) . * **Capturing into a note throws template errors.** A note that keeps live template syntax can re-execute or error whenever a plugin processes the file again. QuickAdd tokens like `{{DATE:YYYY-MM-DD}}` render once, at creation, into plain text - later captures find nothing to re-run. Migrate the offending line to a QuickAdd token and let QuickAdd create the note so the token renders - a Capture with **Create file if it doesn’t exist** plus that template does both (see [Today’s daily note](https://quickadd.obsidian.guide/docs/ComingFromTemplater/#todays-daily-note) ). --- # Settings | QuickAdd [Skip to content](https://quickadd.obsidian.guide/docs/Settings/#_top) Settings ======== Copy Markdown[View as Markdown](https://quickadd.obsidian.guide/docs/Settings.md) [Open in Claude](https://claude.ai/new?q=Read%20https%3A%2F%2Fquickadd.obsidian.guide%2Fdocs%2FSettings.md%20so%20I%20can%20ask%20questions%20about%20it.) [Open in ChatGPT](https://chatgpt.com/?hints=search&q=Read%20https%3A%2F%2Fquickadd.obsidian.guide%2Fdocs%2FSettings.md%20so%20I%20can%20ask%20questions%20about%20it.) This page is a reference for the QuickAdd settings tab, one group at a time. Each entry says what the setting does and what changes when you turn it on. Open the tab from Obsidian’s **Settings → Community plugins → QuickAdd** (or **Settings → QuickAdd**); changes save as you make them. Choices & packages ------------------ [Section titled “Choices & packages”](https://quickadd.obsidian.guide/docs/Settings/#choices--packages) * **Choices** - build and organize your QuickAdd choices. This is the main list you add to, reorder, and configure. See [Template Choices](https://quickadd.obsidian.guide/docs/Choices/TemplateChoice/) , [Capture Choices](https://quickadd.obsidian.guide/docs/Choices/CaptureChoice/) , [Macro Choices](https://quickadd.obsidian.guide/docs/Choices/MacroChoice/) , and [Multi Choices](https://quickadd.obsidian.guide/docs/Choices/MultiChoice/) . * **Packages** - share a set of choices with someone else, or bring theirs in. Use **Export package…** to bundle your choices into a file, and **Import package…** to add someone else’s. See [Share QuickAdd Packages](https://quickadd.obsidian.guide/docs/Choices/Packages/) . Choice picker ------------- [Section titled “Choice picker”](https://quickadd.obsidian.guide/docs/Settings/#choice-picker) The choice picker is the list you see when you run **QuickAdd: Run**. * **Search nested choices** - find a choice even when it lives inside a folder. When on, searching also matches choices nested in folders and shows their path. A nested match can rank above a same-level one. Turn it off to search only the level you have open. * **“New note from template” in the launcher** - decide where the “create a note from a template” row sits in the picker, so you can make a note from any template without building a dedicated Template choice. _Show at the bottom_ (default) keeps your most-used choice in the first slot, _Show at the top_ makes the template row first, and _Hide_ removes it. The row only appears once you have a [template folder](https://quickadd.obsidian.guide/docs/Settings/#templates--properties) configured. The **New note from template** command is always in the command palette, but it needs a configured folder too - without one it shows a notice and opens these settings. Input ----- [Section titled “Input”](https://quickadd.obsidian.guide/docs/Settings/#input) * **Use multi-line input prompt** - get a large text box for text prompts instead of a single line, so you can write several lines at once. Multi-line prompts submit with Ctrl/Cmd+Enter, and plain Enter adds a newline. See [Controlling Prompts](https://quickadd.obsidian.guide/docs/ControllingPrompts/#submit-keys) . * **Persist input prompt drafts** - don’t lose what you typed if you close a prompt by accident. When on, a closed prompt keeps its draft and restores it when you reopen. Drafts last only for the current session. * **Use editor selection as default Capture value** - let a Capture reuse text you already have highlighted. When on, Capture uses the current editor selection as `{{VALUE}}` and may skip the prompt entirely. When off, Capture always asks for `{{VALUE}}`. Individual Capture choices can override this. * **Name pasted images after the note title** - name clipboard images after the destination note instead of `Clipboard image YYYY-MM-DD HH.MM.SS`. Applies when you paste an image into a prompt whose answer lands in note content, and when Capture’s `{{CLIPBOARD}}` falls back to an image. If the destination is not known yet, QuickAdd keeps the timestamp name. Duplicate names follow Obsidian’s attachment folder setting. Off by default. * **One-page input for choices** - answer all of a choice’s questions in one form up front, instead of one prompt after another. Works with Template, Capture, and Macro choices. Each choice can [override this individually](https://quickadd.obsidian.guide/docs/Advanced/onePageInputs/#per-choice-override) . See [One-page Inputs](https://quickadd.obsidian.guide/docs/Advanced/onePageInputs/) and [Controlling Prompts](https://quickadd.obsidian.guide/docs/ControllingPrompts/) . * **Date aliases** - set your own shortcodes for natural-language dates, so typing `tm` in a date prompt means `tomorrow`. Write one per line as `alias = phrase`, for example `tm = tomorrow`. **Reset to defaults** restores the built-in aliases. Templates & properties ---------------------- [Section titled “Templates & properties”](https://quickadd.obsidian.guide/docs/Settings/#templates--properties) * **Template folder paths** - tell QuickAdd where your templates live, so it can suggest them when you configure a choice. Type a folder (autocomplete helps) and press **Add** or Enter; remove one with the trash button on its row. Add as many folders as you like. Leaving the list empty suggests every template file in the vault, but it also removes the **New note from template** launcher row, and the command of the same name will only point you back here until a folder is configured. * **Convert string front matter variables to typed properties (Beta)** - turn text values into real Obsidian property types so front matter reads correctly. List and object values from scripts are **always** written as proper properties (a list value becomes a List property), so templates produce valid front matter without this toggle. Turning it on **also** converts string values: a comma or bullet-list string becomes a List, `"42"` becomes a Number, `"true"` becomes a Checkbox, and so on. Off by default, because the string conversion is a beta heuristic that can have edge cases. See [Template Property Types (Beta)](https://quickadd.obsidian.guide/docs/TemplatePropertyTypes/) . Notifications ------------- [Section titled “Notifications”](https://quickadd.obsidian.guide/docs/Settings/#notifications) * **Announce updates** - see what changed when a new version installs, including new features, demo videos, and bug fixes. Choose _Show updates on each new release_, _Show updates only on major releases (new features, breaking changes)_, or _Don’t show_. * **Show capture notifications** - get a confirmation that a capture landed. When on, QuickAdd shows a notice after content is captured successfully. * **Show input cancellation notifications** - get a notice when you dismiss a prompt without submitting. Turn it off to avoid the extra notice every time you cancel a prompt. Global variables ---------------- [Section titled “Global variables”](https://quickadd.obsidian.guide/docs/Settings/#global-variables) * **Global variables** - define reusable snippets once and drop them in anywhere QuickAdd formatting is supported. These are vault-scoped. See [Global Variables](https://quickadd.obsidian.guide/docs/GlobalVariables/) . AI & online ----------- [Section titled “AI & online”](https://quickadd.obsidian.guide/docs/Settings/#ai--online) * **Disable AI & online features** - stop the plugin from reaching external providers like OpenAI. This blocks plugin features such as the AI Assistant from making those requests. User scripts can still run arbitrary code, including contacting external providers, so this setting does not affect them. Turn it off to use the [AI Assistant](https://quickadd.obsidian.guide/docs/AIAssistant/) . * **Allow URI x-callback-url** - let an `obsidian://quickadd` link report its result back to whoever launched it. Off by default, because the callback URL is set by whoever creates the `obsidian://` link and a successful callback can carry the affected note’s vault path. When on, an `obsidian://quickadd` URI may open a callback URL (`x-success` / `x-error` / `x-cancel`) after a Template or Capture choice finishes, sending the outcome and, on success, the note’s vault path and URL to that callback. Only `shortcuts:` and `obsidian:` callback URLs are permitted. See [Obsidian URI](https://quickadd.obsidian.guide/docs/Advanced/ObsidianUri/) . Appearance ---------- [Section titled “Appearance”](https://quickadd.obsidian.guide/docs/Settings/#appearance) * **Show icon in sidebar** - add the QuickAdd icon to the sidebar ribbon for one-click access. Requires a reload to take effect. Choice icons ------------ [Section titled “Choice icons”](https://quickadd.obsidian.guide/docs/Settings/#choice-icons) * **Automatic choice icons** - QuickAdd gives each choice type a default [Lucide](https://lucide.dev/) icon: `file-text` for Template, `pencil` for Capture, `terminal` for Macro, and `folder` for Multi. These show in the QuickAdd launcher, inside Multi choice pickers, and on registered commands in the command palette and mobile editing toolbar. * **Override a choice’s icon** - give a single choice its own icon. Open the choice’s configuration and set **Icon** to any Lucide icon id (for example `star`); leave it empty to fall back to the choice type default. Icons take the active Obsidian theme’s color; QuickAdd does not set per-choice icon colors. _Choice icons introduced in QuickAdd 2.14.0._ --- # Template | QuickAdd [Skip to content](https://quickadd.obsidian.guide/docs/Choices/TemplateChoice/#_top) Template ======== Copy Markdown[View as Markdown](https://quickadd.obsidian.guide/docs/Choices/TemplateChoice.md) [Open in Claude](https://claude.ai/new?q=Read%20https%3A%2F%2Fquickadd.obsidian.guide%2Fdocs%2FChoices%2FTemplateChoice.md%20so%20I%20can%20ask%20questions%20about%20it.) [Open in ChatGPT](https://chatgpt.com/?hints=search&q=Read%20https%3A%2F%2Fquickadd.obsidian.guide%2Fdocs%2FChoices%2FTemplateChoice.md%20so%20I%20can%20ask%20questions%20about%20it.) A Template choice creates a **new note from a template file** or applies a template to an existing note. Press a hotkey, answer any prompts, and QuickAdd builds the note - filling in dates, your answers, and links as it goes. Use it to spin up a book note, a meeting note, or a project page from a layout you keep once and reuse everywhere. Templates use QuickAdd’s own [format syntax](https://quickadd.obsidian.guide/docs/FormatSyntax/) - prompts, dates, and variables included - so no other plugin is required. If your templates come from the Templater plugin, see [Coming from Templater](https://quickadd.obsidian.guide/docs/ComingFromTemplater/) for the QuickAdd-native way to do each familiar job. ![The QuickAdd Template builder, showing the Template, Location, Linking, and Behavior sections](https://quickadd.obsidian.guide/_astro/template-builder.DAUsoTzm_1WwuXi.webp) Set up your first template choice --------------------------------- [Section titled “Set up your first template choice”](https://quickadd.obsidian.guide/docs/Choices/TemplateChoice/#set-up) 1. Create a template note, for example `Templates/Book.md`: ---author:status: reading---# {{VALUE:title}} Started {{DATE}} 2. Open **Settings → QuickAdd**, type a name like `New book note`, choose **Template** in the dropdown, and click **Add Choice**. 3. Click the gear (⚙) next to the new choice. 4. Set **Template Path** to `Templates/Book.md`. 5. Under **New note location**, choose **In a specific folder** and enter `Books`. 6. Run it: command palette → `QuickAdd: Run`, pick `New book note`, type the title, for example `Dune`. QuickAdd creates `Books/Dune.md` from your template, with the title, date, and frontmatter filled in. Assign the choice a hotkey (⚡ icon, or Obsidian’s Hotkeys settings) once it behaves the way you want. ### Tokens in template properties [Section titled “Tokens in template properties”](https://quickadd.obsidian.guide/docs/Choices/TemplateChoice/#tokens-in-properties) A bare token in frontmatter, like `Title: {{VALUE:fileName}}`, is not valid YAML, so Obsidian logs a console warning when it indexes the template file itself. The warning is cosmetic - QuickAdd reads the template as text and the created note is fine - but if you want a quiet console, wrap the token in quotes: Title: "{{VALUE:fileName}}" Two things to know about the quoted form: * QuickAdd escapes the filled-in value for the surrounding quotes, so answers containing `"` or `'` can’t break the created note’s frontmatter. * Quotes normally make the property a **string**. For a typed property, declare the type on the token and the quotes are consumed: `rating: "{{VALUE:rating|type:number}}"` writes `rating: 42`, which Obsidian reads as a Number (same for `|type:checkbox` and `|type:slider`). Run a template without making a choice -------------------------------------- [Section titled “Run a template without making a choice”](https://quickadd.obsidian.guide/docs/Choices/TemplateChoice/#run-without-choice) If you just want to spin up a note from a template in your [template folder](https://quickadd.obsidian.guide/docs/Settings/#templates--properties) without maintaining a Template choice per file, use the **New note from template** command. It lists the templates in your configured folder, prompts for the new note’s name, and creates it in Obsidian’s default location. **New note from template** uses a discovery-first title picker: as you type the new note name, QuickAdd shows matching existing notes and unresolved wikilink targets first. Choose an existing note to open it unchanged, or choose the **Create new note** row to create the note from the selected template. The builder groups a Template choice’s settings into four sections: **Template** (template path and file name format), **Location** (where the file is created), **Linking** (whether and how to link to the created file), and **Behavior** (what happens when the file already exists, and how the file is opened). Point to the template file: Template Path ----------------------------------------- [Section titled “Point to the template file: Template Path”](https://quickadd.obsidian.guide/docs/Choices/TemplateChoice/#mandatory) **Template Path** is the one required setting: the path to the template you want to insert. Paths are vault-relative; a leading `/` is ignored. Templates/Book.md QuickAdd supports markdown (`.md`), canvas (`.canvas`), and base (`.base`) templates. The created file uses the same extension as the template. If you want a new markdown note to include a live embedded Base dashboard, see [Template: Create an MOC Note with a Link Dashboard](https://quickadd.obsidian.guide/docs/Examples/Template_CreateMOCNoteWithLinkDashboard/) . ### Use a dynamic template path [Section titled “Use a dynamic template path”](https://quickadd.obsidian.guide/docs/Choices/TemplateChoice/#dynamic-template-path) The Template Path supports [format syntax](https://quickadd.obsidian.guide/docs/FormatSyntax/) , so the path can change from run to run. Named values (`{{VALUE:client}}`), dates (`{{DATE:YYYY}}`), fields, and global variables all work in the path. The same applies to the Capture choice’s _Create file with template_ path. Templates/{{VALUE:collectionName}} Template.md Running the choice prompts for a collection name and resolves to a path like `Templates/Games Template.md`. The created file’s extension comes from the _resolved_ path, so a placeholder that expands to `.canvas` or `.base` produces a canvas or base file. A path is resolved with a **path-safe** subset of the format syntax: * Macros, inline JavaScript, and `{{TEMPLATE:...}}` inclusion are **not** run while computing a path. * `{{TITLE}}` cannot be used in a path (the title is derived from the created file, not the source template). * The note-relative placeholders `{{FOLDER}}`, `{{FILENAMECURRENT}}`, `{{LINKCURRENT}}`, and `{{LINKSECTION}}` are left as-is in a template path, since they describe the runtime note/folder context (the target folder, or the active note and the cursor’s heading) rather than the source template. `{{FOLDER}}` is still available in file names and template bodies. Name the new note: File Name Format ----------------------------------- [Section titled “Name the new note: File Name Format”](https://quickadd.obsidian.guide/docs/Choices/TemplateChoice/#optional) **File Name Format** sets a format for the created file’s name, using [format syntax](https://quickadd.obsidian.guide/docs/FormatSyntax/) - so file names can be dynamic too. £ {{DATE}} {{NAME}} £ 2021-06-12 Manually-Written-File-Name `{{NAME}}` is a value you enter when invoking the template. If you **disable** File Name Format, QuickAdd uses `{{VALUE}}` as the file name format, which keeps the default behavior of prompting for a file name when you run the choice (with the same `{{VALUE}}` / `{{NAME}}` behavior described in the format syntax docs). A slash in the format creates a folder, so the name can include a path. The file is created under [New note location](https://quickadd.obsidian.guide/docs/Choices/TemplateChoice/#new-note-location) . {{DATE:YYYY}}/{{VALUE}} 2026/Kickoff `{{FILENAMECURRENT}}` names a folder after the note you are in, for example `{{FILENAMECURRENT}}/{{VALUE}}`. ### Search for an existing note first [Section titled “Search for an existing note first”](https://quickadd.obsidian.guide/docs/Choices/TemplateChoice/#search-existing) **Search existing notes before creating** applies to Template choices that use the default note-title prompt. It opens the same discovery-first picker used by **New note from template**: matching notes and unresolved wikilink targets appear while you type, so you can open an existing note instead of creating a duplicate. **When selecting an existing note** controls what selecting a match does: | Action | Result | | --- | --- | | **Open note** | Opens the note unchanged. This is the default. | | **Append template to bottom** | Adds the template at the end of the note. | | **Insert template at top** | Adds the template below the note’s frontmatter. | | **Replace entire note** | Replaces all content, including frontmatter, with the template. | Append and insert use the same [frontmatter merging](https://quickadd.obsidian.guide/docs/Choices/TemplateChoice/#update-existing-file) as the other template update actions. Applying a template to a selected note requires a Markdown template. The picker names the action beside each existing note, so an update is visible before you select it. The selected note keeps its path and name. QuickAdd skips **File Name Format**, **New note location**, and the new-note collision setting. `{{TITLE}}` and the anonymous `{{VALUE}}` use the selected note’s basename, and `{{FOLDER}}` uses its folder. The template’s other inputs still appear, including in the [one-page form](https://quickadd.obsidian.guide/docs/Advanced/onePageInputs/#choose-or-create-a-note) . An update finishes before the next Macro step runs and follows the choice’s linking, clipboard, and **Open** settings. **Open note** always opens the selected note without applying the template, inserting links, or copying links. Selecting **Create new note** or an unresolved wikilink target continues with normal Template creation. **If a new note’s path already exists** handles any collision at that generated path. The standalone **New note from template** command keeps the **Open note** behavior for existing matches. Which day `{{DATE}}` is about ----------------------------- [Section titled “Which day {{DATE}} is about”](https://quickadd.obsidian.guide/docs/Choices/TemplateChoice/#date-origin) Most of the time you want today. That’s the default, and you can leave it alone. Sometimes you don’t. Last week’s review, yesterday’s daily, the Friday you forgot to write. **Which day** is the calendar day `{{DATE}}` uses. The template file stays the same. `{{TIME}}` is still the time you ran the choice, so a “written at” stamp stays honest. * **Today** is the default. * **Ask each time** opens a date picker. **Picker starts on** is only the first value in that picker. You can still click another day. * **Yesterday**, **Last week**, **Next week**, and **Last month** cover the usual jobs. A weekly note with `|startof:week` still lands in the right week. * **Custom…** is any other jump from today, like three days back or last year. * **A variable…** is for a `{{VDATE}}` or a script that already has the day. When it isn’t today, hold Shift in the QuickAdd menu and the same choice asks for the day. If you want a hotkey for that, see [Command palette](https://quickadd.obsidian.guide/docs/Choices/TemplateChoice/#command-palette) below. You don’t need a second Daily Note choice. Scripts and the CLI can pass a day too: `executeChoice("Weekly review", {}, { date: "last week" })`, or `date=ask` if you want the picker. Decide where the note is created: New note location --------------------------------------------------- [Section titled “Decide where the note is created: New note location”](https://quickadd.obsidian.guide/docs/Choices/TemplateChoice/#new-note-location) **New note location** is a dropdown that controls where the note is created. Pick one of four modes: * **Obsidian default** - use Obsidian’s “Default location for new notes” setting. * **In a specific folder** - create the note in the folder(s) you configure below. One folder creates the note there; several folders open a suggester asking which to use. Drag a folder’s handle, or focus the handle and press ArrowUp / ArrowDown, to change the suggester order. An **Include subfolders** toggle (shown only in this mode) lets the suggester offer the selected folders _and_ their subfolders. * **Same folder as current file** - create the note next to the currently active file (falls back to the vault root if no file is open). * **Ask for folder each time** - prompt you to pick any folder in the vault each time the choice runs. Switching modes hides the fields that don’t apply, but your configured folder list is kept - switching back restores it. Folder paths support [format syntax](https://quickadd.obsidian.guide/docs/FormatSyntax/) , including `{{VALUE}}`, named values such as `{{VALUE:client}}`, dates, and global variables: Projects/{{VALUE:client}}/{{DATE:YYYY}} This prompts for a client and creates the file under that client’s folder for the current year. Link to the new note: Link to created file ------------------------------------------ [Section titled “Link to the new note: Link to created file”](https://quickadd.obsidian.guide/docs/Choices/TemplateChoice/#link-to-created-file) **Link to created file** controls whether QuickAdd inserts a link to the note it just created - handy for leaving a trail in the note you were in. Three modes: * **Enabled (strict)** - require the configured link destination to be available * **Enabled (skip if unavailable)** - insert the link when possible and skip silently when a current-note destination has no focused Markdown editor * **Disabled** - never append a link With either enabled mode, **Link destination** controls where the link is written: * **Current note** - insert the link into the active Markdown editor * **Specified note** - append the link to the bottom of an existing Markdown note, such as an index or MOC, without opening that note For **Current note**, strict mode keeps the legacy behavior and requires a focused Markdown editor. For **Specified note**, QuickAdd validates the destination note before creating the new note. It appends a normal link at the bottom of that file; it does not create the index file, insert under a heading, update properties, or remove duplicate links. ### Where the link is placed [Section titled “Where the link is placed”](https://quickadd.obsidian.guide/docs/Choices/TemplateChoice/#link-placement) For the **Current note** destination, **Link placement** chooses the spot: * **Replace selection** - replaces any selected text with the link (default) * **After selection** - preserves the selected text and places the link after it * **End of line** - places the link at the end of the current line * **New line** - places the link on a new line below the cursor * **In frontmatter property** - adds the link to a named frontmatter property When **In frontmatter property** is selected, set the property name and choose how strictly QuickAdd should handle missing or non-list properties: * **Create or convert** (default) - create the property if it is missing, or convert an existing scalar value into a list before appending the new link. Object values still throw an error. * **Create if missing** - create the property if it is missing. Existing scalar/object values still throw an error. * **Require list** - append only to an existing list property. Empty/null properties are treated as empty lists; missing properties and existing scalar/object values throw an error. ### Link or embed [Section titled “Link or embed”](https://quickadd.obsidian.guide/docs/Choices/TemplateChoice/#link-type) **Link type** is shown for any **Current note** body placement (**Replace selection**, **After selection**, **End of line**, and **New line**). Choose whether QuickAdd inserts a **Link** (`[[Note]]`) or an **Embed** (`![[Note]]`). An embed transcludes the linked note’s contents at the placement position, so for example **New line** + **Embed** drops `![[Note]]` on its own line. The inline placements (**After selection**, **End of line**) insert the embed inline on the same line. The **In frontmatter property** placement and the **Specified note** destination stay link-only. ### What the link says [Section titled “What the link says”](https://quickadd.obsidian.guide/docs/Choices/TemplateChoice/#link-display-text) **Link display text** is shown for the selection placements (**Replace selection**, **After selection**) with the **Link** type. It chooses what the inserted link displays. **Selected text** keeps your highlight as the link’s display text: Select "Meeting with Mark", run a Template choice whose file name format is20240101 {{SELECTED}} [[20240101 Meeting with Mark|Meeting with Mark]] With nothing selected (or when the selection can’t be represented safely inside a link), QuickAdd inserts the plain link instead. Multi-line selections are collapsed to a single line for the display text, and vaults using Markdown-style links get `[Meeting with Mark](20240101%20Meeting%20with%20Mark.md)`. ### Copy a link to the clipboard [Section titled “Copy a link to the clipboard”](https://quickadd.obsidian.guide/docs/Choices/TemplateChoice/#copy-link-to-clipboard) **Copy link to clipboard** copies a link to the created file after the Template choice runs. This works separately from **Link to created file**, so you can copy the link without inserting it into the current note, or do both. The copied link is a vault-path wikilink, ready to paste into another note. Open the note after creating: Open ---------------------------------- [Section titled “Open the note after creating: Open”](https://quickadd.obsidian.guide/docs/Choices/TemplateChoice/#open-created-file) **Open** opens the created file. When enabled, additional file-opening controls appear (these are shared with the Capture choice): * **File opening location** - where to open the file: **Reuse current tab**, **New tab**, **Split pane**, **New window**, **Left sidebar**, or **Right sidebar**. * **Split direction** - shown only when the location is **Split pane**. Arrange the new pane as **Split right** or **Split down**. * **View mode** - how to display the opened file: **Source**, **Preview**, **Live Preview**, or **Default**. * **Focus new pane** - shown for every location except **Reuse current tab**. Focus the opened tab immediately after opening. Run it from a hotkey: Command palette ------------------------------------- [Section titled “Run it from a hotkey: Command palette”](https://quickadd.obsidian.guide/docs/Choices/TemplateChoice/#command-palette) **Add to command palette** registers the choice as an Obsidian command, so you can bind a hotkey to it. It is the same switch as the lightning bolt in the choice list. Once it is on, and [Which day](https://quickadd.obsidian.guide/docs/Choices/TemplateChoice/#date-origin) isn’t **Ask each time**, a second toggle appears: **Also add “Name (pick a day)”**. That registers one more command that asks which day before it runs, so you can have one hotkey for today’s note and another for any other day, from the same choice. Your main hotkey keeps using Which day. When the note already exists ---------------------------- [Section titled “When the note already exists”](https://quickadd.obsidian.guide/docs/Choices/TemplateChoice/#file-already-exists-behavior) **If the target file already exists** decides what QuickAdd does when a note with the target name is already there. The setting works in two steps: first pick a high-level behavior, then a follow-up field appears for the two behaviors that need a detail. With **Search existing notes before creating** enabled, this setting is called **If a new note’s path already exists**. It applies to new-note creation. [Selecting an existing match](https://quickadd.obsidian.guide/docs/Choices/TemplateChoice/#search-existing) has its own action. * **If the target file already exists** - choose **Ask every time**, **Update existing file**, **Create another file**, or **Keep existing file**. * **Update action** - shown only when you choose **Update existing file**. * **New file naming** - shown only when you choose **Create another file**. ### Let QuickAdd ask each time [Section titled “Let QuickAdd ask each time”](https://quickadd.obsidian.guide/docs/Choices/TemplateChoice/#ask-every-time) QuickAdd prompts you to choose one of these actions each time the target path already exists: * **Append to bottom** * **Append to top** * **Overwrite file** * **Increment trailing number** * **Append duplicate suffix** * **Do nothing** ### Update the existing note [Section titled “Update the existing note”](https://quickadd.obsidian.guide/docs/Choices/TemplateChoice/#update-existing-file) These options modify the existing markdown, canvas, or base file: * **Append to bottom** - adds the template content to the end of the existing file. * **Append to top** - adds the template content to the beginning of the existing file. * **Overwrite file** - replaces the existing file content with the template. ### Create a new note instead [Section titled “Create a new note instead”](https://quickadd.obsidian.guide/docs/Choices/TemplateChoice/#create-another-file) These options keep the existing file untouched and create a new file instead: * **Increment trailing number** - changes trailing digits only while preserving zero padding when present. For example, `note009.md` becomes `note010.md`. * **Append duplicate suffix** - keeps the full base name and adds `(1)`, `(2)`, and so on. For example, `note.md` becomes `note (1).md`. ### Keep the existing note [Section titled “Keep the existing note”](https://quickadd.obsidian.guide/docs/Choices/TemplateChoice/#keep-existing-file) Selecting **Keep existing file** applies the same result as choosing **Do nothing** from the prompt: * **Do nothing** - leaves the existing file unchanged and opens it automatically. This does not require the separate **Open** setting. --- # Share QuickAdd Packages | QuickAdd [Skip to content](https://quickadd.obsidian.guide/docs/Choices/Packages/#_top) Share QuickAdd Packages ======================= Copy Markdown[View as Markdown](https://quickadd.obsidian.guide/docs/Choices/Packages.md) [Open in Claude](https://claude.ai/new?q=Read%20https%3A%2F%2Fquickadd.obsidian.guide%2Fdocs%2FChoices%2FPackages.md%20so%20I%20can%20ask%20questions%20about%20it.) [Open in ChatGPT](https://chatgpt.com/?hints=search&q=Read%20https%3A%2F%2Fquickadd.obsidian.guide%2Fdocs%2FChoices%2FPackages.md%20so%20I%20can%20ask%20questions%20about%20it.) A package bundles choices, macros, and their supporting scripts into a single `.quickadd.json` file. Use one to move a workflow to another vault or share it with someone else - they import the file and get your choices without rebuilding anything by hand. Importing shows a full review of what the package can do first, so you always see the scripts and macros before they run. Export a package ---------------- [Section titled “Export a package”](https://quickadd.obsidian.guide/docs/Choices/Packages/#export-a-package) 1. Open **Settings → QuickAdd** and scroll to the choices list. 2. Click **Export package…** in the Packages setting. 3. Use the filter to find the choices you want to share, then tick their checkboxes. Any dependent choices or scripts are added automatically. 4. Review the summary panel to confirm how many choices and assets are included. 5. Choose **Copy JSON** (puts the package on your clipboard) or **Save to file**. When saving, QuickAdd creates any missing folders inside your vault automatically. Import a package ---------------- [Section titled “Import a package”](https://quickadd.obsidian.guide/docs/Choices/Packages/#import-a-package) 1. Open **Settings → QuickAdd** and click **Import package…**. 2. Paste the full contents of a `.quickadd.json` file into the text box. 3. QuickAdd analyses the JSON and shows a **review** of exactly what the package will add and run before you commit - see [Review what a package can do](https://quickadd.obsidian.guide/docs/Choices/Packages/#review-what-a-package-can-do) . 4. Under **Choices**, pick an action for each choice: * **Import** adds a new choice only when its ID does not already exist. * **Overwrite** keeps the original ID and replaces the existing choice. * **Duplicate** copies the choice with new IDs so you can keep both versions. * **Skip** leaves the choice untouched. 5. Under **Files**, each bundled file is grouped as **Added** or **Will overwrite**. Choose **Write**, **Overwrite**, or **Skip** per file, and adjust the destination path if you want it saved elsewhere (templates default to your QuickAdd template folder when one is set). QuickAdd updates the imported choices to reference the new locations. 6. If the package runs code, tick the acknowledgement, then click **Import package**. The choices list updates immediately and a notice summarises what changed. Review what a package can do ---------------------------- [Section titled “Review what a package can do”](https://quickadd.obsidian.guide/docs/Choices/Packages/#review-what-a-package-can-do) Importing a package can run scripts and macros that have full access to your vault and the network, so the import screen treats it as a trust decision: it makes everything visible **before** anything is written. ### What the package can do to your vault [Section titled “What the package can do to your vault”](https://quickadd.obsidian.guide/docs/Choices/Packages/#capability-summary) A **What this package can do** panel lists the package’s capabilities, ranked by how much they can affect your vault: * **Runs custom JavaScript** - a user script, or a script-mode condition, that runs arbitrary code. * **Runs on startup** - a macro set to run automatically every time Obsidian launches, with no interaction. * **Adds commands** - choices that register a command in the palette / hotkeys. * **Overwrites existing choices or files**, **sends content to an AI provider**, **triggers other Obsidian commands**, and similar. Each row names the choice it comes from. Hover any badge for a plain-language explanation of what it means. ### Read the files before you trust them [Section titled “Read the files before you trust them”](https://quickadd.obsidian.guide/docs/Choices/Packages/#read-the-files-before-you-trust-them) Every bundled file appears under **Files** with its destination and size. Click **View contents** to read a script or template exactly as it will be written. Files that are run as code are marked **Executable** (regardless of their declared type), and very long or minified scripts are flagged as not fully reviewable. A Markdown note can carry runnable code too. A bundled note whose content includes a JavaScript code fence is flagged with a critical **can be run as code** capability row and counts toward the acknowledgement gate below, because such a note executes when something uses it: a user-script step runs a note’s first `js` fence as its script, and [inline `js quickadd` fences](https://quickadd.obsidian.guide/docs/InlineScripts/) run whenever the note is used as a template - **including as an AI Assistant prompt template**, where the fence runs on every AI call. ### Acknowledge the code before importing [Section titled “Acknowledge the code before importing”](https://quickadd.obsidian.guide/docs/Choices/Packages/#acknowledgement-gate) When a package can run code, the **Import package** button stays disabled until you have opened **View contents** on each bundled executable script and ticked the acknowledgement. Reviewed scripts are marked so you can track what is left. ### Preview a package from the command line [Section titled “Preview a package from the command line”](https://quickadd.obsidian.guide/docs/Choices/Packages/#preview-from-the-command-line) For scripting or CI, the `quickadd:package-preview` command returns the same review as JSON, without opening the modal: obsidian quickadd:package-preview path=path/to/package.quickadd.json Add `decode=true` to inline the decoded contents of each bundled file. Check version compatibility --------------------------- [Section titled “Check version compatibility”](https://quickadd.obsidian.guide/docs/Choices/Packages/#version-compatibility) Packages record the QuickAdd version and a schema number, so future releases can warn you when a file needs a newer plugin. If you see a schema version error, upgrade QuickAdd in both vaults and export the package again. --- # Capture | QuickAdd [Skip to content](https://quickadd.obsidian.guide/docs/Choices/CaptureChoice/#_top) Capture ======= Copy Markdown[View as Markdown](https://quickadd.obsidian.guide/docs/Choices/CaptureChoice.md) [Open in Claude](https://claude.ai/new?q=Read%20https%3A%2F%2Fquickadd.obsidian.guide%2Fdocs%2FChoices%2FCaptureChoice.md%20so%20I%20can%20ask%20questions%20about%20it.) [Open in ChatGPT](https://chatgpt.com/?hints=search&q=Read%20https%3A%2F%2Fquickadd.obsidian.guide%2Fdocs%2FChoices%2FCaptureChoice.md%20so%20I%20can%20ask%20questions%20about%20it.) A Capture choice adds text or updates a property **without opening the note**. Press a hotkey, type your entry, and QuickAdd files it exactly where it belongs - while you stay right where you are. Use it to: * Add timestamped entries to your daily note * Log work under the right heading of a project note * Save interesting links for later reading ![The QuickAdd Capture builder, showing the Location and Position sections](https://quickadd.obsidian.guide/_astro/capture-builder.CCw-h9CZ_12WOIU.webp) Set up your first capture ------------------------- [Section titled “Set up your first capture”](https://quickadd.obsidian.guide/docs/Choices/CaptureChoice/#set-up) 1. Open **Settings → QuickAdd**, type a name like `Add to journal`, choose **Capture** in the dropdown, and click **Add Choice**. 2. Click the gear (⚙) next to the new choice. 3. Set **Capture To** to where entries should land, for example `Journal/{{DATE}}.md`. 4. Enable **Capture format** and describe one entry, for example `- {{DATE:HH:mm}} {{VALUE}}`. 5. Run it: command palette → `QuickAdd: Run`, pick `Add to journal`, type your entry. You now have this in today’s journal note: - 09:42 Standup moved to Wednesday Assign the choice a hotkey (⚡ icon, or Obsidian’s Hotkeys settings) once it behaves the way you want. Choose where it goes: Capture To -------------------------------- [Section titled “Choose where it goes: Capture To”](https://quickadd.obsidian.guide/docs/Choices/CaptureChoice/#capture-to) _Capture To_ is the note you are capturing to. Either enable **Capture to active file** to write into the note you are currently in, or enter a file path. The path supports [format syntax](https://quickadd.obsidian.guide/docs/FormatSyntax/) , so it can be dynamic. A daily journal capture might use: Journal/{{DATE:gggg-MM-DD - ddd MMM D}}.md Every run finds today’s file, and your entry is captured to it. File names are Markdown-first: * No extension means a Markdown file: `Inbox` targets `Inbox.md`. * An explicit supported extension (`.md`, `.canvas`) is kept. * `.base` files are not supported as capture targets - use a Template choice for `.base` workflows. ### How QuickAdd picks the target [Section titled “How QuickAdd picks the target”](https://quickadd.obsidian.guide/docs/Choices/CaptureChoice/#how-quickadd-picks-a-target) When **Capture to active file** is off, the resolved _Capture to_ value decides what happens: | You write | What happens | | --- | --- | | `Inbox.md` (or any path with an extension) | Captures straight to that file | | nothing, or `/` | Opens a picker with every Markdown note in the vault | | `Projects/` (trailing slash) | Opens a picker confined to that folder | | `Projects` (existing folder, no extension) | Same picker, unless `Projects.md` exists - then the file wins | | `#people` | Picker with notes carrying that tag | | `property:type=draft` | Picker with notes whose frontmatter matches - see [filtering by a property](https://quickadd.obsidian.guide/docs/Choices/CaptureChoice/#capturing-to-a-property) | Paths are vault-relative; a leading `/` is ignored (except a lone `/`, which opens the whole-vault picker). The picker is ordered like Obsidian’s Quick Switcher: notes you opened most recently come first, then everything else alphabetically. Ordering ignores modification time on purpose, so a sync that touches old notes doesn’t push them to the top. Files in Obsidian’s **Excluded files** list sink to the bottom but stay selectable. You can also **type a new name** into the picker: with **Create file if it doesn’t exist** enabled, a **Create new note: ** row appears and QuickAdd creates the note for you. The create row is selected first, so press Enter to create the exact name you typed even when existing notes are fuzzy matches. The row hides when the typed name matches an existing note in scope, so typing an existing name selects it instead of offering a duplicate. The picker still opens for an empty folder, tag, property, or filtered scope so you can create the first note there. ### Capture to a folder [Section titled “Capture to a folder”](https://quickadd.obsidian.guide/docs/Choices/CaptureChoice/#capturing-to-folders) Type a folder name (like `CRM/people`) and QuickAdd asks which note in that folder to capture to - nested folders included. Format syntax works here too. For example: you keep one note per person in `CRM/people`. Set _Capture To_ to `CRM/people`, run the capture, and pick the person. Type `John Doe` instead and QuickAdd creates `CRM/people/John Doe.md` (with **Create file if it doesn’t exist** enabled). ### Capture to a tag [Section titled “Capture to a tag”](https://quickadd.obsidian.guide/docs/Choices/CaptureChoice/#capturing-to-tags) Type a tag (like `#people`) and QuickAdd asks which note carrying that tag to capture to. ### Filter by folders and tags together [Section titled “Filter by folders and tags together”](https://quickadd.obsidian.guide/docs/Choices/CaptureChoice/#capturing-to-filtered-files) Combine filters with `|` when the destination could live in several folders, or must match several tags: | You write | The picker shows | | --- | --- | | `folder:Goals\|folder:Projects` | Notes in either folder | | `tag:active\|tag:work` | Notes with **both** tags | | `folder:Goals\|folder:Projects\|tag:active` | Active notes in either folder | | `folder:Goals\|exclude-folder:Archive\|exclude-tag:done` | Goals that aren’t archived or done | Repeated `folder:` filters are OR filters. Repeated `tag:` filters are AND filters. Exclusions remove any matching file. Capture still writes to **one** destination per run. To select several related notes for metadata, use the [`{{FILE:|multi}}`](https://quickadd.obsidian.guide/docs/FormatSyntax/#file) placeholder in the capture format instead. ### Capture to notes with a matching property [Section titled “Capture to notes with a matching property”](https://quickadd.obsidian.guide/docs/Choices/CaptureChoice/#capturing-to-a-property) Type `property:=` to limit the picker to notes whose frontmatter matches. If your notes have a `type` field, `property:type=draft` opens a picker containing only the notes whose `type` is `draft`. This selects the destination note. [**Write position → Property**](https://quickadd.obsidian.guide/docs/Choices/CaptureChoice/#property) controls whether the capture updates one of that note’s properties. * `property:type=draft` - notes whose `type` equals `draft`. * `property:type` - notes that **have** a `type` field, whatever the value. * Matching is case-insensitive and trimmed. For a list property (`type: [draft, idea]`), the note matches if **any** entry equals the value. * The value supports [format syntax](https://quickadd.obsidian.guide/docs/FormatSyntax/) : `property:status={{VALUE}}` asks when the capture runs. Combine with the shared file filters using `|`, the same syntax as [`{{FIELD}}`](https://quickadd.obsidian.guide/docs/FormatSyntax/#field-filters) : * `property:type=draft|folder:Notes` - only drafts inside `Notes/`. * `property:type=draft|exclude-folder:Archive` - drafts not in `Archive/`. * `property:type=draft|exclude-tag:done` - drafts not tagged `#done`. Good to know: * Matches **YAML frontmatter** only, not inline Dataview `field:: value` fields. * The field name matches case-insensitively (`property:type` matches a `Type:` field), and value matching is always case-insensitive. * Only the `folder:` / `tag:` / `exclude-folder:` / `exclude-tag:` / `exclude-file:` pipe filters are applied here. * Because `|` starts a filter, a property value cannot itself contain `|`. * Typing a new note name (with **Create file if it doesn’t exist**) creates the note, but does not automatically give it the property. ### Send one entry to several notes [Section titled “Send one entry to several notes”](https://quickadd.obsidian.guide/docs/Choices/CaptureChoice/#capturing-the-same-entry-to-multiple-files) Capture writes to one destination per run. To write the same entry to several fixed notes, compose Capture choices with a [Macro](https://quickadd.obsidian.guide/docs/Choices/MacroChoice/) : 1. Create one Capture choice per destination. 2. Give each the same named value, for example `- {{VALUE:entry}}`. 3. Create a Macro and add each Capture choice as a **Nested Choice** command. 4. Run the Macro: QuickAdd prompts for `entry` once and reuses the answer. | Choice | Capture To | Format | | --- | --- | --- | | Log to Person A | `People/Person A.md` | `- {{VALUE:entry}}` | | Log to Person B | `People/Person B.md` | `- {{VALUE:entry}}` | If the destinations are dynamic, use one Capture choice with a formatted target and run it repeatedly from a [user script](https://quickadd.obsidian.guide/docs/UserScripts/) : | Setting | Value | | --- | --- | | Capture To | `People/{{VALUE:person}}.md` | | Format | `- {{VALUE:entry}}` | module.exports = async ({ quickAddApi }) => { const entry = await quickAddApi.inputPrompt("Entry"); const people = await quickAddApi.checkboxPrompt([ "Person A", "Person B", "Person C", ]); for (const person of people) { await quickAddApi.executeChoice("Log event to person", { entry, person, }); }}; Pass the variables object on every `executeChoice` call - each call clears its temporary variables after the choice runs. ### Friendlier names in the picker [Section titled “Friendlier names in the picker”](https://quickadd.obsidian.guide/docs/Choices/CaptureChoice/#file-picker-labels) The picker labels each note by its frontmatter `title` when available, then its first level-1 heading, then its file name. The selected destination is always the real file, so captures write to the same place even when the label is friendlier than the filename. Shape the entry: Capture format ------------------------------- [Section titled “Shape the entry: Capture format”](https://quickadd.obsidian.guide/docs/Choices/CaptureChoice/#capture-format) _Capture format_ is what actually gets written - think of it as a mini template for one entry. When disabled, QuickAdd writes `{{VALUE}}`: whatever you type in the prompt (or your editor selection, if selection-as-value is enabled). All of [format syntax](https://quickadd.obsidian.guide/docs/FormatSyntax/) works here: - {{DATE:HH:mm}} {{VALUE}} - 09:42 Called the bank For a long format, keep it in a note and reference it: {{TEMPLATE:Templates/Capture Format.md}} QuickAdd inserts the file’s contents, then processes the result like any capture format - the file can contain `{{VALUE}}`, `{{DATE}}`, `{{MACRO:...}}`, inline scripts, and further `{{TEMPLATE:...}}` includes (`.md`, `.canvas`, and `.base` files; include the extension). This lets you edit, version, and reuse a complete capture format as a normal note. The [one-page input form](https://quickadd.obsidian.guide/docs/Advanced/onePageInputs/) and `quickadd:check` scan referenced template files too, so their prompts appear up front. If your format includes an inline `js quickadd` block and you need to transform input, read input in script code via `this.quickAddApi.inputPrompt(...)` and assign variables on `this.variables` - don’t put `{{VALUE}}` inside JavaScript string literals. See [Inline scripts](https://quickadd.obsidian.guide/docs/InlineScripts/#execution-order-and-value) . The options, one by one ----------------------- [Section titled “The options, one by one”](https://quickadd.obsidian.guide/docs/Choices/CaptureChoice/#capture-options) The Capture builder groups its settings into **Location**, **Position**, **Linking**, **Content**, and **Behavior**. ### Create the note if it’s missing [Section titled “Create the note if it’s missing”](https://quickadd.obsidian.guide/docs/Choices/CaptureChoice/#create-file-if-it-doesnt-exist) _Create file if it doesn’t exist_ does what it says. Optionally create the file **from a template** - an input for the template file appears below the setting. ### Format the entry as a task [Section titled “Format the entry as a task”](https://quickadd.obsidian.guide/docs/Choices/CaptureChoice/#task) _Task_ formats your captured text as a task (`- [ ] ...`). ### Which day [Section titled “Which day”](https://quickadd.obsidian.guide/docs/Choices/CaptureChoice/#date-origin) Same [Which day](https://quickadd.obsidian.guide/docs/Choices/TemplateChoice/#date-origin) setting as a Template. Imagine you capture into `Daily/{{DATE}}.md` at 3pm. The path picks the note. The line `- {{TIME}} bought milk` is 3pm, even if that note is yesterday. That’s the useful split: the note is the day, the stamp is when you wrote it. `{{DATE:HH:mm}}` looks like it should print yesterday, but `HH:mm` only prints the clock, so you still get `15:00`. Put `{{DATE}}` on the line if you want the note’s day next to the text. Most people leave this on Today and hold Shift in the QuickAdd menu for the days that aren’t today. If you’d rather have a hotkey for that, see [Command palette](https://quickadd.obsidian.guide/docs/Choices/CaptureChoice/#command-palette) . Your existing hotkey still captures to today. ### Use your selection as the answer [Section titled “Use your selection as the answer”](https://quickadd.obsidian.guide/docs/Choices/CaptureChoice/#use-editor-selection) _Use editor selection as default value_ controls whether selected text in the editor is used as `{{VALUE}}` instead of prompting: **Follow global setting**, **Use selection**, or **Ignore selection** (the global default lives in **Settings → Input**). This does not affect `{{SELECTED}}`. ### Pick where in the note it lands: Write position [Section titled “Pick where in the note it lands: Write position”](https://quickadd.obsidian.guide/docs/Choices/CaptureChoice/#write-position) _Write position_ controls where in the note the entry is written. The options depend on whether **Capture to active file** is enabled: * **At cursor** (active file) / **Top of file** (target file) - the first option’s label changes with the mode * **Top of file (after frontmatter)** (active file only) * **New line above cursor** / **New line below cursor** (active file only) * **After line…** - insert after a target line you specify, or pick a heading at run time. The workhorse for structured notes - see [Insert after](https://quickadd.obsidian.guide/docs/Choices/CaptureChoice/#insert-after) . * **Before line…** - see [Insert before](https://quickadd.obsidian.guide/docs/Choices/CaptureChoice/#insert-before) * **Bottom of file** * **Property** - set a frontmatter value or add items to a list. ### Capture into a property [Section titled “Capture into a property”](https://quickadd.obsidian.guide/docs/Choices/CaptureChoice/#property) **Write position → Property** writes the Capture format to one frontmatter property in a Markdown note. The note’s body and unrelated property values stay intact. QuickAdd uses Obsidian’s frontmatter writer, so YAML formatting can change. **Property** selects the key: * **Named property** uses a fixed name such as `status`, or a formatted name such as `{{VALUE:property}}`. * **Choose when capturing** opens a picker with the target note’s properties. With **Create property if missing** enabled, you can also enter a new name. Property names match case-insensitively and keep the note’s existing spelling. An exact match wins. If several keys differ only in case and none matches exactly, QuickAdd stops the capture instead of choosing one. **Action** controls the update: * **Set value** replaces the property’s value. For a List property, each line of the captured text is one item, and a typed list replaces the whole list. An empty text value clears the list. Commas inside text do not split it into several items. * **Add to list** adds each line of the captured text, or each item of a typed list, to the property’s list. Existing items keep their order, and exact duplicates are skipped. An existing text, number, or checkbox value causes an error. Line breaks mark list items, the same way Enter does in Obsidian’s own List property editor: * Lines are trimmed and blank lines are ignored, so a single line stays one item. * A multi-line Capture format adds several fixed items without a prompt. `{{VALUE}}` on its own line above them adds what you type as one more item. * A `{{VALUE:notes|type:multiline}}` prompt into a list is a free-form “one item per line” prompt. * Text, number, checkbox, date, and date-time properties never split. * Arrays from `|multi` pickers and scripts are written as they are, even if an item contains a line break. A `|multi` picker combined with other lines produces text, so its picks land in one comma-joined item; keep `|multi` alone in the format, or use a plain `{{VALUE}}` line for the typed value. An explicit `|format:markdown` or `|format:yaml` keeps its dashes or YAML markers in each item. Neither action converts an existing text, number, or checkbox property into a list. An empty or whitespace-only text value or empty list with **Add to list** leaves the note unchanged. It does not create a missing note, write properties, insert links, or copy links. **Create property if missing** permits a new key. When disabled, a missing key stops the capture. **Create file if it doesn’t exist** separately controls whether QuickAdd can create the destination note. The Capture format supplies the value. A format made entirely of one `VALUE`, `FIELD`, or `FILE` token preserves a typed number, checkbox, or list. Combining a token with other text produces text. An explicit multi-select output format, such as `|format:spaced`, also produces the requested text representation. For a Number or Checkbox property, a plain `{{VALUE}}` or `{{VALUE:rating}}` automatically uses the matching input widget and value type. This also applies to a missing property whose type is already set in Obsidian. An explicit `|type:` option takes precedence. | Property | Action | Capture format | Result | | --- | --- | --- | --- | | `status` | **Set value** | `{{VALUE:status}}` | The entered text. | | `rating` | **Set value** | `{{VALUE:rating\|type:number}}` | A Number property. | | `done` | **Set value** | `{{VALUE:done\|type:checkbox}}` | A Checkbox property. | | `tags` | **Add to list** | `work` and `personal` on two lines | Adds both tags without a prompt. | | `tags` | **Add to list** | `{{VALUE:work,personal\|multi}}` | Adds the selected tags. | | `people` | **Set value** | `{{FILE:People\|multi\|link}}` | Replaces the list with links to the selected notes. | The value must match the property’s Obsidian type, or its existing value when no type is known. A Number property can receive a script value of `42` or the text `"42"` through a plain `VALUE` token. Literal formats and composite text are not parsed as YAML: `true` and `[work, personal]` remain text. Text properties also preserve values such as `001`. Commas in text remain part of one value. Objects and lists containing non-text values are rejected. **Set value** removes exact duplicate list items while preserving their order. For a new property without a known type, the captured value determines the type. Date properties accept `YYYY-MM-DD`, and date-time properties accept ISO date-time text such as `2026-09-07T14:30`. An intentional empty text value or empty list clears a matching property with **Set value**. Use `|optional` to allow an empty prompt answer. Cancelling a prompt stops the capture. Several lines of text are the one exception. **Set value** stops with an error instead of guessing, because several lines usually mean a list, and writing them as text would register the property as Text for the whole vault and block every later **Add to list**. Use **Add to list** to create it as a list, or set the property’s type in Obsidian first - choose Text to keep the lines as one value. QuickAdd collects and validates the property inputs before writing or creating the note. **Task** and **Run Templater on entire destination file after capture** are hidden and do not apply to property captures. Scripts can supply native values through `executeChoice`. With **Add to list**, property `tags`, and format `{{VALUE:tags}}`, this adds two complete items. The comma inside the first item stays part of that item: await quickAddApi.executeChoice("Add project tags", { tags: ["Research, writing", "work"],}); For a non-interactive CLI run, use **Named property**, optionally with a variable in its name, and pass typed values through [`vars`](https://quickadd.obsidian.guide/docs/Advanced/CLI/#passing-variables) . **Choose when capturing** requires an interactive run. ### Link back to the captured note [Section titled “Link back to the captured note”](https://quickadd.obsidian.guide/docs/Choices/CaptureChoice/#link-to-captured-file) _Link to captured file_ inserts a link to the note you captured to - useful for leaving a trail in the note you were in. Three modes: * **Enabled (strict)** - require the configured link destination to be available * **Enabled (skip if unavailable)** - insert the link when possible, silently skip when nothing is open * **Disabled** - never insert a link With either enabled mode, _Link destination_ controls where the link goes: * **Current note** - insert into the active editor * **Specified note** - append to the bottom of a chosen note (an index or MOC, for example) without opening it. QuickAdd validates the destination before writing. It appends a plain link only: it won’t create the index file, insert under a heading, update properties, or dedupe links. For **Current note**, strict mode requires a focused Markdown editor (except Canvas-triggered captures, which skip link insertion when no Markdown editor is available). #### Where the link is placed [Section titled “Where the link is placed”](https://quickadd.obsidian.guide/docs/Choices/CaptureChoice/#link-placement) For the **Current note** destination, _Link placement_ chooses the spot: * **Replace selection** - replace any selected text with the link (default) * **After selection** - keep the selected text, place the link after it * **End of line** - at the end of the current line * **New line** - on a new line below the cursor * **In frontmatter property** - add the link to a named frontmatter property For **In frontmatter property**, set the property name and how strictly to handle missing or non-list properties: * **Create or convert** (default) - create the property if missing, or convert an existing scalar value into a list before appending. Object values still error. * **Create if missing** - create the property if missing; existing scalar/object values error. * **Require list** - append only to an existing list property. Empty/null count as empty lists; missing properties and scalar/object values error. #### Link or embed [Section titled “Link or embed”](https://quickadd.obsidian.guide/docs/Choices/CaptureChoice/#link-type) For the body placements (**Replace selection**, **After selection**, **End of line**, **New line**), a _Link type_ dropdown chooses **Link** (`[[Note]]`) or **Embed** (`![[Note]]`). An embed transcludes the captured note’s contents at the placement position. **In frontmatter property** and the **Specified note** destination stay link-only. #### What the link says [Section titled “What the link says”](https://quickadd.obsidian.guide/docs/Choices/CaptureChoice/#link-display-text) For the selection placements with the **Link** type, _Link display text_ chooses the visible text. **Selected text** keeps your highlight as the display text: selecting `Meeting with Mark` and capturing to `20240101 Meeting with Mark` inserts `[[20240101 Meeting with Mark|Meeting with Mark]]`. With nothing selected (or a selection that can’t sit safely inside a link), the plain link is inserted. Multi-line selections collapse to one line, and vaults using Markdown-style links get `[Meeting with Mark](20240101%20Meeting%20with%20Mark.md)`. ### Copy a link to the clipboard [Section titled “Copy a link to the clipboard”](https://quickadd.obsidian.guide/docs/Choices/CaptureChoice/#copy-link-to-clipboard) _Copy link to clipboard_ copies a link to the captured note after the capture runs - independent of _Link to captured file_, so you can copy without inserting, or do both. The copied link is a vault-path wikilink, ready to paste into another note. ### Open the captured note [Section titled “Open the captured note”](https://quickadd.obsidian.guide/docs/Choices/CaptureChoice/#opening-the-captured-file) When **Capture to active file** is off, the **Behavior** section shows an _Open_ toggle. Enabling it reveals: * _File opening location_ - **Reuse current tab**, **New tab**, **Split pane**, **New window**, **Left sidebar**, or **Right sidebar** * _Split direction_ - **Split right** or **Split down** (shown for **Split pane**) * _View mode_ - **Source**, **Preview**, **Live Preview**, or **Default** * _Focus new pane_ - focus the opened tab immediately (shown for every location except **Reuse current tab**) When QuickAdd opens and focuses a Markdown target in an editable mode after a body capture, it places the cursor at the end of the inserted text so you can keep typing. This is skipped for preview/unfocused opens and when Templater cursor markers take over. ### Run it from a hotkey: Command palette [Section titled “Run it from a hotkey: Command palette”](https://quickadd.obsidian.guide/docs/Choices/CaptureChoice/#command-palette) **Add to command palette** registers the capture as an Obsidian command, the same switch as the lightning bolt in the choice list. Once it is on, and [Which day](https://quickadd.obsidian.guide/docs/Choices/CaptureChoice/#date-origin) isn’t **Ask each time**, **Also add “Name (pick a day)”** registers a second command that asks which day first. One hotkey captures to today, the other to whichever day you pick, from the same choice. ### Run Templater on the whole file afterwards [Section titled “Run Templater on the whole file afterwards”](https://quickadd.obsidian.guide/docs/Choices/CaptureChoice/#run-templater-on-entire-destination-file-after-capture) _Run Templater on entire destination file after capture_ is an advanced, legacy option: it executes any `<% %>` anywhere in the destination file, including inside code blocks. Leave it off unless you specifically need that whole-file pass. ### Templater and newly created notes [Section titled “Templater and newly created notes”](https://quickadd.obsidian.guide/docs/Choices/CaptureChoice/#templater-and-newly-created-files) Body captures have two Templater paths when they create a missing Markdown file: * **Create file if it doesn’t exist** without a QuickAdd template: QuickAdd creates a blank file first. If Templater’s new-file trigger applies to that location, QuickAdd waits for Templater to finish before inserting the capture. * **Create with template**: QuickAdd owns the initial content. It renders the selected QuickAdd template, suppresses Templater’s new-file/directory trigger for that creation, then runs Templater once on the content QuickAdd wrote. So a blank Capture-created file can receive Templater’s directory template first, while a template-created file runs Templater on QuickAdd’s template content instead. Property captures prepare the property value before creating the file. After a new-file Templater pass, QuickAdd applies the property update to the resulting frontmatter so the template does not discard the capture. Insert after ------------ [Section titled “Insert after”](https://quickadd.obsidian.guide/docs/Choices/CaptureChoice/#insert-after) **After line…** inserts the entry after a line with the text you specify - this is how entries land under the right heading. A journal capture might insert after `## What did I do today?`. By default, QuickAdd preserves blank lines after headings to keep spacing intact. **Blank lines after match** controls this: * **Auto (headings only)** - skip blank lines only when the matched line is a heading * **Always skip** - skip all consecutive blank lines after the match * **Never skip** - insert immediately after the matched line Example (Auto, insert after `# H` with content `X`): # H XA With Insert after you can also enable **Insert at end of section** and **Consider subsections** - see [below](https://quickadd.obsidian.guide/docs/Choices/CaptureChoice/#consider-subsections--option) . **Create line if not found** creates the target line when it doesn’t exist - useful when the heading might not be in the note yet. The created line can go at the **Top** or **Bottom** of the file, at your **Cursor**, or **Ordered** - sorted among same-level headings; see [Ordered section placement](https://quickadd.obsidian.guide/docs/Choices/CaptureChoice/#ordered-section-placement) for reverse-chronological logs and changelogs. The target may span several lines: type `\n` in the **Insert after** field to match a multi-line anchor (the preview shows it expanded). **Inline insertion** is the exception - it inserts on the same line, so its target must be a single line; a `\n` target there is rejected with a notice. ### Ordered section placement [Section titled “Ordered section placement”](https://quickadd.obsidian.guide/docs/Choices/CaptureChoice/#ordered-section-placement) When **Create line if not found** is set to **Ordered** (full label: `Ordered (place new section among siblings)`), a missing “Insert after” heading is created at its **sorted position among same-level headings**. This is the building block for a reverse-chronological log: each new dated section is added above older ones, while a fixed title stays pinned at the top. The classic “daily log, newest first” recipe (issue [#481](https://github.com/chhoumann/quickadd/issues/481) ): * **Capture to**: your log note (enable `Create file if it doesn't exist` to auto-create it) * **Format**: the entry with a trailing newline, e.g. `- {{DATE:HH:mm}} {{VALUE}}\n` (task captures add their own newline) * **Insert after**: the day heading, `## {{DATE:YYYY-MM-DD}}` * **Insert at end of section**: off, so each entry lands directly under the day heading (newest first within the day) * **Create line if not found**: on, location **Ordered**, **Sort sections by** = `Date`, **Section order** = `Newest / highest first` Running it on consecutive days (and twice in one day) produces: # My Daily Log A short intro that always stays at the top. ## 2026-06-16- 09:40 reviewed the code- 09:13 started the design ## 2026-06-14- 09:00 older entry The first capture of a day creates `## 2026-06-16` below the intro and above `## 2026-06-14`; later captures that day find the existing heading and add their entry on top. The `# My Daily Log` title stays put because only same-level headings (`##`) are sorted against each other, and YAML frontmatter is never treated as a heading. #### Sort options [Section titled “Sort options”](https://quickadd.obsidian.guide/docs/Choices/CaptureChoice/#sort-options) With **Ordered** selected, these controls appear: * **Sort sections by** - how the sort key is read from each heading: * `Insertion order (no sorting)` - newest-first prepends the new section; oldest-first appends it. No parsing. * `Text (A→Z)` - case-insensitive text compare. * `Number` - the leading number in the heading (e.g. `## 12 Project X`). * `Date` - parsed with a **Date format** (auto-detected from the `{{DATE:…}}` placeholder in your “Insert after” text, and editable). Trailing decoration like `## 2026-06-14 (Friday)` is ignored. * `Version (semver)` - `major.minor.patch`, so `1.10.0` sorts above `1.9.0`. A leading `v` and the Keep-a-Changelog `## [1.10.0] - 2026-06-16` form are both understood. * **Section order** - `Newest / highest first` or `Oldest / lowest first`. * **Existing unparseable headings** (for `Date`, `Number`, `Version (semver)`) - where to rank headings that can’t be parsed for the chosen key (like `## Unreleased` in a changelog): sort to bottom (default) or top. A new heading that can’t be parsed is always appended at the end. Use **Insert at end of section** to control order _within_ each section: off = newest entry on top (date logs), on = entries appended at the end (changelogs). #### More examples [Section titled “More examples”](https://quickadd.obsidian.guide/docs/Choices/CaptureChoice/#more-examples) A changelog with the newest version on top - **Insert after** `## {{VALUE:version}}`, **Format** `- {{VALUE:change}}\n`, **Insert at end of section** on, **Create line if not found** on → **Ordered**, **Sort by** `Version (semver)`, **Order** `Newest / highest first`: # Changelog ## 1.10.0- new feature- another fix in 1.10.0 ## 1.9.0- old fix A “books read” note grouped by year - **Insert after** `## {{DATE:YYYY}}`, **Format** `- {{VALUE}}\n`, **Create line if not found** on → **Ordered**, **Sort by** `Date` with **Date format** `YYYY`, **Order** `Newest / highest first`. #### Notes and limits [Section titled “Notes and limits”](https://quickadd.obsidian.guide/docs/Choices/CaptureChoice/#notes-and-limits) * The heading is created **once** and reused - every later capture finds it, so the section is never duplicated. This relies on the heading resolving to the **same text** each time: use a stable placeholder (`{{DATE:…}}`, a `{{VALUE:…}}` you supply), not a random one. * Sorting covers **all same-level headings in the note**, not one parent section. For the layouts above (dated/versioned `##` sections under one `#` title) that’s exactly right - keep the fixed title at a different heading level so it’s never a sortable sibling. * Ordered placement positions the **new** section only; it doesn’t re-sort existing ones. * **Ordered** is for headings and can’t be combined with **Inline insertion**. ### Choose the heading when capturing [Section titled “Choose the heading when capturing”](https://quickadd.obsidian.guide/docs/Choices/CaptureChoice/#choose-heading-when-capturing) Instead of typing the target line when you build the choice, enable **Choose heading when capturing** to pick it **at run time**: QuickAdd reads the target note and shows a dropdown of its headings - pick one, and the entry is inserted under it. Useful when the heading varies between runs, or when you’d rather not remember it. The picked heading simply becomes the insert-after target, so every placement control still applies: **Insert at end of section**, **Consider subsections**, **Blank lines after match**, and **Create line if not found** work exactly as usual. Good to know: * You can type a heading that doesn’t exist yet; enable `Create line if not found` to have QuickAdd create it (type it with its `#` markers, e.g. `## Tasks`). * The dropdown lists ATX headings (lines starting with `#`). For a brand-new note created from a template, the picker can’t list the template’s headings (the note doesn’t exist at pick time) - type the heading and use `Create line if not found`. * With the one-page input form, the heading dropdown still appears as a separate step after the form. ### Consider subsections [Section titled “Consider subsections”](https://quickadd.obsidian.guide/docs/Choices/CaptureChoice/#consider-subsections--option) Controls whether a section’s nested subsections count as part of it when using **Insert at end of section**. Disabled - the section ends where its first subsection starts: ## 1. First heading **Insert after** comes here. - content 1- content 2- content 3 **Insert at end** comes here. ### 1.1. Nested heading 1 Content ## 2. Another heading Content Enabled - subsections belong to the section, so “end of section” is after them: ## 1. First heading **Insert after** comes here - content 1- content 2- content 3 ### 1.1. Nested heading 1 Content**Insert at end** comes here. Captures to after this, as it's considered part of the "1. First heading" section. ## 2. Another heading Content Insert before ------------- [Section titled “Insert before”](https://quickadd.obsidian.guide/docs/Choices/CaptureChoice/#insert-before) **Before line…** inserts the capture before the first line matching the text you specify. The target accepts [format syntax](https://quickadd.obsidian.guide/docs/FormatSyntax/) , so values like `{{TITLE}}` and `{{LINKCURRENT}}` work in the match text. **Create line if not found** works here too: QuickAdd writes the captured content first, then creates the missing line below it. The created line can go at the start or end of the file, or at your cursor. Capture to Canvas ----------------- [Section titled “Capture to Canvas”](https://quickadd.obsidian.guide/docs/Choices/CaptureChoice/#canvas-capture-notes) QuickAdd supports two Canvas capture workflows: * Capture to the selected card in the active Canvas view * Capture to a specific card in a specific `.canvas` file ### Capture to the selected card [Section titled “Capture to the selected card”](https://quickadd.obsidian.guide/docs/Choices/CaptureChoice/#1-capture-to-selected-card-in-active-canvas) Enabled when **Capture to active file** is on and the active view is a Canvas. Supported card targets: * Text cards * File cards that point to Markdown files ### Capture to a card in a specific file [Section titled “Capture to a card in a specific file”](https://quickadd.obsidian.guide/docs/Choices/CaptureChoice/#2-capture-to-specific-card-in-specific-canvas-file) Enabled when **Capture to active file** is off, the capture path resolves to a `.canvas` file, and **Target canvas node** is set. When the path is a `.canvas` file, QuickAdd shows a node picker so you can choose the card directly from that board. ### Write positions in Canvas [Section titled “Write positions in Canvas”](https://quickadd.obsidian.guide/docs/Choices/CaptureChoice/#write-position-support-in-canvas) * Text cards and file cards (Markdown targets) support: **Top of file**, **Bottom of file**, **After line…**, **Before line…** * Cursor-based modes (**At cursor**, **New line above/below cursor**) don’t exist in Canvas. If **Capture to active file** is on and the write position is still the default **At cursor**, the capture aborts until you switch to a supported mode. Selected-card mode needs exactly one selected card. If the selection is missing, multiple, or unsupported, QuickAdd aborts with a notice instead of writing to the wrong place. When append-link is **Enabled (requires active file)** and the capture runs from a Canvas card without a focused Markdown editor, the capture still writes and link insertion is skipped. For a step-by-step setup, see [Capture: Canvas Capture](https://quickadd.obsidian.guide/docs/Examples/Capture_CanvasCapture/) . ### Canvas capture FAQ [Section titled “Canvas capture FAQ”](https://quickadd.obsidian.guide/docs/Choices/CaptureChoice/#canvas-capture-faq) **Why did my capture abort in Canvas?** Most often: no card selected, more than one card selected, an unsupported card type, or a cursor-based write position. **Can I target a specific card in a Canvas file?** Yes - set the capture path to a `.canvas` file and choose a **Target canvas node**. **Does “At cursor” work in Canvas cards?** No. Use top, bottom, insert-after, or insert-before placement. **Can I capture to a file card that points to a Canvas file?** No - file-card capture supports Markdown targets only. **Can I still create new Canvas files from templates?** Yes. Template choices support `.canvas` templates. --- # Unknown \# Getting Started > Get started with QuickAdd: install it, pick between Template, Capture, Macro, and Multi choices, and build your first workflow QuickAdd turns your repetitive Obsidian actions - creating a note from a template, logging a line to your journal, running a script - into single commands you trigger with a hotkey. Set a workflow up once, then run it in a keystroke from anywhere in your vault. New here? Build your \[first workflow\](#first-workflow) below in about a minute. ## Install QuickAdd Install QuickAdd from Obsidian's Community Plugins browser, then enable it. If you cannot use the plugin browser, follow the \[manual installation guide\](/docs/ManualInstallation/). ## Choose the right choice type | If you want to... | Use this | Start here | | --- | --- | --- | | Create a new note from a reusable file | Template choice | \[Template Choices\](/docs/Choices/TemplateChoice/) | | Append text to a journal, log, task list, or existing file | Capture choice | \[Capture Choices\](/docs/Choices/CaptureChoice/) | | Run one or more Obsidian commands, scripts, or choices | Macro choice | \[Macro Choices\](/docs/Choices/MacroChoice/) | | Group choices into a nested menu | Multi choice | \[Multi Choices\](/docs/Choices/MultiChoice/) | | Share configured workflows across vaults | Package | \[Share QuickAdd Packages\](/docs/Choices/Packages/) | Most workflows start with either a Template choice or a Capture choice. Add a Macro choice when you need scripting, multiple steps, or data from another plugin or API. ## First workflow Let's build a capture that adds a timestamped line to your daily journal. It takes about a minute. 1. Open \*\*Settings → QuickAdd\*\*. Type a name like \`Add to journal\`, choose \*\*Capture\*\* in the dropdown, and click \*\*Add Choice\*\*. 2. Click the gear (⚙) next to your new choice to open its settings. 3. Set \*\*Capture To\*\* to \`Journal/{{DATE}}.md\` - the note today's entries land in. 4. Turn on \*\*Capture format\*\* and enter \`- {{DATE:HH:mm}} {{VALUE}}\` - the shape of one entry. 5. Close the settings. Open the command palette (Ctrl/Cmd+P), run \*\*QuickAdd: Run\*\*, pick \`Add to journal\`, and type your entry. QuickAdd writes a line like \`- 09:42 Standup moved to Wednesday\` into today's journal note, without opening it. Once it works the way you want, give it a hotkey from the ⚡ icon next to the choice or Obsidian's Hotkeys settings. The \`{{DATE}}\` and \`{{VALUE}}\` above are \[format syntax\](/docs/FormatSyntax/): placeholders QuickAdd fills in each time you run the choice. There are placeholders for dates, your answers, links, clipboard content, and more. When a prompt asks you for text, the \[suggester system\](/docs/SuggesterSystem/) lets you type \`\[\[\` or \`#\` to pull in a file, tag, or heading from your vault.\ \ ## Common paths\ \ ### I want examples first\ \ Use the \[examples overview\](/docs/Examples/) to pick a complete workflow by choice\ type, difficulty, prerequisites, and outcome.\ \ Good first examples:\ \ - \[Capture: Add entries to your daily note\](/docs/Examples/Capture\_ToDailyNote/)\ - \[Template: Add an Inbox Item\](/docs/Examples/Template\_AddAnInboxItem/)\ - \[Macro: Book Finder\](/docs/Examples/Macro\_BookFinder/)\ - \[Capture: Canvas Capture\](/docs/Examples/Capture\_CanvasCapture/)\ \ ### I want to automate with scripts\ \ Start with the \[scripting overview\](/docs/Advanced/ScriptingGuide/), then move to\ \[User Scripts\](/docs/UserScripts/) and the \[QuickAdd API reference\](/docs/QuickAddAPI/)\ when you need exact method details.\ \ ### I want to call QuickAdd from outside Obsidian\ \ Use \[Obsidian URI\](/docs/Advanced/ObsidianUri/) for URI-triggered workflows, or the\ \[QuickAdd CLI\](/docs/Advanced/CLI/) for shell scripts and external automation. --- # Multis | QuickAdd [Skip to content](https://quickadd.obsidian.guide/docs/Choices/MultiChoice/#_top) Multis ====== Copy Markdown[View as Markdown](https://quickadd.obsidian.guide/docs/Choices/MultiChoice.md) [Open in Claude](https://claude.ai/new?q=Read%20https%3A%2F%2Fquickadd.obsidian.guide%2Fdocs%2FChoices%2FMultiChoice.md%20so%20I%20can%20ask%20questions%20about%20it.) [Open in ChatGPT](https://chatgpt.com/?hints=search&q=Read%20https%3A%2F%2Fquickadd.obsidian.guide%2Fdocs%2FChoices%2FMultiChoice.md%20so%20I%20can%20ask%20questions%20about%20it.) A Multi is a **folder for your other choices**. Group related choices under one entry in the QuickAdd picker, then open it to see what’s inside - handy once your picker grows past a handful of items. In the settings list, a Multi is the entry you can fold and unfold. ![The Multi choice settings modal](https://quickadd.obsidian.guide/_astro/multi-choice.CZmFZOo4_1KMcls.webp) Put choices inside a multi -------------------------- [Section titled “Put choices inside a multi”](https://quickadd.obsidian.guide/docs/Choices/MultiChoice/#add-choices) You add a choice to a multi by **dragging it in**. Make sure the multi is unfolded (as in the screenshot above), grab the drag handle of the choice you want to move, and drop it just below and slightly to the right of the multi’s own drag handle. When it works, the choice appears indented under the multi. Set the search box hint: Placeholder text ----------------------------------------- [Section titled “Set the search box hint: Placeholder text”](https://quickadd.obsidian.guide/docs/Choices/MultiChoice/#placeholder-text) Each multi can show its own hint in the choice picker’s search box when you open it - useful for labeling a complex menu or a grouped workflow. Leave it empty and the multi’s name is used instead. Because [search reaches everything nested under the multi](https://quickadd.obsidian.guide/docs/Choices/MultiChoice/#searching-nested-choices) , word the hint for the whole group, not just the top level. Change a choice’s icon ---------------------- [Section titled “Change a choice’s icon”](https://quickadd.obsidian.guide/docs/Choices/MultiChoice/#icons) Choices in the QuickAdd picker use the same Obsidian/Lucide icons as registered QuickAdd commands. Every choice type has a default icon, and you can override it from the choice’s **Icon** setting. Icons are monochrome and take on your active Obsidian theme color. Search across nested choices ---------------------------- [Section titled “Search across nested choices”](https://quickadd.obsidian.guide/docs/Choices/MultiChoice/#searching-nested-choices) Typing in the choice picker searches every choice nested inside the current level’s multis, not just the level you are looking at. A nested match shows its folder path (for example `Work / Meetings`) beneath the choice name. This also applies to the root picker opened by the **QuickAdd: Run** command or the ribbon icon. Good to know: * Browsing is unchanged: with an empty search box, you still see one level at a time. * The search also matches the folder path, so `work meeting` finds `New meeting` inside `Work / Meetings`. * Selecting a nested multi from the results opens it. Its **← Back** entry returns to the level you searched from, skipping any levels in between. * Searching from inside a multi only covers that multi’s sub-choices. Go back (or open the root picker) to search more broadly. To limit search to the level you have open, turn off **Settings → QuickAdd → Search nested choices**. --- # Apply Template to Note | QuickAdd [Skip to content](https://quickadd.obsidian.guide/docs/ApplyTemplateToNote/#_top) Apply Template to Note ====================== Copy Markdown[View as Markdown](https://quickadd.obsidian.guide/docs/ApplyTemplateToNote.md) [Open in Claude](https://claude.ai/new?q=Read%20https%3A%2F%2Fquickadd.obsidian.guide%2Fdocs%2FApplyTemplateToNote.md%20so%20I%20can%20ask%20questions%20about%20it.) [Open in ChatGPT](https://chatgpt.com/?hints=search&q=Read%20https%3A%2F%2Fquickadd.obsidian.guide%2Fdocs%2FApplyTemplateToNote.md%20so%20I%20can%20ask%20questions%20about%20it.) Created a note manually - with `Cmd/Ctrl+N`, the Quick Switcher, or by clicking a link to a file that didn’t exist yet - and only then realized you forgot to use your template? You don’t need to delete the note and start over. QuickAdd can apply a template to a note you already have. There are two ways in: * Run **QuickAdd: Apply template to active note** from the command palette to apply a template to the note currently open. * Right-click a Markdown file (in the file explorer, a tab header, and so on) and pick **Apply QuickAdd template** to target that file directly. Either way, you pick a template, choose how it should be added, and QuickAdd fills in the placeholders and merges the frontmatter for you. How it works ------------ [Section titled “How it works”](https://quickadd.obsidian.guide/docs/ApplyTemplateToNote/#how-it-works) 1. Run the command while a Markdown note is active. 2. **Pick what to apply.** The picker lists your [Template choices](https://quickadd.obsidian.guide/docs/Choices/TemplateChoice/) first (including ones nested in Multi choices), followed by template files from your configured templates folder that aren’t already covered by a choice. 3. **Pick how to apply it** (skipped for empty notes - see [Smart behaviors](https://quickadd.obsidian.guide/docs/ApplyTemplateToNote/#smart-behaviors) ): * **Insert at cursor**: inserts the template at the cursor. Only offered when the note is open in the active editor. * **Insert at top**: inserts the template below the note’s frontmatter, or at the very top if there is none. * **Append to bottom**: adds the template content to the end of the note. * **Replace note content**: replaces the entire note with the template. The template runs through the full QuickAdd [format syntax](https://quickadd.obsidian.guide/docs/FormatSyntax/) pipeline, and Templater syntax is processed as usual. Smart behaviors --------------- [Section titled “Smart behaviors”](https://quickadd.obsidian.guide/docs/ApplyTemplateToNote/#smart-behaviors) QuickAdd handles a few common situations for you so you don’t have to think about them: * **Empty notes skip the prompt.** If the note is empty (or only whitespace), the “how to apply” step is skipped and the template becomes the note’s full content. The usual case is a freshly created blank note. * **The title fills itself in.** The note already has a name, so `{{TITLE}}` and the unnamed `{{VALUE}}` / `{{NAME}}` resolve to the note’s file name instead of prompting. Named values like `{{VALUE:project}}` still prompt as usual. * **Frontmatter merges instead of stacking.** For **Insert at top**, **Append to bottom**, and **Insert at cursor**, the template’s frontmatter is not added as a second `---` block. Missing or empty properties are filled from the template. If a property already contains one value, the note’s value wins. Properties that can contain multiple values, such as tags, aliases, and multi-text properties, keep their existing values and add any template values that are not already present. Reapplying the same template does not duplicate them. (**Replace note content** replaces the whole note, frontmatter included.) * **The note can move to match the choice.** If you picked a Template choice with a folder and/or file name format, and the note’s current location or name doesn’t match what that choice would have produced, QuickAdd offers to move or rename the note to match. Links to the note are updated automatically. This is skipped when the choice’s folder settings need a runtime folder picker, or when a file already exists at the target path. From scripts and macros ----------------------- [Section titled “From scripts and macros”](https://quickadd.obsidian.guide/docs/ApplyTemplateToNote/#from-scripts-and-macros) The [QuickAdd API](https://quickadd.obsidian.guide/docs/QuickAddAPI/) does the same thing without any prompts: await quickAddApi.applyTemplateToActiveFile("templates/meeting.md", { mode: "top", // "cursor" | "top" | "bottom" | "replace"}); When `mode` is omitted, empty notes get `replace` and non-empty notes get `bottom`. --- # Controlling Prompts | QuickAdd [Skip to content](https://quickadd.obsidian.guide/docs/ControllingPrompts/#_top) Controlling Prompts =================== Copy Markdown[View as Markdown](https://quickadd.obsidian.guide/docs/ControllingPrompts.md) [Open in Claude](https://claude.ai/new?q=Read%20https%3A%2F%2Fquickadd.obsidian.guide%2Fdocs%2FControllingPrompts.md%20so%20I%20can%20ask%20questions%20about%20it.) [Open in ChatGPT](https://chatgpt.com/?hints=search&q=Read%20https%3A%2F%2Fquickadd.obsidian.guide%2Fdocs%2FControllingPrompts.md%20so%20I%20can%20ask%20questions%20about%20it.) When a choice runs, every placeholder that needs input becomes a prompt: `{{VALUE:title}}` in a file name, `{{VDATE:due,YYYY-MM-DD}}` in a template, the target file of a Capture, and so on. This page covers everything you control about those prompts - which ones appear, the order they come in, how each one looks, how to make one skippable, the keys that submit or cancel, and the one-page form that asks everything at once. For the full syntax of each placeholder and flag, see [Format Syntax](https://quickadd.obsidian.guide/docs/FormatSyntax/) . For the one-page form in depth, see [One-page Inputs](https://quickadd.obsidian.guide/docs/Advanced/onePageInputs/) . What QuickAdd asks you ---------------------- [Section titled “What QuickAdd asks you”](https://quickadd.obsidian.guide/docs/ControllingPrompts/#where-prompts-come-from) QuickAdd prompts whenever it meets a placeholder it cannot fill on its own: * [`{{VALUE}}` / `{{VALUE:name}}`](https://quickadd.obsidian.guide/docs/FormatSyntax/#value) ask for text, or show a pick list when you give them options. * [`{{VDATE:name,format}}`](https://quickadd.obsidian.guide/docs/FormatSyntax/#vdate) asks for a date, and understands natural language like `tomorrow`. * [`{{FIELD:name}}`](https://quickadd.obsidian.guide/docs/FormatSyntax/#field) suggests values a property already has in your vault. * [`{{FILE:folder}}`](https://quickadd.obsidian.guide/docs/FormatSyntax/#file) asks you to pick a note from a folder. * Template choices may also ask for a file name or folder; Capture choices may ask which file to capture to. You are asked once per variable, per run. If `{{VALUE:title}}` appears in both the file name and the template body, you answer once and QuickAdd reuses it. A variable that already has a value never prompts: prefilled variables from a macro step, [the API](https://quickadd.obsidian.guide/docs/QuickAddAPI/) , or the [CLI](https://quickadd.obsidian.guide/docs/Advanced/CLI/) skip their prompts, and even an empty string counts as an answer. The order prompts appear in --------------------------- [Section titled “The order prompts appear in”](https://quickadd.obsidian.guide/docs/ControllingPrompts/#prompt-order) Prompts follow the structure of the choice, not where the placeholders sit in your text. Take this template: Attendees: {{VALUE:attendees}}Due: {{VDATE:due,YYYY-MM-DD}} The `due` prompt appears first, even though `attendees` comes first in the text. That is because dates are asked before named values within one piece of text. The full order: 1. **Template choices** resolve the template path first, then the folder, then the file name, and finally the template’s content. A placeholder in the file name always prompts before anything in the template body. 2. **Capture choices** resolve the capture target first, then the capture format. 3. **Within one piece of text** (a file name, a template, a capture format), prompts are grouped by kind, and only inside a kind do they follow the order they appear. The kinds run in this order: plain `{{VALUE}}`/`{{NAME}}` first, then dates (`{{VDATE}}`), then named values (`{{VALUE:name}}`), then fields (`{{FIELD}}`) and file pickers (`{{FILE}}`), with the math prompt (`{{MVALUE}}`) last. No flag reorders individual prompts. If the sequence bothers you, switch on the [one-page input form](https://quickadd.obsidian.guide/docs/ControllingPrompts/#one-form-instead-of-many-prompts) : it lists every input in one form (still in resolution order), and you fill them in whatever order you like. Change how a prompt looks ------------------------- [Section titled “Change how a prompt looks”](https://quickadd.obsidian.guide/docs/ControllingPrompts/#shape-an-individual-prompt) Each control is a flag you add to the placeholder. The most common ones: | You want | Flag | Example | | --- | --- | --- | | Helper text on the prompt | [`\|label:`](https://quickadd.obsidian.guide/docs/FormatSyntax/#value-label) | `{{VALUE:attendees\|label:Comma-separated names}}` | | A pre-filled default | [`\|default:`](https://quickadd.obsidian.guide/docs/FormatSyntax/#value-default-option) | `{{VALUE:status\|default:open}}` | | A large, multi-line text box | [`\|type:multiline`](https://quickadd.obsidian.guide/docs/FormatSyntax/#value-multiline) | `{{VALUE:notes\|type:multiline}}` | | A number, slider, or checkbox | [`\|type:number` and friends](https://quickadd.obsidian.guide/docs/FormatSyntax/#value-property-types) | `{{VALUE:rating\|type:slider\|min:0\|max:10}}` | | A pick list | [comma-separated options](https://quickadd.obsidian.guide/docs/FormatSyntax/#named-value) | `{{VALUE:low,medium,high}}` | | A pick list that also accepts custom text | [`\|custom`](https://quickadd.obsidian.guide/docs/FormatSyntax/#value-custom) | `{{VALUE:home,work\|custom}}` | | Several selections at once | [`\|multi`](https://quickadd.obsidian.guide/docs/FormatSyntax/#value-multi) | `{{VALUE:a,b,c\|multi}}` | The full reference for every flag lives in [Format Syntax](https://quickadd.obsidian.guide/docs/FormatSyntax/) . Good to know: * `|label:` works on `{{VALUE}}` placeholders and [`{{FILE:...}}`](https://quickadd.obsidian.guide/docs/FormatSyntax/#file) pickers, not on `{{VDATE}}` or `{{FIELD}}`. On a plain text prompt the label shows as helper text below the title; on a pick list it becomes the placeholder. * `|type:multiline` upgrades a single placeholder to the large text box and overrides the global **Use multi-line input prompt** setting. There is no reverse flag: with the global setting on, every plain text prompt is already multi-line. * `|type:` flags only work on single-value placeholders. A pick list ignores them. Make a prompt skippable ----------------------- [Section titled “Make a prompt skippable”](https://quickadd.obsidian.guide/docs/ControllingPrompts/#optional-prompts) Add [`|optional`](https://quickadd.obsidian.guide/docs/FormatSyntax/#optional-fields) to let a prompt be left blank, in which case it resolves to nothing: - [ ] {{VALUE:task}} {{VDATE:due,[📅 ]YYYY-MM-DD|optional}} An optional prompt gains a **Skip** button and treats an empty submission as the answer, so you are not asked again later in the run. `|optional` works on `{{VALUE}}` placeholders, option lists, `{{VDATE}}`, and `{{FILE}}`. Skipping is an answer; pressing **Esc** still cancels the whole choice. If the same variable appears in several places, put `|optional` on every occurrence - that is the one spelling that behaves the same in both the sequential prompts and the one-page form. Keys that submit, skip, and cancel ---------------------------------- [Section titled “Keys that submit, skip, and cancel”](https://quickadd.obsidian.guide/docs/ControllingPrompts/#submit-keys) | Prompt | Submit | Also useful | | --- | --- | --- | | Single-line input (also number, slider, and date prompts) | `Enter` | | | Multi-line input | `Ctrl/Cmd+Enter` (`Enter` inserts a newline) | `Tab` indents; `Shift+Tab` moves focus out | | Pick list / suggester | `Enter` picks the highlighted option | | | Math prompt ([`{{MVALUE}}`](https://quickadd.obsidian.guide/docs/FormatSyntax/#mvalue)
) | `Ctrl/Cmd+Enter` | `Tab` jumps to the cursor marker | | One-page input form | `Ctrl/Cmd+Enter` | `Tab` moves between fields | | Any optional prompt | | `Ctrl/Cmd+Shift+Enter` skips | `Esc` cancels the prompt and with it the whole run - nothing is created or captured by the cancelled choice. (In a macro, steps that already ran are not undone.) To get a notice when that happens, enable **Show input cancellation notifications** in [settings](https://quickadd.obsidian.guide/docs/Settings/#notifications) . Peek at the note ---------------- [Section titled “Peek at the note”](https://quickadd.obsidian.guide/docs/ControllingPrompts/#peek) Single-line and multi-line text prompts, plus the one-page input form, can get out of the way so you can read or select text in the open note, then come back to the same draft. * **Peek at note** on the prompt, or `Ctrl/Cmd+Shift+E` on desktop, hides the prompt without cancelling the run. On the one-page form, it hides the whole form. Everything in the prompt survives the peek: the draft, its undo history, a paste still saving, even the text you had selected in the field. * A chip stays on screen: **Insert selection** replaces the field’s selection (or drops in at the caret) and returns, **Return** comes back as-is, and **Cancel** aborts the run. On the one-page form, **Insert selection** uses the last text field you focused, or the first text field if you have not focused one. On desktop, `Ctrl/Cmd+Shift+E` also returns. Peek does not bind `Esc` in the editor, so Vim users can still leave insert mode, and your other Obsidian hotkeys keep working while the chip is up. * The command **QuickAdd: Return to prompt** is available while a peek is open. On a phone the chip is a one-line bar under the note header, so the bottom nav and home indicator stay free, and prompt actions stay on one row (Peek / Cancel / Ok) so the keyboard does not cover Cancel. * Peek appears on text prompts opened during a choice run or from the [API](https://quickadd.obsidian.guide/docs/QuickAddAPI/) , and on the one-page input form. It does not appear on QuickAdd’s own settings and builder prompts. Only one run can be parked: peeking a second prompt cancels the first, and returning waits until any other open prompt is closed. Autocomplete while you type --------------------------- [Section titled “Autocomplete while you type”](https://quickadd.obsidian.guide/docs/ControllingPrompts/#autocomplete-inside-prompts) Inside a prompt, `#` searches your vault’s tags and `[[` searches your files (headings, blocks, and relative paths work too). See [Suggester System](https://quickadd.obsidian.guide/docs/SuggesterSystem/)\ for all triggers and keys.\ \ These triggers work in single-line and multi-line prompts, and in text and textarea fields on the one-page form. Field and pick-list widgets keep their own inline suggestions.\ \ One form instead of many prompts\ --------------------------------\ \ [Section titled “One form instead of many prompts”](https://quickadd.obsidian.guide/docs/ControllingPrompts/#one-form-instead-of-many-prompts)\ \ Rather than answering prompts one at a time, QuickAdd can collect everything in a single form before the choice runs. Every unanswered variable appears as the right widget - text, textarea, date with a calendar, dropdown, slider - with optional fields badged, and Template choices with a file name format get a live file name preview.\ \ * Turn it on for everything with **One-page input for choices** under [Settings → Input](https://quickadd.obsidian.guide/docs/Settings/#input)\ .\ * Template and Capture choices each have a **One-page input override** dropdown in their builder (**Follow global setting**, **Always**, **Never**), so you can flip the form on or off for one choice.\ * A few inputs still run as follow-up steps after the form, such as [`{{FIELD:...|multi}}`](https://quickadd.obsidian.guide/docs/FormatSyntax/#field-multi)\ pickers and Capture’s insert-after heading picker.\ * Cancelling the form cancels the whole run, exactly like cancelling a sequential prompt.\ \ The full behavior - what is collected, date parsing, defaults, and script-declared inputs - is documented in [One-page Inputs](https://quickadd.obsidian.guide/docs/Advanced/onePageInputs/)\ .\ \ For script authors\ ------------------\ \ [Section titled “For script authors”](https://quickadd.obsidian.guide/docs/ControllingPrompts/#for-script-authors)\ \ User scripts can declare their inputs so they appear in the one-page form (`quickadd.inputs`), and can open a one-page form of their own at runtime with [`quickAddApi.requestInputs`](https://quickadd.obsidian.guide/docs/QuickAddAPI/)\ . Both are covered in [One-page Inputs](https://quickadd.obsidian.guide/docs/Advanced/onePageInputs/#user-scripts-declare-inputs-optional)\ . --- # Variables and data flow | QuickAdd [Skip to content](https://quickadd.obsidian.guide/docs/VariablesDataFlow/#_top) Variables and data flow ======================= Copy Markdown[View as Markdown](https://quickadd.obsidian.guide/docs/VariablesDataFlow.md) [Open in Claude](https://claude.ai/new?q=Read%20https%3A%2F%2Fquickadd.obsidian.guide%2Fdocs%2FVariablesDataFlow.md%20so%20I%20can%20ask%20questions%20about%20it.) [Open in ChatGPT](https://chatgpt.com/?hints=search&q=Read%20https%3A%2F%2Fquickadd.obsidian.guide%2Fdocs%2FVariablesDataFlow.md%20so%20I%20can%20ask%20questions%20about%20it.) When a choice runs, QuickAdd keeps one scratchpad of named values for that run. Prompts, scripts, and AI Assistant commands write values onto it; placeholders like `{{VALUE:project}}` read them back. In a Macro, every step shares the same scratchpad in order, so an answer you give in one step is available to every step after it. This page is about those **run variables** - the temporary values that exist only while a Template, Capture, or Macro run is executing. For saved, reusable snippets that persist across runs, see [Global Variables](https://quickadd.obsidian.guide/docs/GlobalVariables/) instead. The exact placeholder grammar lives in [Format Syntax](https://quickadd.obsidian.guide/docs/FormatSyntax/) ; this page is about how values move between steps. At a glance, here is what writes a run variable and what reads it back: | Written by | Read by | | --- | --- | | A prompt, such as `{{VALUE:project}}` or `{{VDATE:due,YYYY-MM-DD}}` | `{{VALUE:project}}` in a later field or step | | A user script (`params.variables.slug = "..."`) | `{{VALUE:slug}}`, or `params.variables.slug` in another script | | An AI Assistant command’s **Output variable name** | `{{VALUE:output}}` | | A script, the CLI, or the API supplying a value up front | any placeholder that would otherwise prompt | Write once, use everywhere -------------------------- [Section titled “Write once, use everywhere”](https://quickadd.obsidian.guide/docs/VariablesDataFlow/#write-values-once) Give a value a **name** when the same answer should appear in more than one place. QuickAdd asks for it once and reuses your answer everywhere the name appears: File name format: Projects/{{VALUE:project}}Template body: # {{VALUE:project}}Capture format: Logged work for {{VALUE:project}} If `project` isn’t set yet, QuickAdd asks once and stores your answer under `project`. Every later `{{VALUE:project}}` in the same run reads that stored answer instead of asking again. This works across a Template file name, the Template body, Capture formats, and later Macro steps. If a script, the CLI, or the QuickAdd API supplies `project` before the placeholder is formatted, the placeholder uses that value and never asks. A key that is absent or set to `undefined` counts as missing; an empty string counts as a deliberate empty answer. When the prompt should be a picker, define the options once with a name, then reuse the name on its own: {{VALUE:work,home,urgent|name:category}}{{VALUE:category}} See [`{{VALUE:|name:}}`](https://quickadd.obsidian.guide/docs/FormatSyntax/#value-name) for option lists, display labels, first-definition behavior, and reserved names. The unnamed answer: `{{VALUE}}` ------------------------------- [Section titled “The unnamed answer: {{VALUE}}”](https://quickadd.obsidian.guide/docs/VariablesDataFlow/#the-special-value-input) The unnamed `{{VALUE}}` reads a special variable called `value`. It’s meant for one-off input, or for a trigger that already supplied some content: {{VALUE}} This is **not** the same as `{{VALUE:project}}`. If an answer needs to survive across several Macro steps, copy it into a named key and read that instead: module.exports = async (params) => { if (params.variables.value !== undefined) { params.variables.project = params.variables.value; }}; Later steps can then use: {{VALUE:project}} Sharing values with a script ---------------------------- [Section titled “Sharing values with a script”](https://quickadd.obsidian.guide/docs/VariablesDataFlow/#scripts-share-the-map) A user script in a Macro receives `params.variables` - the same scratchpad the placeholders read from. Write to it, and later steps see your values: module.exports = async (params) => { const title = await params.quickAddApi.inputPrompt("Title"); params.variables.title = title; params.variables.slug = title.toLowerCase().replace(/\s+/g, "-");}; Later Macro steps can read them: # {{VALUE:title}}Slug: {{VALUE:slug}} Two things trip people up here: * **A plain JavaScript variable isn’t enough.** Only values written onto `params.variables` are visible to later steps. A `const title = "Inbox"` stays private to that one script; `params.variables.title = title` is what makes it available. * **Order matters.** A script must run _before_ the Template, Capture, or script step that reads its variables. Inline scripts run first ------------------------ [Section titled “Inline scripts run first”](https://quickadd.obsidian.guide/docs/VariablesDataFlow/#inline-scripts) Inline scripts run **before** the ordinary placeholders around them, so an inline script can’t read a value the surrounding output is still about to prompt for. This does not do what it looks like: const value = "{{VALUE:project}}"; While the inline script runs, that’s just literal text - the placeholder hasn’t been filled in yet. If the script needs input-aware logic, prompt inside the script, or read a variable an earlier step already set: const project = this.variables.project;return project ? `Project: ${project}` : ""; Reading an AI Assistant’s output -------------------------------- [Section titled “Reading an AI Assistant’s output”](https://quickadd.obsidian.guide/docs/VariablesDataFlow/#ai-assistant-outputs) An AI Assistant Macro command writes its response to the variable named in its **Output variable name** setting. The default name is `output`, so later steps can read: {{VALUE:output}} or, in a script: module.exports = async (params) => { console.log(params.variables.output);}; QuickAdd also writes a quote-block version under `-quoted`. With the default output name that’s: {{VALUE:output-quoted}} If you renamed the output variable to `description`, read `{{VALUE:description}}` and `{{VALUE:description-quoted}}` instead. Both are available to later steps in the same Macro run. `executeChoice` is a trigger, not a function call ------------------------------------------------- [Section titled “executeChoice is a trigger, not a function call”](https://quickadd.obsidian.guide/docs/VariablesDataFlow/#executechoice-is-a-trigger) The Macro Builder’s **Choice** command and the API method `quickAddApi.executeChoice` look similar but behave differently. A **Choice** command added inside a Macro runs as part of that Macro’s sequence and shares the Macro’s scratchpad with the steps after it. `quickAddApi.executeChoice(choiceName, variables)` is a **one-way trigger**. It passes the variables you give it into the target choice, waits for that choice to finish, and resolves with `undefined` - it does **not** hand the target choice’s output back to the caller. After the target finishes, QuickAdd clears the temporary variables that execution used. So if you call it from a Macro script, don’t expect your current `params.variables` to still be around afterward unless you saved and restored them yourself. Use it to trigger another choice with input: module.exports = async (params) => { await params.quickAddApi.executeChoice("Create project note", { project: params.variables.project, });}; Don’t expect a return value back from it: module.exports = async (params) => { const result = await params.quickAddApi.executeChoice("Pick project"); params.variables.project = result; // result is undefined}; When later steps need a value, keep the workflow inside one Macro sequence, set `params.variables` directly, or call a shared JavaScript helper that returns the value to your script. Troubleshooting --------------- [Section titled “Troubleshooting”](https://quickadd.obsidian.guide/docs/VariablesDataFlow/#troubleshooting) **The same prompt appears more than once.** Use the same named placeholder everywhere, such as `{{VALUE:project}}`. A bare `{{VALUE}}` and a named `{{VALUE:project}}` are different inputs. **A script value is missing in a later Template or Capture.** Set it on `params.variables`, not only in a local JavaScript variable, and make sure the script step runs before the step that reads it. **A placeholder stayed as literal text.** The syntax is `{{VALUE:name}}`. A bare `{{name}}` is not a QuickAdd placeholder. **An AI result is missing.** Check the AI Assistant command’s **Output variable name**, then read that exact variable in a later Macro step. **`executeChoice` returned `undefined`.** That’s expected. Use `executeChoice` to trigger another choice with input variables, not to fetch a return value from it. --- # Global Variables | QuickAdd [Skip to content](https://quickadd.obsidian.guide/docs/GlobalVariables/#_top) Global Variables ================ Copy Markdown[View as Markdown](https://quickadd.obsidian.guide/docs/GlobalVariables.md) [Open in Claude](https://claude.ai/new?q=Read%20https%3A%2F%2Fquickadd.obsidian.guide%2Fdocs%2FGlobalVariables.md%20so%20I%20can%20ask%20questions%20about%20it.) [Open in ChatGPT](https://chatgpt.com/?hints=search&q=Read%20https%3A%2F%2Fquickadd.obsidian.guide%2Fdocs%2FGlobalVariables.md%20so%20I%20can%20ask%20questions%20about%20it.) A global variable is a named snippet you define once in QuickAdd’s settings and reuse anywhere QuickAdd fills in placeholders. Keep your list of projects, a folder path, or a block of boilerplate in one place, then drop it into any choice or template with `{{GLOBAL_VAR:}}`. Edit the snippet in settings and every choice that uses it updates at once. Unlike a [run variable](https://quickadd.obsidian.guide/docs/VariablesDataFlow/) , which lives only while one choice is running, a global variable is saved with your vault and available to every choice, every time. For example, define a snippet named `Signature`: Name: SignatureValue: Logged by QuickAdd on {{DATE:YYYY-MM-DD}} Then use it in a capture or template: {{GLOBAL_VAR:Signature}} Logged by QuickAdd on 2026-07-08 Snippets can hold other placeholders (like the `{{DATE}}` above), so a global variable can be a fixed string, a small template, or a reusable option list. Good places to use one: * A single list of projects, tags, or folders reused across many choices and templates * Constants you’d otherwise retype: paths, emojis, boilerplate text, or a YAML block Define a global variable ------------------------ [Section titled “Define a global variable”](https://quickadd.obsidian.guide/docs/GlobalVariables/#define) 1. Open **Settings → QuickAdd → Global variables**. 2. Add a **name** and a **value**. The value is free text and supports all of [format syntax](https://quickadd.obsidian.guide/docs/FormatSyntax/) . 3. That’s it - changes save automatically as you type. Use it anywhere: `{{GLOBAL_VAR:}}` ---------------------------------------- [Section titled “Use it anywhere: {{GLOBAL\_VAR:}}”](https://quickadd.obsidian.guide/docs/GlobalVariables/#use) Write `{{GLOBAL_VAR:}}` and QuickAdd replaces it with that snippet’s value. It works everywhere QuickAdd formats text: | Where | Which fields | | --- | --- | | **Template choice** | File name format, folder paths, template content | | **Capture choice** | Target path, content formatting | | **Macros** | Inline formatting strings | Good to know: * The name after `GLOBAL_VAR:` matches **case-insensitively**, so `{{global_var:Signature}}` also works. The stored key itself is case-sensitive, which is why you should avoid defining two variables whose names differ only in case. * A name that doesn’t match any global variable becomes an **empty string** rather than erroring. Put other placeholders inside a snippet --------------------------------------- [Section titled “Put other placeholders inside a snippet”](https://quickadd.obsidian.guide/docs/GlobalVariables/#nested-tokens) A snippet’s value can contain any QuickAdd placeholder - `{{VALUE:...}}`, `{{VDATE:...}}`, `{{FIELD:...}}`, `{{RANDOM:n}}`, and so on. When the snippet is inserted, those placeholders run just like they would if you’d typed them directly. Name: MyProjectsValue: {{VALUE:Inbox,Work,Personal,Archive}} Projects/{{GLOBAL_VAR:MyProjects}}/{{DATE:YYYY}}/ Running a choice that uses `MyProjects` shows the `Inbox / Work / Personal / Archive` picker, and your pick lands in the path. Good to know: * A snippet can reference **another global variable**. QuickAdd resolves up to 5 levels of nesting, so an accidental loop stops instead of hanging. * Globals expand **early** in the formatter, so any placeholders inside a snippet are processed by the passes that follow. * The [one-page input form](https://quickadd.obsidian.guide/docs/Advanced/onePageInputs/) looks inside your snippets too, so prompts they introduce (like `{{VALUE:...}}`) appear up front with the rest. --- # Macros | QuickAdd [Skip to content](https://quickadd.obsidian.guide/docs/Choices/MacroChoice/#_top) Macros ====== Copy Markdown[View as Markdown](https://quickadd.obsidian.guide/docs/Choices/MacroChoice.md) [Open in Claude](https://claude.ai/new?q=Read%20https%3A%2F%2Fquickadd.obsidian.guide%2Fdocs%2FChoices%2FMacroChoice.md%20so%20I%20can%20ask%20questions%20about%20it.) [Open in ChatGPT](https://chatgpt.com/?hints=search&q=Read%20https%3A%2F%2Fquickadd.obsidian.guide%2Fdocs%2FChoices%2FMacroChoice.md%20so%20I%20can%20ask%20questions%20about%20it.) A macro chains several QuickAdd actions into one command you can run from the palette or a hotkey. Instead of running a template, then a capture, then a script by hand, a macro runs them in order and passes data from one step to the next. Reach for a macro when a single choice isn’t enough. Use it to: * Ask a question once and reuse the answer across several steps * Run your own JavaScript to talk to the Obsidian API or another plugin * Branch the workflow based on what you picked or what a script returns * Kick off a routine automatically when Obsidian starts Macros are QuickAdd’s most capable - and most technical - choice type. You don’t need to be a programmer to start: the walkthrough below uses no code at all. The deeper sections assume you’re comfortable with a little JavaScript. What is a macro? ---------------- [Section titled “What is a macro?”](https://quickadd.obsidian.guide/docs/Choices/MacroChoice/#what-are-macros) A **macro** is a list of commands that run one after another. Each macro is paired with a **macro choice**, the entry that shows up in the QuickAdd menu and gives you something to trigger. ### The pieces [Section titled “The pieces”](https://quickadd.obsidian.guide/docs/Choices/MacroChoice/#key-concepts) * **Macro choice** - the trigger that appears in the QuickAdd menu. * **Macro** - the actual sequence of commands that runs. * **Commands** - the individual steps (Obsidian commands, scripts, AI prompts, and more). * **Variables** - data that one command sets and a later command reads, all within a single run. Set up your first macro ----------------------- [Section titled “Set up your first macro”](https://quickadd.obsidian.guide/docs/Choices/MacroChoice/#creating-a-macro) We’ll build a tiny macro with no code: it opens today’s daily note and drops your cursor at the end, ready to type. Two commands, run as one. ### Step 1: Create the macro choice [Section titled “Step 1: Create the macro choice”](https://quickadd.obsidian.guide/docs/Choices/MacroChoice/#step-1-create-a-macro-choice) 1. Open **Settings → QuickAdd**, type a name like `Open daily note`, choose **Macro** in the dropdown, and click **Add Choice**. 2. Click the gear (⚙) next to the new choice to open the Macro Builder. ![The Macro builder](https://quickadd.obsidian.guide/_astro/macro-builder.CGRxKy4q_1m6Sep.webp) ### Step 2: Build the macro [Section titled “Step 2: Build the macro”](https://quickadd.obsidian.guide/docs/Choices/MacroChoice/#step-2-build-your-macro) 1. In the Macro Builder, add an **Obsidian Command** and pick `Daily notes: Open today's daily note`. 2. Add an **Editor commands** entry and choose **Move cursor to file end**. 3. Close the builder, then run it: command palette → `QuickAdd: Run` → `Open daily note`. Your daily note opens and the cursor sits at the end of the file, ready for the next line - both steps in a single command. Assign the choice a hotkey (the ⚡ icon, or Obsidian’s Hotkeys settings) once it behaves the way you want. The commands you can add ------------------------ [Section titled “The commands you can add”](https://quickadd.obsidian.guide/docs/Choices/MacroChoice/#command-types) The Macro Builder offers these command types. Add as many as you like, in any order. | Command | What it does | | --- | --- | | **Obsidian Command** | Run any Obsidian command, for example `Daily notes: Open today's daily note` or `Toggle reading view`. | | **Editor commands** | Manipulate text in the active editor: copy, cut, paste, [paste with format](https://quickadd.obsidian.guide/docs/Choices/MacroChoice/#paste-with-format)
, select the line or a link on it, and move the cursor. See [Editor commands](https://quickadd.obsidian.guide/docs/Choices/MacroChoice/#editor-commands)
. | | **User Script** | Run your own JavaScript to reach the Obsidian API, do complex work, or integrate with other plugins. See [Add a user script command](https://quickadd.obsidian.guide/docs/Choices/MacroChoice/#add-a-user-script-command)
. | | **Nested Choice** | Run another QuickAdd choice - a template, capture, or another macro - so you can reuse existing work and build modular workflows. | | **Wait** | Pause for a set number of milliseconds, useful when a previous command needs time to finish. | | **AI Assistant** | Run an AI prompt to generate or process content. Available once you’ve configured an AI provider. | | **Open File** | Open an existing file at a formatted path. Supports all [format syntax](https://quickadd.obsidian.guide/docs/FormatSyntax/)
(`{{DATE}}`, `{{VALUE}}`, and so on), with tab and split options. It opens in the default view mode with focus, and only opens files that already exist (it won’t create one). | | **Conditional** | Branch the run based on live data. See [Branch with a conditional](https://quickadd.obsidian.guide/docs/Choices/MacroChoice/#conditional-commands)
. | ### Add a user script command [Section titled “Add a user script command”](https://quickadd.obsidian.guide/docs/Choices/MacroChoice/#add-a-user-script-command) Macros don’t contain JavaScript directly. Your code lives either in a `.js` file inside your vault **or** in a ` ```js ` code block inside a note, and the macro simply runs it. The note option is handy on mobile, where Obsidian cannot open `.js` files - see [User Scripts](https://quickadd.obsidian.guide/docs/UserScripts/#scripts-in-a-note-code-block) . Create a script file such as `scripts/my-macro.js`, or a note such as `Scripts/my-macro.md` with your code in a ` ```js ` (or ` ```javascript `) block. QuickAdd runs the **first** matching JavaScript block in a note and ignores the surrounding prose. To add it, open the Macro Builder and add a **User Script** command. There are two ways to point it at your script: * **Browse** opens QuickAdd’s script picker (not your operating system’s file picker). It lists the `.js` files and notes-with-a-code-block that Obsidian has already discovered, so it can’t reach files outside the vault or hidden from Obsidian’s index. * **Type it in.** For a `.js` file, type its basename - for `scripts/my-macro.js`, enter `my-macro`. For a note, type its vault path, for example `Scripts/my-macro.md`. Then click **Add**. To run a specific exported function, append it with `::`, such as `my-macro::start`. If the script exports more than one function and you don’t name one, QuickAdd asks which export to run. You can also set an output variable name so later commands can reuse the result. Good to know: * To **insert text into a note**, don’t write it in a script. Use a **Template** or **Capture** choice and run it from the macro as a **Nested Choice** command. That’s the intended way to write content, and no YAML frontmatter is required. * If your script calls the API of another plugin, that plugin must be installed and enabled in your vault. You don’t need any extra plugin just to run user scripts. ### Branch with a conditional [Section titled “Branch with a conditional”](https://quickadd.obsidian.guide/docs/Choices/MacroChoice/#conditional-commands) A conditional command lets your macro take one path or another without writing boilerplate JavaScript. Each conditional has: * **Condition mode** - compare a macro variable, or run a script that returns `true`/`false`. * **Variable comparisons** - test a variable with operators like equals, contains, less than, greater than, or a basic truthiness check. The value type (text, number, boolean) controls how the two sides are compared. * **Script mode** - point to a JavaScript file in your vault (with an optional exported function) that returns a boolean. The script gets the same parameters as any user script, including your macro variables and `params.abort`. * **Branch editors** - the commands that run when the condition passes (**Then**) or fails (**Else**). Each branch is a full command sequence, so you can nest more conditionals or reuse any command type. To add one: 1. Click the branch icon in the command bar of the Macro Builder (or of any conditional branch editor). 2. Click the settings icon on the new command to define the condition. 3. Use the branch buttons to set the commands that run for the **Then** and **Else** outcomes. The macro runs the matching branch in order, then continues with the rest of the macro. Branch commands share the same variable map as the outer macro, so they can read or update variables for later steps. Editor commands --------------- [Section titled “Editor commands”](https://quickadd.obsidian.guide/docs/Choices/MacroChoice/#editor-commands) Editor commands manipulate text in the active editor. ### Paste with format [Section titled “Paste with format”](https://quickadd.obsidian.guide/docs/Choices/MacroChoice/#paste-with-format) **Paste with format** preserves rich formatting when you paste from an external source. Unlike the standard paste, which handles plain text only, it: * **Detects HTML** in your clipboard * **Converts it to Markdown** using Obsidian’s built-in conversion * **Preserves formatting** like links, bold, italics, headers, and lists * **Falls back gracefully** to plain text when no HTML is available What that looks like in practice: | You copy | You paste | | --- | --- | | A formatted link from a webpage | `[Link Text](https://example.com)` | | Text with bold/italic | **bold** and _italic_ preserved | | A bulleted list | A proper Markdown list | | A table from a website | A Markdown table | ### The other editor commands [Section titled “The other editor commands”](https://quickadd.obsidian.guide/docs/Choices/MacroChoice/#other-editor-commands) * **Copy / Cut / Paste** - standard clipboard operations. * **Select active line** - select the whole line the cursor is on. * **Select link on active line** - find and select a link on the current line. * **Move cursor to file start / file end** - jump to the beginning or end of the file. * **Move cursor to line start / line end** - jump to the beginning or end of the current line. User scripts ------------ [Section titled “User scripts”](https://quickadd.obsidian.guide/docs/Choices/MacroChoice/#user-scripts) A user script extends a macro with custom JavaScript, written either in a `.js` file or in a ` ```js ` code block inside a note. Scripts have access to: * The Obsidian `app` object * The QuickAdd API * A `variables` object for passing data between commands The basic shape is an exported async function - QuickAdd calls it with a `params` object that carries everything you need: module.exports = async (params) => { // Destructure the parameters const { app, quickAddApi, variables } = params; // Your code here console.log("Hello from my macro!"); // Set a variable for use in later commands variables.myResult = "Some value";}; Everything else about writing scripts lives in the [User Scripts reference](https://quickadd.obsidian.guide/docs/UserScripts/) : * [Where a script can live](https://quickadd.obsidian.guide/docs/UserScripts/#adding-scripts-to-macros) - `.js` file or note code block, and which folders QuickAdd’s picker can see. * [Prompt the user](https://quickadd.obsidian.guide/docs/UserScripts/#user-input) - input prompts, suggesters, yes/no, and checkbox prompts via `quickAddApi`; the full method list is in the [QuickAdd API](https://quickadd.obsidian.guide/docs/QuickAddAPI/) . * [Read the editor selection](https://quickadd.obsidian.guide/docs/QuickAddAPI/#getselection-string) - `quickAddApi.utility.getSelection()`. * [Reach into other plugins](https://quickadd.obsidian.guide/docs/UserScripts/#accessing-other-plugins) - talk to Templater, MetaEdit, or any plugin through `app.plugins.plugins`. * [Offer several actions from one script](https://quickadd.obsidian.guide/docs/UserScripts/#multiple-entry-points) - export more than one function and pick at run time. * [Configurable settings](https://quickadd.obsidian.guide/docs/UserScripts/#configurable-options) , [error handling and `abort()`](https://quickadd.obsidian.guide/docs/UserScripts/#error-handling-and-macro-control) , and a shelf of [copy-paste recipes](https://quickadd.obsidian.guide/docs/UserScripts/#common-patterns--recipes) . Pass data between commands: variables ------------------------------------- [Section titled “Pass data between commands: variables”](https://quickadd.obsidian.guide/docs/Choices/MacroChoice/#variables-and-data-flow) Every command in a macro shares one temporary variable map for the current run. A user script can write `params.variables.bookTitle`, and a later Template or Capture command can read it back as `{{VALUE:bookTitle}}`. For the full rules - named `VALUE` prompts, empty values, AI Assistant output variables, and the `executeChoice` boundary - see [Variables and data flow](https://quickadd.obsidian.guide/docs/VariablesDataFlow/) . Run one export directly: `Macro::member` ---------------------------------------- [Section titled “Run one export directly: Macro::member”](https://quickadd.obsidian.guide/docs/Choices/MacroChoice/#direct-function-access) When a script [exports several functions](https://quickadd.obsidian.guide/docs/UserScripts/#multiple-entry-points) , QuickAdd normally asks which one to run. You can skip that prompt by naming the function: * `{{MACRO:MyMacro::option1}}` runs `option1` directly. * `{{MACRO:MyMacro::start}}` runs the `start` function. When a macro has more than one user script, `Macro::member` picks the script that uniquely exports the requested member across all scripts in the macro. QuickAdd resolves it like this: * If exactly one script exports the member, QuickAdd uses it. * If no script exports the member, QuickAdd stops and shows an error. * Exception: if the macro has no user-script commands at all, QuickAdd can’t satisfy member access - it logs a warning and returns an empty result instead of stopping the macro. * If several scripts export the member, QuickAdd stops and lists the conflicting script names instead of guessing. * Exception: the convention keys `settings`, `entry`, and `quickadd` (which many scripts export as metadata rather than entrypoints) resolve to the **first** script that exports them and show a one-time notice pointing at the selector form below, rather than stopping. Use the selector if you need a different script. When there’s a conflict, target a specific script by name: * `{{MACRO:MyMacro::Script 1::option1}}` The selector uses the macro command name shown in the editor. If two user-script commands share the same name, rename one before using the selector form. Macro settings -------------- [Section titled “Macro settings”](https://quickadd.obsidian.guide/docs/Choices/MacroChoice/#macro-settings) ![The Macro builder, including the Run on startup toggle](https://quickadd.obsidian.guide/_astro/macro-builder.CGRxKy4q_1m6Sep.webp) ### Which day [Section titled “Which day”](https://quickadd.obsidian.guide/docs/Choices/MacroChoice/#date-origin) Same [Which day](https://quickadd.obsidian.guide/docs/Choices/TemplateChoice/#date-origin) setting as a Template. Child choices in the macro inherit that day, so a weekly pack can ask once and then write every template for last week. ### Run on startup [Section titled “Run on startup”](https://quickadd.obsidian.guide/docs/Choices/MacroChoice/#run-on-startup) Enable this to run a macro automatically when Obsidian starts. Handy for: * Creating a daily note automatically * Setting up your workspace * Running maintenance tasks ### Command palette [Section titled “Command palette”](https://quickadd.obsidian.guide/docs/Choices/MacroChoice/#command-palette) **Add to command palette** is the same switch as the lightning bolt in the choice list. Once it is on, and Which day isn’t **Ask each time**, **Also add “Name (pick a day)”** registers a second command that asks which day before the macro runs. See [Command palette](https://quickadd.obsidian.guide/docs/Choices/TemplateChoice/#command-palette) on the Template page. Practical examples ------------------ [Section titled “Practical examples”](https://quickadd.obsidian.guide/docs/Choices/MacroChoice/#practical-examples) ### Example 1: Log a book to your daily note [Section titled “Example 1: Log a book to your daily note”](https://quickadd.obsidian.guide/docs/Choices/MacroChoice/#example-1-book-logging-macro) Prompt for a book name and write it into today’s daily note (using the MetaEdit plugin): module.exports = async (params) => { const { quickAddApi: { inputPrompt }, app } = params; // Get book name from user const bookName = await inputPrompt("📖 Book Name"); // Get MetaEdit plugin const { update } = app.plugins.plugins["metaedit"].api; // Format today's date const date = window.moment().format("YYYY-MM-DD"); // Update the daily note await update("Book", bookName, `Daily Notes/${date}.md`);}; ### Example 2: Create a task with priority [Section titled “Example 2: Create a task with priority”](https://quickadd.obsidian.guide/docs/Choices/MacroChoice/#example-2-task-management-macro) Ask for a task and a priority, then hand them to a later Template command as variables: module.exports = async (params) => { const { quickAddApi, app, variables } = params; // Get task details const task = await quickAddApi.inputPrompt("Task description:"); const priority = await quickAddApi.suggester( ["🔴 High", "🟡 Medium", "🟢 Low"], ["high", "medium", "low"] ); // Set variables for use in template variables.taskDescription = task; variables.taskPriority = priority; variables.taskCreated = new Date().toISOString(); // Create task note using template (in next macro command)}; ### Example 3: Scaffold a research workspace [Section titled “Example 3: Scaffold a research workspace”](https://quickadd.obsidian.guide/docs/Choices/MacroChoice/#example-3-research-workflow) Chain several operations: create a folder structure for a topic, then set variables for a later template step to fill an overview note. module.exports = async (params) => { const { quickAddApi, app, variables } = params; // Get research topic const topic = await quickAddApi.inputPrompt("Research topic:"); // Create folder structure const vault = app.vault; const researchFolder = `Research/${topic}`; // Check if folder exists if (!await vault.adapter.exists(researchFolder)) { await vault.createFolder(researchFolder); await vault.createFolder(`${researchFolder}/Sources`); await vault.createFolder(`${researchFolder}/Notes`); } // Set variables for template variables.researchTopic = topic; variables.researchFolder = researchFolder; // Next commands in macro will create the overview note}; When a macro stops ------------------ [Section titled “When a macro stops”](https://quickadd.obsidian.guide/docs/Choices/MacroChoice/#macro-execution-control) ### What stops a macro [Section titled “What stops a macro”](https://quickadd.obsidian.guide/docs/Choices/MacroChoice/#automatic-abort-behavior) A macro stops early in three situations: 1. **You cancel** - press Escape or click Cancel in any prompt. 2. **A script errors** - an unhandled error is thrown in a user script. 3. **A script aborts on purpose** - `params.abort()` is called. When a macro stops: * Every remaining command is skipped. * A message is logged explaining why. * For your own cancel and for explicit aborts, no error dialog appears. * For a script error, the full error and stack trace are kept for debugging. Best practices -------------- [Section titled “Best practices”](https://quickadd.obsidian.guide/docs/Choices/MacroChoice/#best-practices) ### 1\. Handle errors [Section titled “1. Handle errors”](https://quickadd.obsidian.guide/docs/Choices/MacroChoice/#1-error-handling) Wrap script work in `try`/`catch` so a failure is visible and stops the rest of the macro: module.exports = async (params) => { try { // Your code here } catch (error) { console.error("Macro error:", error); new Notice(`Macro failed: ${error.message}`); throw error; // Re-throw to stop remaining macro commands }}; ### 2\. Check for plugin dependencies [Section titled “2. Check for plugin dependencies”](https://quickadd.obsidian.guide/docs/Choices/MacroChoice/#2-check-for-plugin-dependencies) Confirm a required plugin is present before you use it: module.exports = async (params) => { const { app } = params; const requiredPlugin = app.plugins.plugins["plugin-id"]; if (!requiredPlugin) { new Notice("Required plugin not found!"); return; } // Continue with plugin operations}; ### 3\. Use meaningful variable names [Section titled “3. Use meaningful variable names”](https://quickadd.obsidian.guide/docs/Choices/MacroChoice/#3-use-meaningful-variable-names) Descriptive names keep a macro readable: * ✅ `variables.projectName` * ✅ `variables.meetingDate` * ❌ `variables.var1` * ❌ `variables.temp` ### 4\. Keep it modular [Section titled “4. Keep it modular”](https://quickadd.obsidian.guide/docs/Choices/MacroChoice/#4-modular-design) Break a complex macro into smaller, reusable parts: * Put distinct operations in separate scripts. * Reuse existing choices with **Nested Choice** commands. * Keep each script focused on a single purpose. Troubleshooting --------------- [Section titled “Troubleshooting”](https://quickadd.obsidian.guide/docs/Choices/MacroChoice/#troubleshooting) ### Common issues [Section titled “Common issues”](https://quickadd.obsidian.guide/docs/Choices/MacroChoice/#common-issues) **“Syntax error: unexpected identifier”** * Usually a JavaScript syntax error in your script. * Check for a missing semicolon, bracket, or quote. * See [issue #417](https://github.com/chhoumann/quickadd/issues/417) for detailed solutions. **“Cannot read property of undefined”** * A plugin or API you’re reaching for doesn’t exist. * Add a null check before you use a plugin’s API. * Make sure the plugin is enabled before you run the macro. **Variables not passing between commands** * Use a named placeholder such as `{{VALUE:sharedName}}`, or set `params.variables.sharedName`, for values later steps need. * Make sure the script runs _before_ the command that reads its variables. * See [Variables and data flow](https://quickadd.obsidian.guide/docs/VariablesDataFlow/) for the full model. **Macro not appearing in command palette** * Make sure the macro choice is enabled in settings. * Restart Obsidian if you just created the macro. * Check that QuickAdd is enabled in Community Plugins. Tips and tricks --------------- [Section titled “Tips and tricks”](https://quickadd.obsidian.guide/docs/Choices/MacroChoice/#tips-and-tricks) 1. **Test incrementally** - build the macro one command at a time, testing each. 2. **Use `console.log`** - log values to the developer console while debugging. 3. **Keep scripts in your vault** - so you can version and back them up. 4. **Share macros** - export and import macro configurations with other users. 5. **Combine with hotkeys** - assign a shortcut to a macro you run often. See also -------- [Section titled “See also”](https://quickadd.obsidian.guide/docs/Choices/MacroChoice/#see-also) * [Template Choices](https://quickadd.obsidian.guide/docs/Choices/TemplateChoice/) - for creating new notes * [Capture Choices](https://quickadd.obsidian.guide/docs/Choices/CaptureChoice/) - for appending to existing notes * [Format Syntax](https://quickadd.obsidian.guide/docs/FormatSyntax/) - available placeholders * [QuickAdd API](https://quickadd.obsidian.guide/docs/QuickAddAPI/) - detailed API documentation * [Examples](https://quickadd.obsidian.guide/docs/Examples/Macro_BookFinder/) - pre-built macro examples --- # Format syntax | QuickAdd [Skip to content](https://quickadd.obsidian.guide/docs/FormatSyntax/#_top) Format syntax ============= Copy Markdown[View as Markdown](https://quickadd.obsidian.guide/docs/FormatSyntax.md) [Open in Claude](https://claude.ai/new?q=Read%20https%3A%2F%2Fquickadd.obsidian.guide%2Fdocs%2FFormatSyntax.md%20so%20I%20can%20ask%20questions%20about%20it.) [Open in ChatGPT](https://chatgpt.com/?hints=search&q=Read%20https%3A%2F%2Fquickadd.obsidian.guide%2Fdocs%2FFormatSyntax.md%20so%20I%20can%20ask%20questions%20about%20it.) Format syntax lets you put **placeholders** in anything QuickAdd creates. When a choice runs, each placeholder is replaced with a real value: today’s date, an answer you type, a link to the note you came from. You can use placeholders anywhere QuickAdd asks for a format: file name fields, capture formats, folder paths, “Insert after” targets, and inside template files. For example, a Capture with this format: - {{DATE:HH:mm}} {{VALUE}} asks you for a value, and if you answer `Standup moved to Wednesday`, it inserts: - 09:42 Standup moved to Wednesday You describe the shape once; QuickAdd fills in the blanks every run. Quick reference --------------- [Section titled “Quick reference”](https://quickadd.obsidian.guide/docs/FormatSyntax/#quick-reference) **Ask for input** | Placeholder | What it does | | --- | --- | | [`{{VALUE}}`](https://quickadd.obsidian.guide/docs/FormatSyntax/#value) | Ask for text | | [`{{VALUE:title}}`](https://quickadd.obsidian.guide/docs/FormatSyntax/#named-value) | Ask for text once, reuse the answer anywhere as `title` | | [`{{VALUE:Red,Green,Blue}}`](https://quickadd.obsidian.guide/docs/FormatSyntax/#value-suggest) | Pick from a list | | [`{{VDATE:due,YYYY-MM-DD}}`](https://quickadd.obsidian.guide/docs/FormatSyntax/#vdate) | Ask for a date (“tomorrow” works) | | [`{{FIELD:project}}`](https://quickadd.obsidian.guide/docs/FormatSyntax/#field) | Suggest values that property already has in your vault | | [`{{FILE:People}}`](https://quickadd.obsidian.guide/docs/FormatSyntax/#file) | Pick a note from a folder | | [`{{MVALUE}}`](https://quickadd.obsidian.guide/docs/FormatSyntax/#mvalue) | Write a math formula (LaTeX) | **Dates** | Placeholder | What you get | | --- | --- | | [`{{DATE}}`](https://quickadd.obsidian.guide/docs/FormatSyntax/#date) | Today, like `2026-07-08` | | [`{{DATE:MMMM Do}}`](https://quickadd.obsidian.guide/docs/FormatSyntax/#date-format) | Today, formatted your way: `July 8th` | | [`{{DATE+7}}`](https://quickadd.obsidian.guide/docs/FormatSyntax/#date) | Seven days from today | | [`{{DATE:YYYY-MM\|startof:week}}`](https://quickadd.obsidian.guide/docs/FormatSyntax/#date-snap) | The week’s starting month, for weekly notes | | [`{{TIME}}`](https://quickadd.obsidian.guide/docs/FormatSyntax/#time) | The current time, like `14:05` | **The note you ran QuickAdd from** | Placeholder | What you get | | --- | --- | | [`{{LINKCURRENT}}`](https://quickadd.obsidian.guide/docs/FormatSyntax/#linkcurrent) | A link to it: `[[That note]]` | | [`{{LINKSECTION}}`](https://quickadd.obsidian.guide/docs/FormatSyntax/#linksection) | A link to the section your cursor is in | | [`{{FILENAMECURRENT}}`](https://quickadd.obsidian.guide/docs/FormatSyntax/#filenamecurrent) | Its file name | | [`{{FOLDERCURRENT}}`](https://quickadd.obsidian.guide/docs/FormatSyntax/#foldercurrent) | Its folder | | [`{{SELECTED}}`](https://quickadd.obsidian.guide/docs/FormatSyntax/#selected) | The text you had selected | **The note being created** | Placeholder | What you get | | --- | --- | | [`{{TITLE}}`](https://quickadd.obsidian.guide/docs/FormatSyntax/#title) | The new note’s file name | | [`{{FOLDER}}`](https://quickadd.obsidian.guide/docs/FormatSyntax/#folder) | The folder the new note lands in | **Other content** | Placeholder | What it inserts | | --- | --- | | [`{{CLIPBOARD}}`](https://quickadd.obsidian.guide/docs/FormatSyntax/#clipboard) | Whatever you copied last | | [`{{TEMPLATE:Templates/Meeting.md}}`](https://quickadd.obsidian.guide/docs/FormatSyntax/#template) | The contents of a template file | | [`{{MACRO:My Macro}}`](https://quickadd.obsidian.guide/docs/FormatSyntax/#macro) | Whatever a macro returns | | [`{{GLOBAL_VAR:Header}}`](https://quickadd.obsidian.guide/docs/FormatSyntax/#global-var) | A snippet you defined in settings | | [`{{RANDOM:6}}`](https://quickadd.obsidian.guide/docs/FormatSyntax/#random) | A random ID like `x7k2p9` | Dates ----- [Section titled “Dates”](https://quickadd.obsidian.guide/docs/FormatSyntax/#dates) ### Today’s date: `{{DATE}}` [Section titled “Today’s date: {{DATE}}”](https://quickadd.obsidian.guide/docs/FormatSyntax/#date) `{{DATE}}` becomes today’s date in `YYYY-MM-DD` format. A choice can aim that token at another day, so the same `Daily/{{DATE}}.md` template opens yesterday when you ask it to. `{{DATE+3}}` is still three days later. `{{TIME}}` is always the time you ran the choice. See [Which day](https://quickadd.obsidian.guide/docs/Choices/TemplateChoice/#date-origin) . `{{DATE:HH:mm}}` only prints the clock, so it looks like `{{TIME}}`. The day is still the chosen one. Write `{{DATE:YYYY-MM-DD HH:mm}}` if you want both. Add `+N` to move the date: `{{DATE+3}}` is three days from that day, `{{DATE+-3}}` is three days before it. Daily/{{DATE}}.mdReview on {{DATE+7}} Daily/2026-07-08.mdReview on 2026-07-15 ### Choose the date format: `{{DATE:}}` [Section titled “Choose the date format: {{DATE:}}”](https://quickadd.obsidian.guide/docs/FormatSyntax/#date-format) Put a [Moment.js format](https://momentjs.com/docs/#/displaying/format/) after the colon to control how the date looks. The `+N` day offset works here too: `{{DATE:YYYY-MM-DD+3}}`. | You write | You get | | --- | --- | | `{{DATE:MMMM Do, YYYY}}` | `July 8th, 2026` | | `{{DATE:YYYY-MM-DD_HH-mm}}` | `2026-07-08_09-42` | | `{{DATE:[Week] w}}` | `Week 28` | ### Change date text casing: `|case:` [Section titled “Change date text casing: |case:”](https://quickadd.obsidian.guide/docs/FormatSyntax/#date-case) Add `|case: