Enables AI agents to extract structured design systems, perform accessibility audits, and analyze web technology stacks from any website.
Also known as mgriffen/tapsite
- Stars
- 3
- Tools
- 43
- Downloads, 30 days
- —
- Latest version
- 4.0.1
- Last commit
- Nov 13, 2026
- License
- MIT
What is tapsite MCP?
tapsite enables AI agents to extract structured design systems, perform accessibility audits, and analyze web technology stacks from any website. It exposes 43 tools, such as tapsite_login, tapsite_login_manual, tapsite_login_check.
Summary generated from the project's README
About tapsite MCP server
Extracting structured design systems and performing accessibility audits from any website is what tapsite enables for AI agents. Unlike standard browser tools that focus on simple interactions like clicking buttons, this server provides 55 specialized tools to pull deep intelligence from the web. It allows users to extract color palettes, font families, spacing scales, and CSS variables, or to audit WCAG contrast ratios and Core Web Vitals.
Developers can use this with Claude, Cursor, or Windsurf by adding it to their MCP configuration via npx. The server runs locally using Playwright and Chromium, and it includes features like persistent disk caching and a three-tier anti-bot escalation system with proxy rotation. For sites requiring authentication, the tapsite_login_manual tool allows for manual login and MFA support without ever passing credentials through the chat interface. It can also export findings as structured JSON, W3C design tokens, or comprehensive HTML reports.
What you can do with it
- 1Extract design tokensAn AI agent can pull a complete color palette and spacing scale from a competitor's site to build a new design system.
- 2Perform accessibility auditsA developer can ask an agent to check a webpage for WCAG compliance and contrast issues.
- 3Analyze technology stacksAn agent can identify the frontend frameworks and third-party libraries used by a specific website.
- 4Track site changesA user can compare two different URLs or monitor a single site over time to detect design regressions.
Written from the project's README. Every use case is checked against a quote from it.
How to install tapsite MCP
Formats verified 10 Nov 2026Add to CursorAdd to GooseInstall tapsite MCP in Claude Code
$ claude mcp add tapsite -- npx -y tapsiteInstall tapsite MCP in Cursor
~/.cursor/mcp.json
{
"mcpServers": {
"tapsite": {
"command": "npx",
"args": [
"-y",
"tapsite"
]
}
}
}Install tapsite MCP in VS Code
.vscode/mcp.json
{
"servers": {
"tapsite": {
"type": "stdio",
"command": "npx",
"args": [
"-y",
"tapsite"
]
}
}
}Install tapsite MCP in VS Code CLI
$ code --add-mcp '{"name":"tapsite","type":"stdio","command":"npx","args":["-y","tapsite"]}'Install tapsite MCP in Claude Desktop
claude_desktop_config.json
{
"mcpServers": {
"tapsite": {
"command": "npx",
"args": [
"-y",
"tapsite"
]
}
}
}Install tapsite MCP in Codex
$ codex mcp add tapsite -- npx -y tapsiteInstall tapsite MCP in Codex config.toml
~/.codex/config.toml
[mcp_servers.tapsite] command = "npx" args = ["-y", "tapsite"]
Install tapsite MCP in Gemini CLI
$ gemini mcp add -s user tapsite npx -- -y tapsiteInstall tapsite MCP in Gemini settings.json
~/.gemini/settings.json
{
"mcpServers": {
"tapsite": {
"command": "npx",
"args": [
"-y",
"tapsite"
]
}
}
}Started by HostedMCP on 16 Nov 2026
We ran this command for tapsite 4.0.1 in an isolated container with no network and no keys. It answered and listed 43 tools.
tapsite MCP tools 43
Read from the server with tools/listtapsite_loginAuto-login with credentials. Session persists across calls.
tapsite_login_manualOpen headed browser for manual login (MFA). Call login_check when done.
tapsite_login_checkVerify auth state after manual login. Returns title, URL, content preview.
tapsite_inspectNavigate to URL and/or inspect page DOM with numbered interactive elements. Optional screenshot.
tapsite_screenshotScreenshot the page. Optional element highlighting with numbered badges.
tapsite_interactClick, fill, select, check, or hover an indexed element. Returns updated DOM.
tapsite_scrollScroll page or scroll an element into view.
tapsite_run_jsRun JS in page context. Large results (>2KB) write to disk.
tapsite_closeClose the browser session.
tapsite_extract_tableExtract table data as structured rows.
tapsite_extract_linksExtract all links with text and href.
tapsite_extract_colorsExtract color palette sorted by frequency.
Show all 43 toolsShow fewer tools
tapsite_extract_fontsExtract fonts: families, sizes, weights, sources.
tapsite_extract_css_varsExtract CSS custom properties, categorized by type.
tapsite_extract_spacingExtract spacing scale: margins, padding, gaps, radii.
tapsite_extract_imagesExtract all images with src, dimensions, alt, format.
tapsite_download_imagesDownload images to disk. Uses session cookies for auth assets.
tapsite_extract_svgsExtract SVGs: inline markup, external URLs, icon/illustration classification.
tapsite_extract_faviconExtract favicon and icon references. Optional download.
tapsite_extract_layoutExtract layout tree: flex/grid/block containers with properties.
tapsite_extract_componentsDetect repeated UI component patterns with instance counts.
tapsite_extract_breakpointsExtract CSS breakpoints and detect framework (Tailwind/Bootstrap/MUI).
tapsite_extract_metadataExtract metadata: OG, Twitter Cards, JSON-LD, RSS, canonical.
tapsite_extract_contentExtract main content as clean markdown, stripping chrome.
tapsite_extract_formsExtract forms: fields, validation, actions, hidden fields.
tapsite_extract_animationsExtract CSS animations, transitions, and detect animation libraries.
tapsite_extract_a11yAccessibility audit with score (0-100) and issues by severity.
tapsite_extract_darkmodeDetect dark mode support. Optionally capture dark palette.
tapsite_extract_perfPerformance metrics: Web Vitals, resource sizes, timing.
tapsite_extract_shadowsExtract box-shadow and text-shadow patterns as design tokens.
tapsite_extract_iconsDetect icon font libraries and extract icon usage (Font Awesome, Material, Bootstrap Icons, etc.).
tapsite_extract_contrastWCAG contrast ratio audit between text and background color pairs.
tapsite_capture_networkCapture network traffic for a duration. Filters static assets by default.
tapsite_extract_api_schemaInfer API schemas from captured network traffic.
tapsite_extract_stackDetect tech stack: frameworks, libraries, CMS, analytics, CDNs.
tapsite_crawlBFS crawl with extraction per page. Writes to output/crawl-{ts}/.
tapsite_diff_pagesCompare two URLs (cross-site) or the same URL over time (temporal). Runs real extractors — colors, fonts, spacing, a11y, perf, metadata, components, breakpoints — and produces a structured diff with regressions/improvements highlighted. Omit url2 for temporal mode (compares against last saved snapshot).
tapsite_exportExport URLs as Markdown + HTML report + JSON + CSV + screenshots.
tapsite_export_design_reportFull design system report: HTML + W3C tokens JSON + CSS vars.
tapsite_teardownCompetitive design teardown — runs colors, fonts, CSS vars, spacing, shadows, components, breakpoints, animations, icons, stack detection, perf, a11y, contrast, and dark mode in one call. Returns a combined summary.
tapsite_auditPre-launch quality audit with scorecard — runs a11y, contrast, perf, metadata (SEO), dark mode, and forms. Returns pass/fail per category with an overall score out of 100.
tapsite_harvestMigration asset inventory — crawls up to maxPages pages and extracts content, images, SVGs, forms, fonts, and links per page. Returns per-page counts and a link map. Output written to output/harvest-{ts}/.
tapsite_designsystemDesign system extraction — runs colors, fonts, spacing, shadows, CSS vars, breakpoints, animations, icons, and components. Exports W3C design-tokens.json, design-tokens.css, and raw-data.json to output/design-system-{ts}/.
Automated checks
Ran Nov 13, 2026Full report →Passed our automated checks. That is not a security audit: read the code and give the server the narrowest access it needs. How checks work
- Source repository linked and reachablePass
- Open source license (OSI)Pass
- Commit or release in the last yearPass
- Package name not close to a popular packagePass
- Remote endpoint uses HTTPSNot checked
- Destructive tools are labelledPass
- No hidden instructions to the modelPass
- No critical advisory in the package or its dependenciesPass
README
View on GitHubtapsite
The MCP server for web intelligence extraction. 55 tools that give AI agents the ability to understand websites — not just drive a browser, but extract structured intelligence about design systems, accessibility, performance, content, and more.
Other MCP browser tools let agents click buttons. tapsite lets agents extract a complete color palette, audit WCAG contrast ratios, diff two sites' design tokens, detect tech stacks, or pull structured data with custom CSS/XPath/regex selectors — all as structured JSON that agents can reason about.
55 Tools · 11 Categories · 4 Workflows · Multi-Format Export
Works with Claude, Cursor, Windsurf, and any MCP-compatible AI agent. LangChain/LangGraph integration coming soon.
Installation
# Quick start (no install required)
npx -y tapsite
# Or install globally
npm install -g tapsite
npx playwright install chromium
npx playwright install-deps chromium
Add to your AI agent's MCP config:
{
"mcpServers": {
"tapsite": {
"command": "npx",
"args": ["-y", "tapsite"]
}
}
}
First run: Playwright will install Chromium automatically if not already present (~150MB one-time download).
Also available on the MCP Registry and Glama.
What makes tapsite different
| Other browser MCPs | tapsite |
|---|---|
| Click buttons | Extract full design systems |
| Fill forms | Audit WCAG accessibility |
| Take screenshots | Diff sites over time |
| Read raw HTML | Detect tech stacks & APIs |
| Custom CSS / XPath / regex extraction | |
| Anti-bot resilience & proxy rotation |
Extract design systems — colors, fonts, spacing scales, breakpoints, components, shadows, icons, CSS variables, and contrast ratios from any website. Output as structured JSON or W3C design tokens.
Audit quality — accessibility scoring with WCAG contrast analysis, performance timing (Core Web Vitals), tech stack detection, dark mode support, and animation inventory.
Compare and track — diff two sites side by side, or track a single site over time with snapshot-based temporal diffs. Regressions and improvements are flagged automatically. Disk caching means crawls resume where they left off, and results are reused across sessions.
Work behind login walls — persistent browser sessions with full MFA support. A 3-tier anti-bot escalation system handles protected sites automatically — from stealth scripts to proxy rotation. Log in once manually, then extract across tool calls without re-authenticating. Credentials never enter the chat.
Tools (55)
Session (8)
| Tool | Description |
|---|---|
tapsite_login_manual |
Open headed browser for manual login + MFA |
tapsite_login_check |
Verify authenticated session state |
tapsite_inspect |
Navigate to URL and inspect the DOM (nav, headings, buttons, forms, tables, links) |
tapsite_screenshot |
Take a screenshot of the current page |
tapsite_interact |
Click or fill an indexed element from the last inspect |
tapsite_scroll |
Scroll the page |
tapsite_run_js |
Execute arbitrary JavaScript and return the result |
tapsite_close |
Close the browser session |
Content Extraction (6)
| Tool | Description |
|---|---|
tapsite_extract_table |
Extract a specific table as structured data |
tapsite_extract_links |
Extract all links with text and href |
tapsite_extract_metadata |
Extract page metadata (title, description, OG tags, etc.) |
tapsite_extract_content |
Extract main readable content (article body, headings, paragraphs) |
tapsite_extract_forms |
Extract all forms with fields, labels, and actions |
tapsite_extract_markdown |
Extract page content as clean Markdown (raw, fit, or citations mode) with optional chunking |
Custom Extraction (2)
| Tool | Description |
|---|---|
tapsite_extract_custom |
Extract structured data using custom schemas (CSS selectors, XPath, or regex) |
tapsite_extract_schema_suggest |
Analyze page DOM and auto-suggest extraction schemas |
Design Tokens (5)
| Tool | Description |
|---|---|
tapsite_extract_colors |
Extract color palette (hex values + usage counts) |
tapsite_extract_fonts |
Extract font families, sizes, weights |
tapsite_extract_css_vars |
Extract CSS custom properties |
tapsite_extract_spacing |
Extract spacing scale values |
tapsite_extract_shadows |
Extract box-shadow and text-shadow patterns |
Visual Assets (4)
| Tool | Description |
|---|---|
tapsite_extract_images |
Extract all images with src, alt, dimensions |
tapsite_download_images |
Download images to local output directory |
tapsite_extract_svgs |
Extract inline SVGs |
tapsite_extract_favicon |
Extract favicon URLs and sizes |
Layout Intelligence (3)
| Tool | Description |
|---|---|
tapsite_extract_layout |
Extract layout tree (inline text representation) |
tapsite_extract_components |
Detect repeated UI components and patterns |
tapsite_extract_breakpoints |
Extract responsive breakpoints from CSS media queries |
Quality & Compliance (7)
| Tool | Description |
|---|---|
tapsite_extract_a11y |
Accessibility audit (ARIA, roles, contrast issues) |
tapsite_extract_contrast |
Audit WCAG contrast ratios between text and background |
tapsite_extract_perf |
Extract performance metrics (Core Web Vitals, resource sizes) |
tapsite_extract_security |
Audit security headers (CSP, HSTS, SRI, permissions policy) |
tapsite_extract_darkmode |
Detect dark mode support and extract dark palette |
tapsite_extract_pwa |
Detect PWA support (manifest, service worker, installability) |
tapsite_extract_i18n |
Extract internationalization signals (lang, hreflang, translations) |
Technology Detection (10)
| Tool | Description |
|---|---|
tapsite_extract_stack |
Detect frontend framework, libraries, and tech stack |
tapsite_extract_animations |
Extract CSS animations and transitions |
tapsite_extract_icons |
Detect icon libraries and extract icon usage |
tapsite_extract_graphql |
Detect GraphQL endpoints and introspect schemas |
tapsite_extract_aiml |
Detect AI/ML integrations (models, embeddings, inference endpoints) |
tapsite_extract_canvas |
Extract canvas and WebGL usage patterns |
tapsite_extract_wasm |
Detect WebAssembly modules and usage |
tapsite_extract_web_components |
Detect custom elements and shadow DOM usage |
tapsite_extract_third_party |
Inventory third-party scripts, trackers, and services |
tapsite_extract_storage |
Audit client-side storage (cookies, localStorage, sessionStorage, IndexedDB) |
Network & API (2)
| Tool | Description |
|---|---|
tapsite_capture_network |
Capture network requests during a page load |
tapsite_extract_api_schema |
Infer API schema from observed network traffic |
Multi-page (2)
| Tool | Description |
|---|---|
tapsite_crawl |
Crawl multiple pages from a start URL |
tapsite_diff_pages |
Compare two URLs (cross-site) or track changes over time (temporal) using real extractors |
Export (2)
| Tool | Description |
|---|---|
tapsite_export |
Export inspection results as JSON + Markdown + HTML report + CSV tables + screenshots |
tapsite_export_design_report |
Full design system report: report.html (visual), design-tokens.json (W3C format), design-tokens.css (copy-pasteable :root vars) |
Engine
Resilient extraction engine. Parallel browser pooling for concurrent page extraction. Persistent disk caching — crawls resume where they left off and results are reused across sessions. 3-tier anti-bot escalation with automatic proxy rotation for protected sites.
Workflows (4)
| Tool | Description |
|---|---|
tapsite_teardown |
Comprehensive competitive design teardown (all extractors) |
tapsite_audit |
Pre-launch quality audit (a11y, contrast, perf, SEO, darkmode) |
tapsite_harvest |
Inventory all site assets (images, SVGs, forms, fonts, links) |
tapsite_designsystem |
Extract design tokens as W3C JSON and CSS variables |
LangChain / LangGraph integration (coming soon)
Native LangChain and LangGraph integration is on the roadmap. When released, it will provide a dedicated Python wrapper with tool subsets and managed session lifecycle.
Security
Prompt injection defense (hidden element filtering + output sanitization), HTTPS enforced, private IPs blocked, auth headers redacted. Credentials never enter the chat — log in manually with full MFA support.
Prompt injection defense
Extractors skip hidden elements (display:none, visibility:hidden, opacity:0, zero-size, clip-hidden) to prevent invisible text injection. All output is scanned for prompt injection patterns — instruction overrides, role hijacking, exfiltration attempts, and tool manipulation are flagged inline as [INJECTION_DETECTED].
Credential safety
Never pass credentials through the chat. Use tapsite_login_manual to open a headed browser, log in manually (including MFA), then tapsite_login_check to confirm. Credentials never touch the AI provider's servers or local transcripts.
Docker
tapsite ships a Dockerfile and docker-compose.yml for headless-only use — CI pipelines, server deployments, or anywhere you don't want a local Node.js install.
docker build -t tapsite .
docker compose up
tapsite_login_manual is not available in Docker (it requires a display). To use authenticated sessions in Docker, log in locally first, then mount the profiles/ directory into the container:
volumes:
- ./output:/app/output
- ./profiles:/app/profiles
Security note:
profiles/contains live session cookies. Don't commit it to version control (it's already in.gitignore).
Development setup
git clone https://github.com/mgriffen/tapsite
cd tapsite
npm install
npx playwright install chromium
npx playwright install-deps chromium
MCP config pointing to local source:
{
"mcpServers": {
"tapsite": {
"command": "node",
"args": ["/absolute/path/to/tapsite/src/server.js"]
}
}
}
Project structure
src/
server.js — MCP server entry point
browser.js — shared Chromium context (ensureBrowser, closeBrowser)
helpers.js — shared helpers (safeNavigate, summarizeResult, indexPage)
sanitizer.js — prompt injection detection
diff.js — per-extractor diff logic and extractor name/args mapping
snapshots.js — temporal snapshot I/O (saveSnapshot, loadLatestSnapshot)
browser-pool.js — parallel browser context pooling
cache.js — persistent disk caching with TTL
markdown.js — HTML-to-Markdown converter (raw/fit/citations)
chunker.js — LLM-friendly text chunking (fixed/semantic/sentence)
content-filter.js — BM25 relevance filtering
anti-bot.js — block detection and tier escalation
proxy.js — proxy rotation with failure tracking
stealth-setup.js — Puppeteer-extra stealth plugin registration
extraction-strategies.js — CSS/XPath/regex flexible extractors
extractors.js — browser-context extraction functions (page.evaluate())
exporter.js — file export: JSON, Markdown, HTML, CSV
inspector.js — DOM extraction for inspect tools
cli.js — standalone CLI (login, inspect, session)
config.js — paths and defaults
tools/
session.js — login, inspect, screenshot, interact, scroll, run_js, close
extraction.js — all extract_* tools
network.js — capture_network, extract_api_schema, extract_stack
multipage.js — crawl, diff_pages
export.js — export, export_design_report
workflows.js — teardown, audit, harvest, designsystem
profiles/ — browser state / session cookies (gitignored)
output/ — export results + snapshots (gitignored)
Output formats
output/run-{timestamp}/—tapsite_export: JSON, Markdown, HTML, screenshots, CSV tablesoutput/design-report-{timestamp}/—tapsite_export_design_report:report.html,design-tokens.json,design-tokens.cssoutput/snapshots/{domain}/—tapsite_diff_pagestemporal snapshots
License
MIT
tapsite MCP questions
How do I add tapsite MCP to Claude Code?
Run claude mcp add tapsite -- npx -y tapsite in your terminal. Add --scope user to make it available in every project.
How do I add tapsite MCP to Cursor?
Open ~/.cursor/mcp.json and add the server under mcpServers, using the Cursor config shown in the install section above.
What tools does tapsite MCP provide?
It exposes 43 tools, including tapsite_login, tapsite_login_manual, tapsite_login_check, tapsite_inspect, tapsite_screenshot.
How do I handle websites that require a login or MFA?
Use the tapsite_login_manual tool to open a headed browser for manual login and MFA, then verify the session with tapsite_login_check.
Can I extract specific data using my own selectors?
Yes, you can use custom CSS selectors, XPath, or regex to extract structured data via the tapsite_extract_custom tool.
Does the server support anti-bot measures?
Yes, it features a 3-tier anti-bot escalation system that includes stealth scripts and proxy rotation to handle protected sites.
Is it safe to pass my passwords to the AI?
No, you should never pass credentials through the chat; instead, use the manual login tool to ensure credentials never touch the AI provider's servers.
