Pasteon
Custom Workflows for Mac

Turn copied content into your own repeatable actions.

Build a workflow with visual steps or code, choose which clipboard types it supports, and run it directly beside Pasteon’s built-in actions.

Visual Steps or codeSimple and Script Filter modesLocal script execution
Workflow Editor
StepsEnabled
1
Match Text
Contains “user”
2
Trim Text
Whitespace and newlines
3
Change Case
snake_case
4
Return Text
Paste or copy result
+ Add Step
Inspector

Change Case

Style
snake_case
Input
{{input}}
Test resultPassed · 0.8 ms
hello world
hello_world
Choose how you build

Start visually. Drop into code when you need it.

A Workflow is the saved recipe. Its Action appears in Pasteon only when the selected clipboard item matches the inputs you choose.

1
Recommended

Steps

Arrange a linear pipeline of conditions, transforms, scripts, and one final output. Configure each step in a focused inspector and test the before and after values.

Best for: text cleanup, templates, format conversion, and file generation
2
Advanced

Code

Run inline code or an external script with your interpreter, arguments, working directory, and timeouts. Use Simple mode for one result or Script Filter for runtime choices.

Best for: custom tools, developer automation, and dynamic action lists
Step-by-step tutorial

Build a text cleanup Workflow in four steps.

This example trims copied text, normalizes its naming style, and returns the result to the app you are working in.

01 / Create

Create a Workflow and choose its inputs

Open Settings → Workflows, add a Workflow, give it a name and icon, then select the clipboard types where its Action should appear.

02 / Build

Add transforms in execution order

Add Trim Text, Change Case, or other steps. Drag to reorder them. The Output stays fixed at the end so the pipeline remains predictable.

03 / Test

Use the current clipboard as test data

Run the test without copying, pasting, or opening anything. Inspect each step’s before and after value, duration, and validation state.

04 / Run

Enable it and open Pasteon Actions

The Workflow appears directly after built-in Primary Actions. Click or press Enter to paste the result; hold Command to copy it instead.

Visual step library

Compose the common parts. Script only the special part.

Steps run from top to bottom. Conditions decide when an Action applies, transforms update the current value, and one output defines what Pasteon does with it.

Conditions

Match TextSource AppTarget App

Transforms

TrimReplace / RegexChange CaseURL Encode / DecodeJSON Format / MinifyTemplateOCR

Scripts

Inline CodeExternal ScriptCustom Interpreter

Outputs

Return TextCreate FilePNG FileOpen in FinderOpen URL
Code Workflows

One script can return a result or build a choice list.

Pasteon sends versioned JSON to stdin and reads protocol JSON from stdout. Logs belong on stderr, while timeouts, cancellation, and output limits keep runs controlled.

Simple Workflow

Execute once, return one result

Use Simple mode when one Action should produce one text, file, or URL result.

{
  "version": 1,
  "result": {
    "type": "text",
    "value": "Ready to paste"
  }
}
Script Filter Workflow

Describe choices first, execute one later

The filter phase returns lightweight candidate metadata. Pasteon runs execute only after the user chooses one candidate.

{
  "version": 1,
  "actions": [
    {
      "id": "swift",
      "title": "Generate Swift Model",
      "argument": { "language": "swift" }
    }
  ]
}
01

Filter

The script receives phase “filter” and returns up to 20 candidate Actions.

02

Choose

Pasteon displays the titles, descriptions, icons, and JSON arguments without precomputing results.

03

Execute

The chosen actionId and argument return to the script, which computes only that result.

Use stdout only for protocol JSON. Write diagnostics to stderr. Inline and external scripts share the same input and output contract.

WorkflowDefinition

Workflow configuration fields

These values control where the Workflow appears and how Pasteon launches its script.

FieldTypeRequiredWhat it does
idUUIDYesStable Workflow identifier used for updates, Filter sessions, import conflict detection, and workflowID input.
defaultIntroducedVersionInteger | nullBundled onlyCatalog version that introduced a bundled default. It lets upgrades install only newly added defaults without restoring ones a user deleted.
nameStringYesThe Workflow and Action name shown in Settings and the Pasteon action list.
nameLocalizationKeyString | nullBundled onlyOptional String Catalog key used to localize the name of a bundled Workflow. User edits clear this key.
summaryStringNoA short explanation displayed beside the Action. It does not affect execution.
summaryLocalizationKeyString | nullBundled onlyOptional localization key for the bundled Workflow summary.
symbolNameSF Symbol nameYesThe icon used by the Workflow Action. Invalid candidate icons fall back to this symbol.
isEnabledBooleanYesDisabled Workflows remain saved but do not generate Actions.
requiresTrustConfirmationBoolean | nullImportedMarks imported code as untrusted. Pasteon sets this to true and disables the Workflow until the user confirms it.
sortOrderNumberYesControls the order of Custom Workflow Actions after built-in Primary Actions.
modesimple | scriptFilterYesSimple executes immediately. Script Filter runs filter first, then execute after a candidate is chosen.
supportedTypesPasteType[]YesClipboard types where the Action may appear: text, markdown, html, json, url, color, date, timestamp, fileURL, imageURL, videoURL, image, or appObject.
editorModesteps | codeNoSelects the visual linear editor or script editor. Older Workflow files without this field use Code.
script.sourceinline | externalCodeInline stores code inside the Workflow. External references a script on disk.
script.codeStringInlineThe inline script body. Pasteon writes it to a temporary file for each run.
script.codeResourceResource name | nullBundled onlyBundle resource containing code for a default Workflow. Exported user Workflows carry resolved inline code instead.
script.scriptPathFile pathExternalPath to the external script. Tilde paths are expanded. Missing files keep the configuration but prevent an Action from appearing.
script.interpreterPathExecutable pathInlineExecutable used to run the script, such as /bin/zsh or the result of which node. External executable scripts may leave it empty.
script.argumentsString[]NoArguments passed as an array before the generated or external script path. Pasteon does not join them into a shell command.
script.workingDirectoryDirectory pathNoCurrent directory for the process. When empty, external scripts use their folder and inline scripts use the temporary input folder.
script.filterTimeoutSecondsFilterMaximum Filter duration. Values are clamped to 1–120 seconds; the default is 5.
script.executeTimeoutSecondsYesMaximum Execute duration. Values are clamped to 1–120 seconds; the default is 15.
stepsWorkflowStep[] | nullStepsOrdered linear step definitions. Steps mode requires Simple mode and exactly one final output. OCR enables image input; PNG File and Open in Finder apply stricter input-type rules.
variablesWorkflowVariableDefinition[] | nullNoReusable Text or Secret values available to Steps templates and Code Workflow stdin. Names must be unique within the Workflow.
WorkflowInvocationInput

JSON sent to stdin

Pasteon builds this object only after the user runs a Workflow. Binary clipboard representations are materialized as temporary files instead of being embedded in JSON.

FieldTypeRequiredWhat it does
versionIntegerYesWorkflow protocol version. The current and only supported value is 1.
workflowIDUUID StringYesStable identifier of the Workflow being run.
phasefilter | executeYesTells a shared script which stage to run. Simple Workflows receive execute only.
paste.idUUID StringYesIdentifier of the selected Pasteon history item.
paste.typePasteTypeYesThe derived clipboard content type used for Workflow visibility and script logic.
paste.textString | nullNoText form of the selected content when available. Files and binary images may not have text.
paste.sourceAppBundleIdentifierString | nullNoBundle identifier of the app where the clipboard item was originally copied.
paste.representationsRepresentation[]YesAll available pasteboard representations. Text may be inline; binary data is exposed by file path.
targetApp.bundleIdentifierString | nullNoBundle identifier of the frontmost app that will receive the result.
targetApp.nameString | nullNoLocalized display name of the frontmost target app.
directories.inputDirectory pathYesTemporary run directory containing the inline script and materialized binary inputs. Removed after the run.
directories.outputDirectory pathYesDirectory where the script should create returned files. Unused output directories are cleaned after 24 hours.
variablesRecord<String, String>YesResolved variables keyed by name. Text and Secret values are available during both Filter and Execute.
actionIDString | nullExecute after FilterID of the candidate chosen from Filter output. Null during filter and for Simple Workflows.
argumentJSON value | nullExecute after FilterThe selected candidate’s argument, returned unchanged so execute can compute only that choice.
Execute input example
{
  "version": 1,
  "workflowID": "5F604A89-7AC2-45D9-B48C-BB540B60CA67",
  "phase": "execute",
  "paste": {
    "id": "D0A4E45A-61F6-4DAF-BC1E-4E17A23AA5C0",
    "type": "json",
    "text": "{\"name\":\"Pasteon\"}",
    "sourceAppBundleIdentifier": "com.apple.Safari",
    "representations": [
      {
        "type": "public.utf8-plain-text",
        "value": "{\"name\":\"Pasteon\"}",
        "path": null,
        "fileName": null,
        "fileSize": 18,
        "temporary": false
      }
    ]
  },
  "targetApp": {
    "bundleIdentifier": "com.apple.dt.Xcode",
    "name": "Xcode"
  },
  "directories": {
    "input": "/tmp/Pasteon/WorkflowInputs/RUN_ID",
    "output": "~/Library/Application Support/Pasteon/WorkflowOutputs/RUN_ID"
  },
  "variables": {
    "API_BASE_URL": "https://api.example.com",
    "API_TOKEN": "••••••••"
  },
  "actionID": "swift",
  "argument": { "language": "swift" }
}

Read Workflow input in common languages

Each example reads the complete stdin payload, accesses paste.text and a PREFIX Workflow variable, then writes one valid Simple Workflow result to stdout.

JavaScript / Node.js

Use file descriptor 0 with the Node.js standard library.

/opt/homebrew/bin/node
const fs = require("node:fs");

const payload = JSON.parse(fs.readFileSync(0, "utf8"));
const text = payload.paste?.text ?? "";
const prefix = payload.variables?.PREFIX ?? "";

process.stdout.write(JSON.stringify({
  version: 1,
  result: { type: "text", value: prefix + text }
}));
Python 3

Use json.load with sys.stdin and json.dump with sys.stdout.

/opt/homebrew/bin/python3
import json
import sys

payload = json.load(sys.stdin)
text = payload.get("paste", {}).get("text") or ""
prefix = payload.get("variables", {}).get("PREFIX", "")

json.dump({
    "version": 1,
    "result": {"type": "text", "value": prefix + text}
}, sys.stdout)
Ruby

Read $stdin, parse with JSON, and write only protocol JSON.

/opt/homebrew/bin/ruby
require "json"

payload = JSON.parse($stdin.read)
text = payload.dig("paste", "text") || ""
prefix = payload.dig("variables", "PREFIX") || ""

$stdout.write(JSON.generate({
  version: 1,
  result: { type: "text", value: prefix + text }
}))
PHP

Read the STDIN stream and use PHP’s built-in JSON functions.

/opt/homebrew/bin/php
<?php
$payload = json_decode(stream_get_contents(STDIN), true);
$text = $payload["paste"]["text"] ?? "";
$prefix = $payload["variables"]["PREFIX"] ?? "";

echo json_encode([
    "version" => 1,
    "result" => ["type" => "text", "value" => $prefix . $text]
]);
Swift

Read FileHandle.standardInput and decode with Foundation.

/usr/bin/swift
import Foundation

let data = FileHandle.standardInput.readDataToEndOfFile()
let payload = try JSONSerialization.jsonObject(with: data) as? [String: Any]
let paste = payload?["paste"] as? [String: Any]
let variables = payload?["variables"] as? [String: String]
let text = paste?["text"] as? String ?? ""
let prefix = variables?["PREFIX"] ?? ""

let response: [String: Any] = [
    "version": 1,
    "result": ["type": "text", "value": prefix + text]
]
let output = try JSONSerialization.data(withJSONObject: response)
FileHandle.standardOutput.write(output)
Zsh + jq

Zsh reads the raw payload; jq performs JSON parsing and encoding.

/bin/zsh
#!/bin/zsh
set -euo pipefail

payload="$(cat)"
text="$(printf '%s' "$payload" | jq -r '.paste.text // ""')"
prefix="$(printf '%s' "$payload" | jq -r '.variables.PREFIX // ""')"

jq -n --arg value "$prefix$text" '{
  version: 1,
  result: {type: "text", value: $value}
}'

Pasteon does not bundle language runtimes or jq. Set interpreterPath to an executable that exists on the current Mac. Homebrew paths differ between Apple silicon and Intel Macs; use “which node”, “which python3”, or the equivalent to find the correct path.

WorkflowStepDefinition

Visual Step fields

Every step has identity, behavior, enabled state, and one shared configuration object. Only fields used by the selected kind affect execution.

FieldTypeRequiredWhat it does
steps[].idUUIDYesStable identity used by selection, drag ordering, validation, and per-step test results.
steps[].kindWorkflowStepKindYesSelects the condition, transform, script, or output operation.
steps[].isEnabledBooleanYesDisabled non-output steps are skipped. The final Output cannot be disabled.
configuration.patternStringMatch / ReplaceText, app identifier fragment, or regular expression to test or replace.
configuration.replacementStringReplaceReplacement text. In Regex mode it follows NSRegularExpression replacement template rules.
configuration.matchModecontains | equals | startsWith | endsWith | regularExpressionMatch / ReplaceControls how pattern is compared. Replace uses plain replacement unless regularExpression is selected.
configuration.isCaseSensitiveBooleanMatch / ReplaceWhen false, text comparison and Regex replacement are case-insensitive.
configuration.trimModewhitespaceAndNewlines | whitespace | newlinesTrimSelects which characters are removed from both ends.
configuration.caseStylecamel | pascal | snake | screamingSnake | kebab | train | dotChange CaseTarget naming convention for the current text.
configuration.templateStringTemplateText template containing supported placeholders such as {{input}} and {{date}}.
configuration.fileNameStringOutput FileOutput file name, with template variables allowed. Directory components are discarded for safety.
configuration.scriptScriptConfigurationRun ScriptScript settings for this step. A Run Script step must return a text result for the next visual step.

Available WorkflowStepKind values

textCondition

Show and run only when the current text matches pattern.

sourceAppCondition

Match the bundle identifier of the app that created the clip.

targetAppCondition

Match the bundle identifier of the frontmost destination app.

trimText

Remove selected whitespace characters from both ends.

replaceText

Perform plain or regular-expression replacement.

changeCase

Convert the current text to the configured naming style.

urlEncode / urlDecode

Percent-encode or decode the current text.

jsonPretty / jsonMinify

Parse JSON, sort keys, then pretty-print or compact it.

template

Replace supported placeholders in a text template.

runScript

Run a Simple Code Workflow step that must return text.

recognizeText

Use macOS Vision OCR on Clipboard Image or ImageURL input and pass the recognized text to the following steps.

outputText / outputFile / outputOpenURL

Return text, create a text file, or open a supported URL. Exactly one output is kept at the end of a valid Steps Workflow.

outputPNGFile

Convert Clipboard Image or ImageURL input to a PNG file. Other input types make the Workflow invalid.

outputRevealInFinder

Reveal a local FileURL, ImageURL, or VideoURL in Finder. Workflow testing reports the path without opening Finder.

WorkflowInputRepresentation

Representation fields

Each representation describes one pasteboard flavor. Use value for text and path for files or materialized binary data.

FieldTypeRequiredWhat it does
typeUTI StringYesPasteboard type identifier, such as public.utf8-plain-text, public.file-url, public.png, or public.html.
valueString | nullNoInline UTF-8 value for text-like representations or the original file URL string.
pathFile path | nullNoOriginal local file path or temporary path created for binary representation data.
fileNameString | nullNoOriginal or generated safe file name associated with the representation.
fileSizeInt64YesRepresentation size in bytes, using stored metadata when available.
temporaryBooleanYesTrue when Pasteon wrote binary data into directories.input for this run. Do not retain that path.
WorkflowFilterResponse

Filter response fields

Filter output describes choices only. It must not contain final generated content or perform work for every candidate.

FieldTypeRequiredWhat it does
versionIntegerYesMust equal the supported protocol version: 1.
actionsAction[]YesNon-empty candidate list. Pasteon validates and displays at most the first 20 items.
actions[].idStringYesCandidate identifier returned as actionID during execute. After trimming, length must be 1–120 characters.
actions[].titleStringYesVisible candidate title. After trimming, length must be 1–120 characters.
actions[].subtitleString | nullNoSecondary explanation shown beside the candidate. Pasteon keeps the first 240 characters.
actions[].iconSF Symbol | nullNoSF Symbol name for the candidate. Invalid symbols fall back to the parent Workflow icon.
actions[].argumentJSON value | nullNoOpaque JSON value sent back unchanged during execute. It may be an object, array, string, number, boolean, or null.
Candidates
Maximum 20 displayed per Filter run.
Argument
Maximum 64 KB encoded JSON per candidate.
ID and title
1–120 characters after trimming.
Subtitle
Truncated to 240 characters.
WorkflowExecuteResponse

Execute response fields

Execute returns exactly one result object. Include only the field required by its type.

FieldTypeRequiredWhat it does
versionIntegerYesMust equal the supported protocol version: 1.
resultObjectYesThe one final result Pasteon should apply.
result.typetext | files | openURL | revealFileYesSelects validation and the normal versus Command-mode behavior.
result.valueStringtextNon-empty text to paste normally or copy when Command mode is active.
result.pathsString[]files | revealFileFor files, a non-empty list whose relative paths resolve inside directories.output and must exist. For revealFile, the first path is the local item to reveal.
result.urlStringopenURLValid http, https, or mailto URL. Normal mode opens it; Command mode copies it.
revealFile behaviorLocal file actionrevealFileNormal Action execution reveals the first path in Finder and hides Pasteon. Command mode does not change this result into copy-only behavior.
Files result example
{
  "version": 1,
  "result": {
    "type": "files",
    "paths": ["GeneratedModel.swift"]
  }
}
WorkflowRunner

Limits, process behavior, and cleanup

The runner launches processes without shell-string concatenation, streams both output channels, and terminates work when the user leaves the session.

stdout ≤ 2 MB

stdout must contain one protocol JSON document and no log lines. Exceeding the limit terminates the process.

stderr ≤ 256 KB

Write logs and diagnostics to stderr. It is captured for testing and errors.

timeout 1–120 s

Filter and Execute have separate configurable timeouts. Pasteon terminates an overdue process.

exit status 0

A non-zero process exit is treated as failure, with captured stderr included in the error.

cancellable

Switching Paste items, returning from Filter results, editing or deleting the Workflow, or closing the window cancels the run.

arguments stay separate

Arguments are passed as an array. Pasteon does not expand pipes, wildcards, variables, or other shell syntax.

outputs expire after 24 h

Workflow output directories older than 24 hours are removed during application cleanup.

local user permissions

Scripts execute locally with the current macOS user’s access. Review imported code before enabling it.

WorkflowVariableDefinition

Reusable Workflow variables

Define values once in Settings and reuse them in visual Steps or Code Workflows. Text values are stored with the Workflow. Secret values are stored in the macOS Keychain and removed from exported files.

FieldTypeRequiredWhat it does
variables[].idUUIDYesStable identity used to associate a Secret with its Keychain value. Copying a Workflow creates new variable IDs.
variables[].nameStringYesCase-sensitive lookup name. It must match [A-Za-z_][A-Za-z0-9_]* and be unique within the Workflow.
variables[].kindtext | secretYesText stores its value in the Workflow. Secret stores its value in the macOS Keychain.
variables[].valueStringText onlyText value saved and exported with the Workflow. Secret definitions always export this field as an empty string.
Workflow file example
{
  "variables": [
    {
      "id": "C3EEAF0E-0AD8-4A26-924C-CB867088D955",
      "name": "API_BASE_URL",
      "kind": "text",
      "value": "https://api.example.com"
    },
    {
      "id": "7E05B2EE-E745-4558-A267-E63B7D1E2235",
      "name": "API_TOKEN",
      "kind": "secret",
      "value": ""
    }
  ]
}
Steps syntax
Use {{variables.NAME}} in Template content and output file names. An empty or missing value resolves to an empty string.
Code syntax
Read payload.variables.NAME from stdin JSON. Variables are available in Filter and Execute phases.
Secret storage
Secret values stay in the macOS Keychain. Removing the variable or Workflow deletes its Keychain value.
Import and export
Text values travel with exported JSON. Secret names and kinds are exported, but Secret values must be entered again after import.

Steps template placeholders

Template and file-name steps replace these built-in placeholders and any {{variables.NAME}} value at runtime.

{{input}}Current text from the previous step.
{{sourceApp}}Source app bundle identifier, or an empty string.
{{targetApp}}Frontmost target app bundle identifier, or an empty string.
{{clipboardType}}Current PasteType raw value.
{{date}}Current date and time in ISO 8601 format.
{{variables.NAME}}Value of the user-defined Text or Secret variable with the matching case-sensitive name.

Process environment variables

Code Workflows can read these in addition to the stdin JSON object.

PASTEON_WORKFLOW_IDUUID of the current Workflow.
PASTEON_WORKFLOW_PHASEfilter or execute.
PASTEON_INPUT_DIRPath matching directories.input.
PASTEON_OUTPUT_DIRPath matching directories.output.
.pasteon-workflow

.pasteon-workflow file structure

Exports are readable versioned JSON. A file may contain one Workflow or the full Workflow list.

FieldTypeRequiredWhat it does
versionIntegerYesEnvelope protocol version. Import currently accepts version 1.
installedDefaultsVersionInteger | nullNoInternal default-catalog state. User exports write null and imports do not use it to enable defaults.
workflowsWorkflowDefinition[]YesOne or more complete Workflow definitions. A bare single WorkflowDefinition is also accepted for compatibility.
Every imported Workflow is forced to isEnabled: false and requiresTrustConfirmation: true.
When a UUID already exists, the user can replace it or import a copy with a new UUID.
Inline code is included in the JSON. External script files are not bundled; only scriptPath is exported.
A missing external path keeps the imported configuration visible but prevents its Action from appearing.
JavaScript / Node.js

Complete JavaScript Script Filter example

This one script handles both phases. Filter returns two lightweight choices; Execute computes only the selected result.

workflow.jsInterpreter: /opt/homebrew/bin/node
async function main() {
  let input = "";
  process.stdin.setEncoding("utf8");
  for await (const chunk of process.stdin) input += chunk;

  const payload = JSON.parse(input);
  const text = payload.paste?.text ?? "";
  let response;

  if (payload.phase === "filter") {
    response = {
      version: 1,
      actions: [
        {
          id: "uppercase",
          title: "Convert to Uppercase",
          subtitle: "Uppercase the copied text",
          icon: "textformat",
          argument: null
        },
        {
          id: "wrap",
          title: "Wrap in Brackets",
          subtitle: "Add [ and ]",
          icon: "curlybraces",
          argument: { prefix: "[", suffix: "]" }
        }
      ]
    };
  } else {
    const argument = payload.argument ?? {};
    const value =
      payload.actionID === "uppercase"
        ? text.toUpperCase()
        : (argument.prefix ?? "") + text + (argument.suffix ?? "");

    response = {
      version: 1,
      result: { type: "text", value }
    };
  }

  process.stdout.write(JSON.stringify(response));
}

main().catch((error) => {
  process.stderr.write(`${error.stack ?? error.message}\n`);
  process.exit(1);
});

Use the path returned by “which node” on your Mac. Avoid console.log because it writes to stdout; use console.error for diagnostics.

Result behavior

Return the shape the next app needs.

Normal execution performs the result immediately. Command-click or Command + Enter switches text, files, and URLs to copy-only mode. Finder reveal always locates the file.

text

Paste or copy text

Return generated text, cleaned content, templates, code, or any other string.

files

Paste or copy files

Create files in the provided output directory and return their paths to Pasteon.

openURL

Open or copy a URL

Open supported web or mail links normally, or copy the URL in Command mode.

revealFile

Reveal a file in Finder

Locate the returned local file in Finder. Workflow tests show the path without opening Finder.

Ready on day one

Useful defaults are regular Workflows, too.

Pasteon ships these enabled by default. You can inspect, edit, disable, duplicate, export, or delete them like any other Workflow.

Convert CaseScript Filter
Paste as JSON File.json
Paste as TXT File.txt
Paste as Markdown File.md
Open in BrowseropenURL
URL Encode / DecodeScript Filter
Paste as Markdown LinkSimple
Convert ColorScript Filter
OCROCR → Text
PNG FileImage → .png
Open in FinderrevealFile
Import, export, and trust

Share recipes without hiding what they run.

Workflow files stay readable and portable. Imported Workflows remain disabled until you review and trust their code.

Import and export .pasteon-workflow JSON files.
Inline code travels with the Workflow; external scripts remain referenced by path.
Imported Workflows are disabled by default and require confirmation before scripts run.
Workflow scripts run locally with your current macOS user permissions.
FAQ

Custom Workflow questions

Do I need to know how to code?

No. Steps mode covers common conditions, text transforms, templates, scripts, and outputs in a visual linear editor. Code mode is available when you need custom behavior.

What is the difference between Simple and Script Filter?

Simple runs once and returns one result. Script Filter first returns lightweight choices, then runs the selected choice in a separate execute phase.

When does a Workflow appear in Pasteon?

An enabled Workflow appears after built-in Primary Actions when the selected clipboard item matches its input types and visual conditions.

Where do scripts run?

Scripts run locally on your Mac with the interpreter and working directory you configure. Imported Workflows are disabled until you review and enable them.

Are Custom Workflows a Pro feature?

Yes. You can create, test, import, export, and run Custom Workflows with Pasteon Pro.

Build the clipboard action your work is missing.

Download Pasteon for Mac, start with a visual Workflow, and move into scripts only when your process needs them.