Dom Element Selection And Querying

via “dom-element-interaction-and-selection”

Experimental MCP server for browser automation using Puppeteer (inspired by @modelcontextprotocol/server-puppeteer)

Unique: Wraps Puppeteer's element query and interaction methods (page.$, page.click, page.type) as discrete MCP tools, allowing LLM agents to compose multi-step interactions (find element → extract property → click → wait) without managing Puppeteer's page object

vs others: More granular than Selenium (which requires explicit driver management) and more accessible than raw Puppeteer (no JavaScript knowledge required from LLM client, works via tool schemas)

via “dom-query-and-element-inspection”

MCP server for Chrome DevTools

Unique: Exposes CDP's Runtime domain for DOM queries through MCP, allowing agents to inspect elements without context switching to browser console. Returns structured metadata (bounding boxes, computed styles) in a single call, reducing round-trips compared to sequential property queries.

vs others: More efficient than Puppeteer's page.$() because it returns computed styles and layout info in one call rather than requiring separate property accesses, reducing network overhead in agent workflows.

via “dom element selection and interaction via css/xpath selectors”

** - An MCP server using Playwright for browser automation and webscrapping

Unique: Wraps Playwright's locator API with MCP tool definitions, exposing both CSS and XPath selector support with automatic waiting and error handling. Provides structured feedback on element interaction success/failure.

vs others: More reliable than regex-based selector matching; uses Playwright's native waiting mechanisms to handle dynamic content and timing issues that simpler selector tools struggle with.

via “dom-element-selection-and-querying”

Model Context Protocol servers for Playwright

Unique: Exposes Playwright's locator API as MCP tools with rich metadata responses (bounding box, visibility, attributes), enabling LLMs to make informed decisions about element interaction without trial-and-error clicking, and supporting both CSS and XPath with automatic selector validation

vs others: Returns structured element metadata (visibility, enabled state, bounding box) in a single query, reducing the number of round-trips needed compared to frameworks that require separate queries for element existence, visibility, and interaction readiness

via “dom querying and element interaction with css selectors”

为 AI Agent 设计的 JS 逆向 MCP Server，内置反检测，基于 chrome-devtools-mcp 重构 | JS reverse engineering MCP server with agent-first tool design and built-in anti-detection. Rebuilt from chrome-devtools-mcp.

Unique: Wraps CDP element interaction commands into agent-native tool definitions with automatic element waiting and stale element recovery, vs raw CDP which requires agents to handle timing and retry logic manually

vs others: More agent-friendly than Puppeteer's page.$(selector) because it returns structured metadata and handles common failure modes (stale elements, visibility checks) automatically; simpler than raw CDP for agents unfamiliar with low-level browser protocol

via “dom-element-interaction-with-selector-based-targeting”

Your browser is the API. CLI + MCP server for AI agents to control Chrome with your login state.

Unique: Uses CDP protocol for direct DOM interaction with built-in element visibility waits and multi-element batch operations. Integrates with the authenticated browser context to interact with pages as the logged-in user.

vs others: More reliable than Playwright/Selenium for authenticated pages because it uses the real browser session; built-in waits reduce flakiness vs raw CDP usage

via “dom-aware-element-selection-with-multi-strategy-matching”

🌐Web Agent Protocol (WAP) - Record and replay user interactions in the browser with MCP support

Unique: Implements intelligent fallback chain with selector strategy caching — learns which selector type works for each element and reuses it, reducing retry overhead on subsequent interactions

vs others: More resilient than single-strategy selectors (pure CSS or XPath) because it adapts to DOM changes, but more performant than brute-force fuzzy matching because it caches successful strategies

via “dom-based element selection and targeting”

Hey HN,Claude Code is pretty agentic now. It writes scripts, calls APIs, uses CLIs. But when something requires actually clicking through a website, it stops and asks me to do it.Problem is, I'm often unfamiliar with these platforms myself. "Go to App Store Connect and generate a P8 key&qu

Unique: Exposes DOM element metadata as structured data through MCP, allowing Claude to reason about page structure programmatically rather than relying solely on visual screenshots or trial-and-error clicking.

vs others: More reliable than coordinate-based clicking because it targets semantic elements rather than pixel positions, making automation resistant to layout changes or responsive design variations.

via “dom-element-interaction-and-querying”

Experimental MCP server for browser automation using Puppeteer (inspired by @modelcontextprotocol/server-puppeteer)

Unique: Exposes Puppeteer's element querying and evaluation as MCP tools, allowing agents to chain selector queries with property extraction and interactions in a single tool call. Uses page.evaluate() to run JavaScript in page context for reliable property access.

vs others: More flexible than REST API scraping because it can interact with dynamic elements; more reliable than regex-based HTML parsing because it queries the live DOM after JavaScript execution.

via “dom-query-and-element-inspection”

MCP Server for Browser Dev Tools

Unique: Wraps CDP DOM.querySelector and DOM.getAttributes as MCP tools with structured output, allowing agents to query and inspect elements without writing JavaScript or managing CDP node IDs directly

vs others: More efficient than Puppeteer's page.evaluate() for simple DOM queries because it uses CDP's native DOM domain instead of spinning up a JavaScript context

via “dom-inspection-and-element-selection”

Experimental MCP server for browser automation using Puppeteer (inspired by @modelcontextprotocol/server-puppeteer)

Unique: Exposes DOM inspection as an MCP tool rather than requiring the LLM to write JavaScript; abstracts selector computation and element metadata extraction into a single call, reducing the cognitive load on the LLM for page structure understanding.

vs others: Simpler for LLMs than raw Puppeteer.evaluate() calls because it returns pre-structured element metadata and auto-generates stable selectors, reducing trial-and-error in element targeting.

via “dom-element-interaction-and-selection”

Experimental MCP server for browser automation using Puppeteer (inspired by @modelcontextprotocol/server-puppeteer)

Unique: Wraps Puppeteer element APIs (page.$, page.$$, element.click, element.type) as discrete MCP tools, allowing agents to compose multi-step interactions. Includes element property introspection (text, attributes, visibility) for conditional branching.

vs others: More granular than Selenium/Playwright wrappers that often batch operations; allows agents to inspect element state between actions for adaptive behavior