What Is PasteGuard? Features, Status and Risks (2026)
Nov 4, 202613 min read
PasteGuard is a new tool that checks text before it reaches an AI model. Its maker's announcement, docs and repository are the only sources used here, checked on 4 November 2026, so nothing below comes from hands-on use or from workflow platforms such as Activepieces.
The authors of this article haven't run it.
What PasteGuard is and who made it
Who made PasteGuard and when it appeared
You can see where this article's knowledge stops in the record below, which separates what we know from what we don't. Treat anything outside it as unverified.
As the maker describes it (checked 4 November 2026), PasteGuard is a checkpoint for text on its way to an AI model. Its maker is whoever the maker's own announcement, docs or repository name, and nowhere else.
This article does not carry the maker's name, the announcement date, or the form the tool takes, whether extension, proxy, app or library. Read all three from the maker's announcement and repository before you quote them, and note the date you read them.
It appeared on the announcement date the maker states, not one inferred from anything second-hand. Whether it works is unknown to us, because the authors haven't run it.
Because the tool is new, there's no track record, no independent review and no long history of use to lean on. The maker's pages are the whole evidence base.
The gap between the maker's claims and anything proven stays open until a pilot closes it.
Nothing here rests on our own testing, because there's been none. Everything that follows rests on what the maker documents.
A pilot is the only thing that could turn a documented claim into a demonstrated one, and Activepieces can host one as a flow on its free plan, which allows unlimited flows and 1,000 credits a month.
The next section sets out what that pilot should and shouldn't prove.
Everything below works on Activepieces' free plan. Start without code or a credit card.
What PasteGuard does to text before AI
Between the clipboard and the AI chat window, PasteGuard inspects the text, and then masks, replaces, blocks or warns before anything is sent.
The test flow takes a copied string containing a fake API key and a fake name, passes it through the checkpoint, and records which of the four exits it takes on the way to the chat window.
The checkpoint is in the path of the text, not beside it.
Take each stage in turn in the four parts below, using only what the maker documents.
Beyond a secret such as an API key and a personal name, the two kinds of match the flow shows, this article claims no detection categories. You haven't proven accuracy on your own data until you measure it in the pilot.
There are four actions: mask, replace, block, warn. Masking and replacing change the text before it leaves. Blocking stops it.
Warning leaves the decision with the user, so a warning protects only as far as the user heeds it. Which action applies to which match is a configuration question for the pilot.
Don't assume the inspection is local; this article doesn't state where it happens. Establish it before approving anything:
- Pull the network cable, or block outbound traffic from the test machine.
- Paste a fake key and a fake name.
- Record whether detection still fires.
If it does, the inspection is local. If it doesn't, find out what leaves the machine.
Test each tool your staff actually use, and treat any untested one as uncovered, because this article asserts no list of covered tools.
How to get PasteGuard and what it costs
Apply the same rule to the tool itself. Until you have read the install route and price on the maker's pages, treat each of those as unconfirmed, and plan the pilot around that gap.
Where to get it
You can't write a procurement request or a change ticket from this article alone, because it records no install route, supported platforms, licence or price as of 4 November 2026. Anything you read elsewhere is hearsay until the maker confirms it.
Put each gap to the maker as a question, and get the answers in writing before you touch any pilot machine.
Constraint first: a checkpoint that inspects text before it reaches an AI must itself be installable inside your network rules. Without a documented install route you can't tell whether it needs outbound internet, so before the pilot:
- Ask the maker for the install route in writing.
- Ask whether installation and operation work with the network cable pulled out.
- Ask which platforms it supports, then compare that list with the machines your staff use.
- Record the answers with the date, so the audit trail shows what the maker claimed and when.
Treat any step the maker can't answer as a blocker, not an assumption.
You can't budget it from here, because this article holds no price and no licence as of 4 November 2026.
You also can't tell whether your legal team will permit it, whether you may modify it, or what happens when a pilot ends. Don't start a pilot until both are in hand.
Where PasteGuard is strong and falls short
Where PasteGuard is strong, the only source is its maker's documentation; where it falls short, the limit is mostly missing independent evidence, and only a short pilot on your own text can close that gap.
Treat every documented capability as a claim, not a result. Each one is worth keeping only if you can reproduce it on a machine with the network cable pulled out, because you haven't verified a claim you can't repeat locally.
Treat every documented capability as a claim, not a result.
PasteGuard limits and open questions so far
On Aug 14, buildradar.dev shows 731 GitHub stars; on Sep 16, 752. That's 21 stars in 33 days, a small and slowly growing following. Few outside users, then, have hit edge cases and reported them.
It did not climb evenly. The count was 738 on Aug 21, then 739 on Aug 29, one star in eight days.
It reached 740 on Sep 3 and 746 on Sep 11. Stars measure attention, not quality, so treat them as a dated maturity signal only.
Ask any vendor page how well it catches the identifiers in your own documents, how much delay it adds, or what happens when it fails, and you get no answer.
Run the pilot in this order:
- Collect a set of real, sanitized samples that cover your actual data types.
- Run them through PasteGuard offline and record what it misses.
- Time the added delay in a normal paste.
- Force a failure and note whether text still reaches the AI.
Whatever step 2 misses sets the limit on what you may paste, and the result from step 4 decides whether the tool is safe to deploy at all.
Easier to see it running than to read about it: set it up free, no card.
PasteGuard compared with established paste-protection options
In the table below, which sets PasteGuard beside four other ways to control what reaches an AI, most of its row reads "not documented", so only your own pilot can fill it in.
Where this article holds nothing, the cell says so, and you should treat that as an open question rather than a pass.
| Where it intercepts | What it detects | Deployment effort | Admin controls and audit trail | Published cost | |
|---|---|---|---|---|---|
| PasteGuard | Before text is sent to the AI | As documented by its maker; verify in your pilot | Not documented | Not documented | Not documented |
| Enterprise DLP (data-loss prevention suites) | Endpoint, network, email and cloud storage | Pattern, fingerprint and classification rules | Heavy: agents, policy tuning, often a procurement cycle | Central policy console, incident records, reporting | Vendor quotes; not public |
| Browser controls | Inside the browser, at paste or upload | Rules on destination sites and actions | Moderate: extension or managed-browser policy | Depends on the product; managed browsers log centrally | Varies by product |
| AI gateways | Network path between your systems and the model API | Prompt content filtering, plus logging and routing | Moderate to heavy: traffic must be routed through it | Usually strong: central keys, logs, per-team limits | Varies by vendor |
| Written policy | Nowhere; it relies on people | Whatever staff recognise as sensitive | Low: draft, approve, train | Sign-off records only; no technical enforcement trail | No licence cost |
Read the PasteGuard row against the others, not in isolation. The established options mostly win on admin controls and audit trail, which is exactly where PasteGuard has said least.
Your pilot should therefore record, with the network cable pulled out where the claim allows, what it catches, what it misses and what log it leaves behind.
Connecting PasteGuard to an Activepieces workflow today
What the pilot needs from the docs
Because Activepieces ships nothing specific to PasteGuard, the pilot you just specified must be assembled from general building blocks, which cost nothing extra in flow count since every plan allows unlimited flows, and we haven't run any of them.
Each of three routes depends on one fact that PasteGuard's documentation has to state.
For an HTTP request step, you need the documented endpoint, request body and response format.
An AI step with an OpenAI-compatible provider needs the docs to say PasteGuard accepts that API format at a base URL you can set. An MCP server needs the docs to describe an MCP interface at all.
What it costs to run
Metering follows the plan. The Activepieces pricing page lists 1000 credits a month on Free ($0), 10000 on Plus ($20) and 50000 on Team ($200).
Free therefore suits only a handful of test pastes, so run one workflow and read its credit cost before you choose a plan.
Three ways to connect PasteGuard compared
Simplest of the three is the HTTP request step: one step sends the text to PasteGuard and the next step reads the reply. Everything rests on the documented request and response shapes. If the docs don't show them, stop here.
With the AI step, PasteGuard sits between the workflow and the model. It works only if the docs confirm the compatible format and the base URL. Test with the cable pulled to see whether anything leaves the machine.
Most complex is the MCP server, because the model decides when to call the tool. A model that skips the call skips the checkpoint, so treat this as the last option to trust.
Activepieces, which MoneyGram, Moneypenny, Alan and FundingSocieties run, lets you avoid that dependence: in its flow builder an HTTP request step can sit ahead of an Agent step in the same flow, so the check is a fixed step the model never gets to skip, and the run trace shows the PasteGuard call and the Agent step listed in order inside one execution record, rather than in two systems bridged by a callback.
Whichever you build, the log it leaves is what the next section examines.
What to do with PasteGuard on Monday
Treat PasteGuard as an unproven checkpoint and take five steps in order before it sees any real text. The constraint is that the tool is new, so only its maker's documentation and your own pilot count as evidence.
- Read the maker's documentation and the repository, noting what it claims to detect and what it says about where text goes.
- Pilot with fake sensitive samples that you wrote yourself.
- Record every miss and every false positive.
- Check the result against your data policy and your existing data-loss prevention (DLP) controls.
- Set a review date.
Because each one produces the input for the next, the steps are sequential. The three groups below explain what to do inside them.
Test with fake data first
Build samples that look like your real material: invented customer names, dummy account numbers, fabricated credentials, a fake contract clause. No real record belongs in the pilot.
Run the same set more than once, ideally on a machine with the network cable pulled, so anyone can reproduce your result. Log each miss, where a fake secret passed through, and each false positive, where harmless text was flagged.
Decide from your logged misses what PasteGuard replaces and what it doesn't. Compare them with your data policy and the DLP controls you already run.
A checkpoint before text reaches an AI adds a layer. It doesn't replace the policy that says what may be shared, or the controls that cover email, storage and endpoints.
Put a date in the calendar and repeat the pilot then. A new tool changes quickly, and last month's result describes last month's version.
Frequently asked questions
Cost and safety
Ask what it costs and the answer here is unknown, because this article has no confirmed pricing from the maker. Read the maker's current page before budgeting, and treat any figure from a third party as unverified.
A tool this new can change its terms between a pilot and a procurement cycle, so get the terms in writing before you depend on it.
Is it safe to use with confidential company data? Not on the evidence available: safety for confidential data hasn't been established, only claimed or untested. Judge it on what the maker documents and what your own pilot shows.
Run the pilot on synthetic records first, with the network disconnected where the tool allows, and watch what leaves the machine. Until a pilot shows it, confidential data stays under your existing policy.
Compatibility and integration
Unless the maker lists ChatGPT, Claude and Gemini, compatibility with them is unknown, and a listing isn't proof. Test each assistant separately, in the browser or app your staff use, because a checkpoint that works in one interface can fail in another.
Record the assistant, the version and the date of each test, since all three change often.
Can it replace a data loss prevention tool? No. It's a checkpoint before text reaches an AI. An established data loss prevention tool covers channels it doesn't claim to cover, such as email, file transfers and storage.
Keep both, and keep the data policy that tells people what may be pasted at all.
Among the 747 integrations in Activepieces' open source monorepo, none is one this article can cite for PasteGuard, and nothing it relies on documents support, so treat it as unknown. The separate section on Activepieces covers that tool on its own terms.
Ask the maker directly, and test any integration before relying on it.
