Automating Traverse with Shortcuts and URL Actions

Traverse is built around ordinary OPML files, but ordinary files do not have to mean isolated files.

The new automation options, included in v1.2.0, let Traverse sit in the middle of more of your working day. You can create a fresh outline from a Shortcut, append notes from another app, add a node under the current project branch, retrieve the selected node, or update an existing item after something else has happened.

That makes Traverse useful as a place to think, but also as a destination for capture and a structured handoff point between tools.

There are two ways in:

• Shortcuts actions, for visual workflows on macOS (Pro unlock required)
• traverse:// URL actions, for launchers, scripts, Conduit routes, bookmarks, and apps that can open a callback URL.

You do not have to choose one forever. Shortcuts are friendlier when you are building a workflow by hand. URL actions are better when another app wants a direct link.

Start a new outline from a prompt, page or note

The simplest automation is also one of the most useful: create a new Traverse outline from text you already have.

In Shortcuts, use Create Outline and provide:

• A title.
• Some content.
• A format: Plain Text, Markdown, or OPML.

Plain text is useful for quick indented structures:

Launch plan
    Website
        Publish announcement
        Update pricing page
    Support
        Draft help article
        Prepare saved replies
    Follow-up
        Review feedback
        Decide next fixes

Markdown works well when the source already has headings or bullets. OPML is best when you are bringing structure from another outliner or an agent that can create Traverse-compatible OPML.

A nice everyday Shortcut is:

1. Ask for a project name.
2. Ask for a rough brief.
3. Create Outline in Traverse.
4. Open the new outline.

That turns a loose thought into a place where the work can start taking shape.

Capture into an existing outline

Creating a new outline is only half the story. A lot of real work is incremental: another idea, another source, another next action.

Use Append to Outline when the new material should simply become top-level content, or parsed child content, in an existing outline. Use Add Node when the first new node needs extra information applied at the same time: a note, task state, mark, Type, Fountain role, URL, or custom attribute.

For example, you might have a research outline with branches for:

Questions
Sources
Claims
Counterpoints
Next actions

A Shortcut from Safari could take the current page title and URL, ask for a quick note, and add it under Sources with a URL attribute. Another Shortcut could add a task under Next actions and mark it as open.

This is where automation starts to feel less like "exporting to an app" and more like putting information exactly where future-you expects to find it.

Use the current node as context

The Get Current Node action returns the node currently selected in Traverse. That gives another app enough context to act on the thing you are already looking at.

For instance:

1. Select a node in Traverse.
2. Run a Shortcut.
3. Get Current Node.
4. Send the node text and note to another app, service, or script.
5. Append the result back to the node's note.

That pattern is useful for summarising a branch, preparing a reply, drafting a checklist, or sending the current item into a separate processing tool.

The returned node includes its text, note, document ID, node ID, file location, and a Traverse node link. That link can be used later to come straight back to the same node:

traverse://open?document=DOCUMENT-UUID&node=NODE-UUID

Build an inbox workflow

One of my favourite uses for this is a tiny capture inbox.

Create an outline called something like Inbox. Then build a Shortcut that asks for text and adds it to that outline. You can call it from the menu bar, a keyboard shortcut, Raycast, Alfred, LaunchBar, or anything else that can run a Shortcut.

You can keep it simple:

• Ask for text.
• Add Node to the Inbox outline.
• Open the new node in Traverse.

Or make it a little richer:

• Ask for text.
• Ask for an optional note.
• Add a task attribute set to open.
• Add a mark such as blue or orange.
• Return the Traverse link so another app can store it.

The point is not to build a giant system. It is to remove the small decision of "where do I put this?" when you are trying to catch a thought before it cools.

Add structured material, not just text

The Add Node action exists for the cases where the first inserted node needs metadata as well as text. Append can add content, but it does not apply attributes to the first new node.

Add Node has two modes:

• Single Node creates one node from the supplied text.
• Parse Outline turns the supplied text, Markdown, or OPML into a group of nodes.

That means a Shortcut can add a reusable mini-structure beneath the selected or supplied parent node, while also setting attributes on the first node in that structure.

For example, a "new decision" Shortcut could insert:

Decision
    Context
    Options
    Evidence
    Chosen direction
    Follow-up

A "new source" Shortcut could insert:

Source title
    Summary
    Useful quotes
    Claims to verify
    Related questions

In that source example, the first node could also receive the source URL, a blue mark, and a lookup value such as Status: To read.

Templates and snippets are still better when you want a curated reusable structure inside Traverse itself. Automation is useful when the trigger begins somewhere else, especially when that trigger already knows the attributes you want to attach.

Update nodes as work changes

Automation is not only for adding. Update Node can change text, replace or append to the note, and apply attributes.

That opens up practical workflows such as:

• Append meeting notes to the project node you selected before a call.
• Mark a task complete after a Shortcut finishes another action.
• Add a source URL to the selected research item.
• Change a status lookup from "Waiting" to "Ready".
• Add a follow-up note without disturbing the existing note.

Attributes can be supplied as JSON:

{
  "task": true,
  "mark": "green",
  "status": "Waiting",
  "url": "https://example.com"
}

Or as simple lines:

task: done
mark: blue
status: Ready
url: https://example.com

Traverse validates those values against the outline's attributes. Task values can use friendly words like done, complete, open, or todo. Marks can use colour names such as red, green, blue, or purple.

Use URL actions when another app wants a link

Shortcuts are comfortable, but URL actions are wonderfully direct.

This creates an outline:

traverse://x-callback-url/createOutline?title=Project%20Plan&content=First%20idea

This adds a node:

traverse://x-callback-url/addNode?document=DOCUMENT-UUID&text=Follow%20up%20with%20Sam

This gets the current node and sends the result to another callback URL:

traverse://x-callback-url/getCurrentNode?x-success=myapp://callback

Most URL actions can call x-success with the resulting document and node details. If no success callback is supplied, Traverse opens the resulting node when it can. If something fails and you provide x-error, Traverse sends back an error code and message.

This makes Traverse easy to use from tools that already speak x-callback-url: launchers, note apps, clipboard utilities, custom scripts, and personal glue apps.

A few workflow ideas

Here are some starting points:

• Quick project starter: Ask for a project name and rough brief, then create a Markdown outline with headings for context, milestones, risks, decisions, and next actions.
• Web research capture: Send the current page title, URL, and selected text into a Sources branch.
• Meeting follow-up: Select a meeting node, dictate follow-up notes, and append them to the node note.
• Task capture: Add a node to an Inbox outline with the task attribute turned on.
• Decision log: Insert a parsed decision structure under the current project node.
• Read-current-node handoff: Get the current node, process it in another tool, and update the original node with the result.
• Open from another system: Store a Traverse node link in a calendar event, ticket, note, or task so you can jump straight back to the relevant outline branch.

Why this fits Traverse

Automation can sometimes make an app feel more complicated. The goal here is the opposite.

Traverse remains an outliner built on portable files. The automation layer just gives those files more doors. A thought can arrive from a Shortcut. A node can send context out to another workflow. A link can bring you back to exactly the right part of an outline.

The structure is still yours. The automation just helps it keep up.