BuiltWith Engine Connector (MCP Server)

This Model Context Protocol (MCP) service facilitates interaction with the BuiltWith Application Programming Interface (API) to retrieve comprehensive data regarding the technological infrastructure employed by target internet addresses. It is engineered for seamless integration with any MCP-compliant artificial intelligence assistant.

Core Capabilities

Address Probing: Ascertain detailed component lists and underlying software powering a given domain name.
Stack Organization: Review detected software components grouped into logical categories (e.g., Content Management Systems, Frontend Frameworks, Advertising).
In-depth Artifacts: Access metadata such as descriptive summaries, initial detection timestamps, and external resource links for each identified piece of technology.

System Requirements

Execution environment requiring Node.js version 18 or newer.
Possession of a valid credential for the BuiltWith API service (obtainable from BuiltWith API).

Setup Procedure

Download the repository contents:

bash git clone https://github.com/Cyreslab-AI/builtwith-mcp-server.git cd builtwith-mcp-server

Install required modules:

bash npm install

Note: The MCP Software Development Kit (SDK) is sourced directly from a GitHub location. Should instantiation fail, verification or adjustment of the specified dependency in package.json might be necessary.

Compile the source code: bash npm run build

Troubleshooting SDK Dependency Issues

If the MCP SDK package resolution proves problematic:

Verify its presence in the public npm repository:

bash npm view @modelcontextprotocol/sdk

If unavailable, confirm that package.json is correctly configured for the GitHub source. If errors persist, manual local dependency inclusion is required:
- Clone the SDK repository elsewhere:
bash # Outside the current project directory git clone https://github.com/modelcontextprotocol/sdk.git cd sdk npm install npm run build

# Return to the main project directory and install locally npm install --save ../path/to/sdk

Configuration Mandates

The service necessitates a BuiltWith access token for operational capacity. This key can be supplied either via system environment variables during runtime initialization or embedded within the AI client's MCP configuration schema.

Direct Execution

Launch the service by defining the key environment variable:

bash BUILTWITH_API_KEY=your-secret-token node build/index.js

MCP Client Settings Integration

Integrate the service definition into your MCP consumer application's settings file. The precise file path is contingent on the specific AI assistant being employed.

Standard MCP Structure

Most compliant clients anticipate a configuration similar to this:

{ "mcpServers": { "builtwith": { "command": "node", "args": ["/complete/path/to/builtwith-mcp-server/build/index.js"], "env": { "BUILTWITH_API_KEY": "your-secret-token" }, "disabled": false, "autoApprove": [] } } }

Claude Desktop Configuration Specifics

(macOS path: ~/Library/Application Support/Claude/claude_desktop_config.json) (Windows path: %APPDATA%\Claude\claude_desktop_config.json)

{ "mcpServers": { "builtwith": { "command": "node", "args": ["/path/to/builtwith-mcp-server/build/index.js"], "env": { "BUILTWITH_API_KEY": "your-secret-token" }, "disabled": false, "autoApprove": [] } } }

Claude Developer Tools Configuration Specifics

(macOS path: ~/Library/Application Support/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json) (Windows path: %APPDATA%\Code\User\globalStorage\saoudrizwan.claude-dev\settings\cline_mcp_settings.json)

Operational Use

Upon successful setup and execution of the server, inquiries regarding website technology profiles can be initiated via any MCP-enabled AI agent.

Illustrative Interaction Prompts

When interacting with your MCP-capable assistant, consider prompts such as:

"Enumerate the software deployed on example.com."
"Provide the complete technology inventory for github.com."
"Identify the analytical instruments employed by amazon.com."
"What rendering frameworks are active on netflix.com?"
"Does wordpress.com incorporate any digital commerce solutions?"

Direct Programmatic Access

For software developers seeking direct integration into Node.js applications:

The primary communication pathway is via the Model Context Protocol over standard input/output streams (stdio). Alternatively, the dedicated API client module is available for import:

typescript import { BuiltWithApiClient } from "./src/api-client.js";

const client = new BuiltWithApiClient({ apiKey: "your-secret-token", });

const result = await client.getDomainInfo("example.com"); console.log(result);

Exposed Functionality

The server exposes the following specialized routine:

domain_lookup

Retrieves the technology composition details for a specified web entity.

Parameters:

domain (Mandatory): The target Uniform Resource Locator (URL) base for analysis (e.g., example.com)
detailed (Optional): A boolean flag to request comprehensive versus summary output data.

Development Lifecycle

Launching in Development Mode

Execute the dedicated development script:

bash npm run dev

Source Code Organization

src/index.ts: The main executable file for the server instance.
src/api-client.ts: Module encapsulating the interaction logic with the BuiltWith public interface.
src/handlers/: Directory housing specific request processing functions.
src/types.ts: Definitions for data structures and types used across the system.

Contribution Guidelines

We welcome community input! To submit enhancements:

Create a personal fork of this repository.
Establish a new feature branch: git checkout -b feature/new-enhancement
Stage and commit your modifications: git commit -am 'Feature: Describe new addition'
Push the branch to your fork: git push origin feature/new-enhancement
Submit a formal Pull Request (PR).

Substantial modifications should commence with the opening of a corresponding issue for collaborative discussion.

Assistance and Support

Should you encounter operational defects or require clarification:

File a new issue report on GitHub
Reach out via electronic mail to contact@cyreslab.ai

Licensing

MIT License

This software and its accompanying documentation files (the "Software") are granted free permission for handling without limitation, encompassing rights to utilize, replicate, modify, integrate, disseminate, license, or vend copies of the Software, and to permit those to whom the Software is provided to do so, subject only to the following prerequisite:

The foregoing copyright declaration and this specific permission statement must be present in all derivative copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS," WITHOUT WARRANTY OF ANY NATURE, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO WARRANTIES OF MARKETABILITY, SUITABILITY FOR A SPECIFIC APPLICATION, AND NON-INFRINGEMENT. UNDER NO CIRCUMSTANCES SHALL THE COPYRIGHT HOLDERS OR AUTHORS BE HELD LIABLE FOR ANY CLAIM, DAMAGE, OR OTHER OBLIGATION, WHETHER IN CONTRACTUAL ACTION, TORT, OR OTHERWISE, ARISING FROM, OUT OF, OR IN CONNECTION WITH THE SOFTWARE OR ITS USAGE OR OTHER DEALINGS THEREIN.

WIKIPEDIA: XMLHttpRequest (XHR) represents an Application Programming Interface structured as a JavaScript object, facilitating the transmission of Hypertext Transfer Protocol requests from a web client to a remote server. These methods empower a browser-based application to dispatch queries to the server subsequent to page rendering completion, and subsequently receive data back. XMLHttpRequest is integral to Ajax paradigms. Preceding Ajax, the primary means of server interaction involved hyperlink navigation and form submissions, frequently resulting in the replacement of the currently viewed page.

== Chronology == The underlying concept for XMLHttpRequest originated in the year 2000 via the developers at Microsoft Outlook. This concept was subsequently realized within the Internet Explorer version 5 browser (released in 1999). Nevertheless, the initial invocation syntax did not employ the explicit identifier XMLHttpRequest. Instead, developers utilized the object instantiation syntax ActiveXObject("Msxml2.XMLHTTP") and ActiveXObject("Microsoft.XMLHTTP"). As of Internet Explorer iteration 7 (2006), universal browser support for the XMLHttpRequest identifier was achieved. The XMLHttpRequest identifier now functions as the established convention across all major browser engines, including Mozilla's Gecko rendering core (2002), Apple's Safari version 1.2 (2004), and Opera version 8.0 (2005).

=== Formal Specifications === The World Wide Web Consortium (W3C) formally published a Working Draft specification pertaining to the XMLHttpRequest object on April 5, 2006. On February 25, 2008, the W3C released the Level 2 specification Working Draft. The Level 2 revision introduced enhancements for tracking request progression events, enabling cross-origin requests, and managing binary data streams. By the conclusion of 2011, the Level 2 specification material was integrated back into the foundational document. At the termination of 2012, the Web Hypertext Application Technology Working Group (WHATWG) assumed custodianship of its evolution, maintaining a live document utilizing Web Interface Definition Language (Web IDL).

== Operational Utilization == Generally, executing a data transmission using XMLHttpRequest involves several distinct programming stages.

Instantiate an XMLHttpRequest object via a constructor call: Invoke the "open" method to define the request methodology (e.g., GET/POST), specify the target resource URI, and declare the operation mode as synchronous or asynchronous: For asynchronous operations, establish an event handler function designed to trigger upon changes in the request status: Commence the data transmission process by executing the "send" method: Process status modifications within the registered event handler. If server response data is returned, it is typically stored in the "responseText" attribute by default. When the object ceases processing the reply, its status transitions to state 4, signifying the "completion" state. Beyond these fundamental steps, XMLHttpRequest offers numerous configuration controls for request transmission parameters and response manipulation. Custom header fields can be affixed to the outbound transmission to guide server fulfillment, and payload data can be uploaded to the server by supplying it within the "send" invocation. The received response can be parsed from serialized JSON into an immediately usable JavaScript structure, or processed incrementally as data packets arrive instead of awaiting full text reception. Furthermore, the request can be forcibly terminated prematurely or configured to automatically fail if completion is not achieved within a specified time limit.

== Inter-Domain Communication ==

In the nascent phases of the World Wide Web, limitations were identified concerning the ability to b

builtwith-engine-connector

Author

Cyreslab-AI

Quick Info

Actions

Tags