Redact PDF MCP server
An MCP server that permanently redacts PII from PDFs. Give an agent a PDF, get back a
PDF with the sensitive text removed from the file — not covered with a black rectangle
that anyone can select, copy, or delete.
Most "redaction" MCP servers scrub PII out of prompt text. This one takes a real document
and returns a real redacted document.
It also anonymizes. With mode: "pseudonymize" every person, company and address becomes a
consistent tag such as [Person 1] instead of a black box, so the document stays readable
(e.g. before pasting a contract into ChatGPT or Claude), and you get the tag → original table to
restore the names.
[npm]
[npm downloads]
[No AI training]
[EU & Swiss hosted]
[MCP registry]
[License: MIT]
[redact-pdf-mcp MCP server]
Then ask: "Redact the personal data in ~/Documents/contract.pdf", or "Anonymize
~/Documents/contract.pdf with placeholders so I can paste it into an AI".
Your data
You are sending the document the agent is meant to protect, so this comes first.
- Never used to train AI models — not ours, not Microsoft's, not anyone's. The Azure
AI services used for OCR and PII detection run with content logging disabled, so
document content is not retained or used for model improvement.
- Processed in the EU and Switzerland on Microsoft Azure.
- Encrypted with TLS 1.2+ in transit and AES-256 at rest.
- The original is deleted after a successful redaction under the default
ephemeral retention.
The redacted output is kept for your account's retention window (14 days by default,
configurable) and can be purged at any time with DELETE /v1/jobs/{job_id}.
- Certified infrastructure. Azure holds SOC 2 Type II, ISO 27001, ISO 27017 and
ISO 27018 certifications and is HIPAA-eligible under Microsoft's BAA. Redact PDF AI
itself is not independently audited for these frameworks; it is built so legal, medical
and finance teams can use it inside their own compliance posture.
- The MCP server sends no telemetry of its own — see
what the server does locally.
Details: redact-pdf.ai/security ·
privacy policy
Why not let the agent redact it itself?
An agent can find names in text. It cannot make a PDF safe on its own:
- A black box is not a redaction. Drawing a rectangle over text leaves the text layer
underneath; anyone can select, copy or extract it. This server rasterizes each page and
drops the text layer and metadata, so there is nothing left to recover.
- Scans have no text to search. Contracts, IDs and statements are often images. OCR
runs first, in 100+ languages, then PII detection runs over what it read.
- Detection is a model, not a regex. Names, addresses and organizations do not follow a
pattern. The detector is purpose-built for PII, and your always-redact and never-redact
lists cover the rest.
Examples
Prompts that work as-is once the server is installed:
- "Redact the personal data in ~/Documents/lease.pdf before I send it to the agency."
- "Redact names, emails and IBANs in every PDF in ~/Downloads/statements, keep our company
name visible." — the agent passes
pii_excluded_terms for the company name and fans
out with redact_pdf.
- "Here is a screenshot of a customer ticket. Remove the phone number and address, then
give me a PDF I can attach." — images go in directly, no conversion.
- "Try the redact-pdf demo on ~/Documents/contract.pdf so I can see what it does." —
keyless, first page only.
Try it with no API key
The server ships a keyless tool, try_demo. Give it a file and it redacts the first
page for real — no key, no account — and tells the agent what it found:
You: Use the redact-pdf server's try_demo tool on ~/Documents/contract.pdf.
Claude: Redacted the first page of contract.pdf (4 pages). Personal data removed
on that page: Person, Email. Here is the redacted page (link valid 7 days). To redact
all 4 pages, a free account gets the first document (up to 5 pages) done in full, no card.
Call it with no file and it runs a built-in synthetic sample instead, which is the
zero-configuration connectivity check. Same thing from a terminal, no install:
What it does
- Permanent, irreversible redaction. The underlying text is deleted, not masked. It
cannot be recovered by copy-paste, text extraction, or "remove object" in a PDF editor.
- PDFs and images. Pass a PDF, JPEG or PNG. Photos and screenshots do not need converting
first; the output is a redacted PDF either way.
- Scanned documents. OCR handles image-only PDFs and photos of documents.
- 100+ languages for entity detection.
- Eight entity types: Person, Email, PhoneNumber, Address, Organization, Date, IBAN,
CreditCard — plus your own always-redact and never-redact term lists.
- EU/Swiss processing, never used for AI training — see Your data.
- Pseudonymize instead of black boxes.
mode: "pseudonymize" replaces each entity with a
consistent tag ([Person 1], [Org 1], [Address 1]...), identical on every page and for every variant of
a name, so the document stays readable for a colleague or another AI. The text is still
removed, not covered, and redact_pdf_and_wait also returns the tag → original table (CSV).
- Human review when it matters.
retention: "studio" keeps the original so a
person can check and adjust the masks before export.
Install
Claude Code
Claude Desktop
claude_desktop_config.json:
Cursor
.cursor/mcp.json:
VS Code
Get an API key at redact-pdf.ai/sign-up. A free account
gets its first document (up to 5 pages) redacted in full, no card. Without a key,
try_demo still works; everything else will tell the agent to ask you for one.
A client that can't pass the key in the environment (Cowork drops a plugin MCP server whose
config references a plugin setting, so the Claude plugin passes none) can save it instead: give the agent the key and it calls set_api_key, which
checks the key against the API and, when the client supports MCP elicitation, asks you to
approve the account (email and the key's last four characters). A confirmed key is written to
~/.config/redact-pdf-mcp/key (or $XDG_CONFIG_HOME/redact-pdf-mcp/key), readable by your user
only, and is never replaced without the same confirmation. A client without elicitation gets the
key for that session only, in memory, never over a key that still works, and every tool result
names the account. That keeps a key planted in a processed document from silently redirecting
your files. The tool never returns the key. You can also write the file yourself once (see the
plugin README for the one-line command). REDACT_PDF_API_KEY takes priority when it is set; an
empty value, or an unsubstituted placeholder such as ${user_config.api_key}, counts as unset.
Tools
Redaction rules, on either redact tool:
Anonymize → let the AI work → put the names back
The local server closes the loop without the model ever seeing a name:
redact_pdf_and_wait with mode: "pseudonymize" returns the redacted PDF, the
correspondence table on disk, and document_text: the document as text, every name
replaced by its tag. The agent works from that text.
- The agent writes its answer (summary, memo, letter) to a
.md, .txt or .docx file,
keeping the tags as written.
restore_names with that file and the correspondence_path writes
<name>-restored.<ext> with the real names, and returns only the path and counts.
The agent must not open the original document first, nor the correspondence CSV or the
restored file afterwards: any of those reads puts the personal data back into the
conversation. The server instructions and tool descriptions say so explicitly.
Remote server
The package also ships a streamable-HTTP server for hosted use, where the API key travels
per request instead of in the environment:
It is stateless — no sessions, no stored keys, nothing kept between requests — so each
request gets its own short-lived server instance and one caller's key can never leak into
another's tool call.
The handshake, tools/list, and try_demo work without a key, so a client can connect and
verify the server before anyone signs up; every other tool returns 401 with a
WWW-Authenticate challenge.
Re-identification (hosted)
restore_names on the hosted server takes the document_id, the
text_version that came with document_text, and the agent's tagged text (up
to 500,000 characters). The server fetches that document's correspondence table
itself, puts the real names back, and stores the result for the user: the tool
returns a 15-minute restored_download_url (a download page, the file only on
click) plus counts and the tags it could not restore. No original ever appears
in a result. text_version pins the table: if the document was edited or
detected again in the Studio since the text was produced, the restore is
refused (text_changed) rather than putting in names that a tag no longer
stands for. The stored file is deleted after an hour, or at once with the
document.
Limits (hosted)
The hosted server needs Node 20.3 or later (AbortSignal.any); stdio runs on any Node 20.
Refusals are logged as {"event":"admission","reason":…} and cancelled calls as {"event":"cancelled","reason":"budget"|"client_closed"} (no keys, addresses or arguments). A refused tool call is answered as a tool error carrying retry_after_seconds, so the model sees the advice.
All limits are per process. URL fetches (file_url, ChatGPT files) connect to
the exact address that passed the public-address check: a DNS record that
changes between the check and the connection cannot redirect it.
OAuth (hosted connector)
Set these and the server also acts as an OAuth 2.1 protected resource (MCP authorization
spec), so Claude and ChatGPT can connect with a sign-in instead of a key:
Resource and issuer are set together or not at all; a partial or insecure configuration
stops the server at startup. With OAuth on:
/.well-known/oauth-protected-resource/mcp (and the root form) serves the RFC 9728
metadata; a call that needs sign-in gets 401 with
WWW-Authenticate: Bearer resource_metadata="…".
- Access tokens must be Clerk OAuth tokens in JWT format, signed RS256 by the issuer,
for this resource. They are verified locally (cached JWKS) before the request body
is read.
- The user's token is never forwarded. The server calls the API with a 2-minute HS256
service assertion (
X-Service-Assertion) naming the verified user, minted per API
request.
- API keys still work:
X-API-Key, or a bearer value starting rdp_live_.
Documents reach the hosted server one of three ways (it has no access to your
filesystem):
create_upload_link (the default). Returns a 30-minute page on
www.redact-pdf.ai where the user chooses the file; it goes from their browser
straight to storage and never passes through the AI conversation. The agent
then calls redact_pdf_and_wait with upload_id. Until the user has
uploaded, that call answers status: "waiting_for_upload" (not an error;
nothing is created or billed).
file_base64, for files under 1 MB only. Larger ones are refused with a
pointer to create_upload_link, and request bodies are capped accordingly
(~1.8 MB).
- ChatGPT's
file parameter (_meta["openai/fileParams"]), off by default:
set REDACT_PDF_ENABLE_CHATGPT_FILES=1. It is a URL fetch on the caller's
behalf (any MCP client can fill it, not only ChatGPT) through the same guard
as file_url. Set REDACT_PDF_CHATGPT_FILE_HOSTS to the hosts ChatGPT serves
files from (comma-separated; a leading . matches subdomains); without it the
parameter also requires REDACT_PDF_ENABLE_URL_INPUT=1. Keep it off until the
guard pins DNS.
An upload link makes one job. Once its job exists, the page refuses a second
file ("already used, ask for a new link") and the API answers 410 to any new
request on it, so the agent is never handed the first file's job for a second
file. Hosted results carry document ids, never the user's file names.
Results never carry files. The redacted PDF and the correspondence table come
back as signed links (download_url, correspondence_download_url) minted by
POST /v1/documents/{id}/links; a pseudonymized text comes back inline, or for
a long one as its start plus a signed document_text_url. Each link works for
15 minutes without any credential, is bound to one document, its owner and one
kind, and re-checks ownership, retention, readiness and the account balance
when it is used. A PDF or table link opens a page with a Download button: a
plain GET (a fetch tool, a link preview) never receives the file. Links need
REDACT_PDF_SERVICE_SECRET on the API. See CHANGELOG.md for what changed in
0.5.0.
Fetching a document by URL is off by default on the remote server. The address check
is real — URLs resolving to loopback, private, or link-local addresses are refused, and
every redirect hop is re-checked — but the socket resolves the hostname a second time
after that check, so a DNS-rebinding attacker with a short TTL can still have the server
validate one address and connect to another. Closing that requires pinning the connection
to the validated address, which is not implemented yet, so an internet-reachable server
does not offer the surface at all.
Set REDACT_PDF_ENABLE_URL_INPUT=1 to accept file_url, and only where you have your own
egress controls (a network policy or allowlisting proxy) in front of the server.
REDACT_PDF_ALLOW_PRIVATE_URLS=1 additionally permits private addresses, for a
self-hosted instance fetching from internal storage.
stdio mode is unaffected: it runs on your own machine, where fetching a URL carries no
privilege you do not already have.
What the server does locally
- No telemetry. The server makes exactly the API calls its tools describe, and nothing
else. No analytics, no error reporting, no phone-home.
- Stateless. No database, no cache, no disk writes except the files you asked for, at
the paths you asked for, and the key file when you call
set_api_key.
- Your originals stay yours. In stdio mode the input file is read and never modified.
Under the default
ephemeral retention the API deletes the original after a successful redaction.
- Idempotent by default. The idempotency key is derived from the file bytes and the
redaction settings, so an agent that retries the same call gets the same job back
instead of redacting — and billing — twice. That cache lasts 24 hours; pass an explicit
idempotency_key when you genuinely want a second, separate redaction of the same file.
- Never overwrites. In stdio mode the redacted PDF is written atomically and the tool
refuses to clobber an existing file.
Privacy Policy
The full policy is at redact-pdf.ai/privacy. It covers
the website, the app and the API this server calls. In short:
- What is collected. The documents you send, their processing metadata (status, page
count, selected PII categories) and the redaction masks; your account identifier and
email if you use an API key; billing data if you pay. This MCP server itself collects
nothing and sends no telemetry.
- How it is used. To run the redaction you asked for, and to operate, secure and bill
your account. Documents are processed for OCR and PII detection only and are never used
to train AI models.
- Where it is stored. Microsoft Azure in the EU and Switzerland, encrypted in transit
(TLS 1.2+) and at rest (AES-256).
- Who it is shared with. Documents go only to Microsoft Azure (storage, OCR and PII
detection). Account and billing data go to Clerk and Stripe. Internal operational alerts,
which can include a file name, go to the team's Slack. The policy lists every
subprocessor.
- How long it is kept. Under the default
ephemeral retention the original is deleted
after a successful redaction; the redacted output follows your account's retention window (14 days
by default) and can be deleted at any time. Files sent to the keyless try_demo are
deleted after the first page is redacted; that page is kept 14 days.
- Contact. [email protected] for privacy requests and questions.
Limits
- 50 MB per PDF, 10 MB per image, 100 files per job.
- PDF, JPEG and PNG in; always a PDF out. Convert other formats (DOCX, TIFF, HEIC) to PDF first.
- On the remote server, base64 inflates a document by about a third, so prefer
file_url
for anything large.
- Passing an empty
pii_categories list is rejected: to the API an empty list means
"redact nothing", which would return an untouched file reported as redacted. Omit the
argument to use your account defaults.
- Billed per page against your plan quota and credit packs, after the free first document.
A
quota_exceeded error means top up — the tools tell the agent not to retry it.
Development
Links
Support questions about redaction quality, billing, or your account go to
[email protected] — GitHub issues here are for the MCP server itself.
MIT licensed.