PrivacyPage MCP Server
This MCP server lets you generate legal documents for apps/sites (privacy policies, ToS, EULAs, cookie policies, disclaimers) and fetch full versions with a paid license.
generate_privacy_policy: creates a GDPR/CCPA/COPPA-aware privacy policy from app details, data collected, third-party SDKs, and children-under-13 flag.generate_terms_of_service: creates a ToS based on service name, platform, key policies, and jurisdiction.generate_eula: creates an end-user license agreement with license type and usage restrictions.generate_cookie_policy: creates a GDPR-aware cookie policy from website info, cookie types, and third-party services.generate_disclaimer: creates disclaimers for general, medical, financial, fitness, legal, or affiliate content.get_full_document: retrieves the full text of a generated document using a license key or thePRIVACYPAGE_LICENSE_KEYenvironment variable.Each generator returns a free 25-line preview plus a
documentId; full documents are unlocked with a one-time license.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@PrivacyPage MCP Server Generate a privacy policy for my fitness app FitTrack that uses Firebase and HealthKit."
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
PrivacyPage MCP Server
Give your AI agent the power to generate privacy policies, terms of service, EULAs, cookie policies, and disclaimers — while it builds your app.
Powered by PrivacyPage. Free instant previews; unlock the full document for a one-time $9.99 (no subscription, no account).
Why
Every app shipped from Cursor, Lovable, Bolt, or v0 eventually needs legal documents — the App Store and Play Store require a privacy policy, GDPR requires cookie disclosures, and users expect terms of service. This MCP server lets the agent that's building your app generate those documents in the same conversation, filled in from what the agent already knows about your app: its name, platform, the data it collects, and the SDKs it uses.
Related MCP server: ComplianceIQ MCP Server
Quick start
Requires Node.js 18+. No API key needed to generate previews.
Cursor
Add to ~/.cursor/mcp.json (or .cursor/mcp.json in your project):
{
"mcpServers": {
"privacypage": {
"command": "npx",
"args": ["-y", "privacypage-mcp"]
}
}
}Claude Desktop
Add to claude_desktop_config.json (Settings → Developer → Edit Config):
{
"mcpServers": {
"privacypage": {
"command": "npx",
"args": ["-y", "privacypage-mcp"]
}
}
}Any MCP client (generic stdio config)
{
"command": "npx",
"args": ["-y", "privacypage-mcp"],
"env": {
"PRIVACYPAGE_LICENSE_KEY": "<optional — set after purchase to auto-unlock full documents>"
}
}Tools
Tool | What it generates | Key inputs |
| GDPR/CCPA/COPPA-aware privacy policy | app name, platform, company, contact email, data collected, third-party SDKs, children under 13 |
| Terms of Service agreement | service name, company, platform, key policies (refunds, UGC, subscriptions…), jurisdiction |
| End-User License Agreement | app name, company, platform, license type, usage restrictions |
| GDPR-aware cookie policy | website name/URL, cookie types, third-party services, contact email |
| Liability disclaimer (general / medical / financial / fitness / legal / affiliate) | site name, disclaimer type, external links, contact email |
| Full text of any generated document |
|
Every generate_* tool returns a free 25-line preview, a documentId, and instructions for unlocking the full document.
Example agent conversation
You: Ship my fitness tracker app to the App Store. It uses Firebase Analytics and HealthKit.
Agent: The App Store requires a privacy policy. Let me generate one. (calls
generate_privacy_policywithappName: "FitTrack",platform: "iOS",dataCollected: ["Health Data", "Usage Analytics"],thirdPartyServices: ["Google Analytics / Firebase"],childrenUnder13: false)Agent: Here's a preview of your privacy policy — it covers HealthKit data, Firebase, GDPR and CCPA rights, and COPPA. To get the full document, purchase a one-time license at privacypage.io ($9.99, no subscription) and give me the key.
You: Here's my key:
PP-XXXX-XXXXAgent: (calls
get_full_document) Done — I've saved the full policy topublic/privacy-policy.mdand linked it in your app's settings screen.
Pricing
Preview: free. Every tool returns the first 25 lines of a real, fully generated document at no cost, no account needed.
Full document: $9.99 one-time (or $24.99 for the all-documents bundle). No subscription, no recurring fees. Purchase at privacypage.io.
After purchase, set
PRIVACYPAGE_LICENSE_KEYin your MCP config and the agent can unlock full documents automatically.
Rate limit: 10 document generations per hour per IP. The server reports rate-limit errors to the agent with a friendly retry message.
Environment variables
Variable | Purpose |
| Optional. License key used by |
| Optional. Override the API base URL (defaults to |
Data handling
This server runs locally over stdio and makes HTTPS requests only to the PrivacyPage API (https://privacypage.io, or whatever PRIVACYPAGE_API_URL is set to). Everything below is verifiable in src/index.ts and src/api.ts.
What leaves your machine. Only the explicit arguments the agent passes to a tool call — the fields the generated document prints, such as app/site name, platform, company name, contact email, website URL, data-collection and cookie selections, key policies, and jurisdiction (varying by tool). For the generate_* tools these are sent as a plain JSON POST body; get_full_document sends the documentId and license key as query parameters on a GET request. No conversation context, no filesystem contents, and nothing else from the agent session is read or transmitted.
Schema-bounded. Each tool declares a fixed input schema, and every request payload is built field-by-field from those named arguments only. An agent has no channel to send extra context through these tools.
License key. PRIVACYPAGE_LICENSE_KEY (or the licenseKey argument) is sent only to the PrivacyPage API, solely to prove entitlement when fetching a full document.
What's stored server-side. The PrivacyPage service stores the generation inputs and the generated document — that's what lets a license key unlock a document by documentId after generation. This data is not used for analytics and is not shared. (Server-side behavior is a property of the privacypage.io service; this repository's source shows only what is sent.)
Rate limiting. Generation endpoints are limited to 10 document generations per hour per IP; the server reports 429 responses to the agent with a retry message.
Development
git clone https://github.com/rushi053/privacypage-mcp.git
cd privacypage-mcp
npm install
npm run build
npm run smoke-test # handshake + tools/list over stdio
node scripts/smoke-test.mjs --call # also makes one real API callDisclaimer
Documents generated by PrivacyPage are professionally structured templates and AI-generated drafts. They are not legal advice; for high-stakes situations, have a lawyer review your documents.
License
MIT — the server. Generated documents are yours.
Available Tools
6 toolsgenerate_cookie_policyGenerate Cookie PolicyA
Generate a GDPR-aware cookie policy for a website or web app using privacypage.io. Returns a free 25-line preview and a documentId; the full document is unlocked with a one-time license ($9.99, no subscription).
Inputs: cookieTypes (required), websiteName (required), contactEmail (required), thirdPartyServices (required), +1 more.
generate_disclaimerGenerate DisclaimerA
Generate a liability disclaimer (general, medical, financial, fitness, legal, or affiliate) for a website or app using privacypage.io. Returns a free 25-line preview and a documentId; the full document is unlocked with a one-time license ($9.99, no subscription).
Inputs: websiteName (required), contactEmail (required), externalLinks (required), disclaimerType (required), +1 more.
generate_eulaGenerate EULAA
Generate an End-User License Agreement (EULA) for a software application using privacypage.io. Returns a free 25-line preview and a documentId; the full document is unlocked with a one-time license ($9.99, no subscription).
Inputs: appName (required), platform (required), companyName (required), licenseType (required), +1 more.
generate_privacy_policyGenerate Privacy PolicyA
Generate a GDPR/CCPA/COPPA-aware privacy policy for an app or website using privacypage.io. Returns a free 25-line preview and a documentId; the full document is unlocked with a one-time license ($9.99, no subscription). Fill the fields from what you know about the app being built.
Inputs: appName (required), platform (required), companyName (required), contactEmail (required), +4 more.
generate_terms_of_serviceGenerate Terms of ServiceA
Generate a Terms of Service agreement for an app or service using privacypage.io. Returns a free 25-line preview and a documentId; the full document is unlocked with a one-time license ($9.99, no subscription).
Inputs: platform (required), companyName (required), keyPolicies (required), serviceName (required), +2 more.
get_full_documentGet Full DocumentA
Fetch the full text of a previously generated document using a PrivacyPage license key. Licenses are one-time purchases at https://privacypage.io ($9.99 single document, $24.99 all-documents bundle — no subscription). If licenseKey is omitted, the PRIVACYPAGE_LICENSE_KEY environment variable is used.
Inputs: documentId (required), licenseKey.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 6 tools
Each generate_* tool targets a distinct legal document type (privacy policy, ToS, EULA, cookie policy, disclaimer), and get_full_document handles retrieval. No overlaps or ambiguous boundaries.
All generation tools follow a consistent generate_<document_type> pattern, and get_full_document uses the same verb_noun style. The naming is uniform and predictable.
Six tools is well-scoped for a legal document generation server: five document types plus one retrieval function. Each tool has a clear, non-redundant purpose.
The server covers the core lifecycle of document creation and full retrieval for the most common legal documents. The domain is narrow enough that the provided tools fully satisfy the stated purpose without obvious gaps.
Maintenance
Related MCP Connectors
One-step legal compliance for vibe-coded apps: privacy, terms, cookie banner and EU AI Act check.
Connect your AI assistant to iubenda's privacy policy generator, terms and conditions generator, and cookie banner. Generate a privacy policy, cookie policy, and terms and conditions for your website or app, then set up a cookie banner that collects cookie consent from your visitors, all through natural language. Your policy is built from the services your site actually uses. Add them from iubenda's catalog of thousands of services, or run the cookie scanner to find the trackers and third-party services on your live site, then add what it finds to your policy. Configure your cookie consent banner (position, colors, and consent behavior) by asking, and update your documents whenever your site changes. Built for founders, agencies, and developers who need to meet the requirements of the General Data Protection Regulation (GDPR), the EU ePrivacy Directive, the California Consumer Privacy Act (CCPA) and other US state privacy laws, and privacy compliance rules across markets. Works in Claude, ChatGPT, and any MCP client that supports OAuth, with every iubenda plan, including the free one. Your assistant asks before anything final or permanent, like finalizing a policy or deleting a site.
Create documents and reusable templates, request signatures, and track approvals — for AI agents.
Compliant legal documents from your AI assistant: 1,100+ templates, 15 countries, free preview.
Related MCP Servers
- FlicenseBqualityNot gradedmaintenanceEnables the generation of professional, jurisdiction-specific legal documents like privacy policies, terms of service, and cookie policies. It allows users to produce structured HTML legal content by providing specific parties, terms, and service configurations to an AI-driven tool.1-
- AlicenseAqualityDmaintenanceGenerates professional compliance documents like privacy policies and terms of service directly from AI tools. Supports multiple document types and export formats with API integration.35 npmMIT

pactlio-mcpofficial
AlicenseAqualityDmaintenanceContract and wills legal tools for AI agents: statute-cited requirements per contract type and US state, non-compete enforceability for all 50 states + DC, intake schemas, async multi-agent contract drafting with free previews, and contract risk analysis.8MIT- AlicenseAqualityBmaintenanceGenerates legal policies (privacy, terms, cookies, etc.) directly from AI coding tools by analyzing codebase context.16MIT