npm - @deventerprisesoftware/scrapi-mcp - Versions diffs - 0.2.8 → 0.3.0 - Mend

@deventerprisesoftware/scrapi-mcp 0.2.8 → 0.3.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (4) hide show

package/dist/index.js CHANGED Viewed

@@ -5,38 +5,55 @@ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import { z } from "zod";
+import { createRequire } from "module";
+const require = createRequire(import.meta.url);
+const { version: SCRAPI_SERVER_VERSION } = require("./package.json");
 const PORT = process.env.PORT || 5000;
 const SCRAPI_API_KEY = process.env.SCRAPI_API_KEY || "00000000-0000-0000-0000-000000000000";
 const SCRAPI_SERVER_NAME = "ScrAPI MCP Server";
-const SCRAPI_SERVER_VERSION = "0.2.8";
 const app = express();
 app.use(cors({
     origin: "*",
     exposedHeaders: ["mcp-session-id", "mcp-protocol-version"],
-    allowedHeaders: [
-        "Content-Type",
-        "mcp-session-id",
-        "mcp-protocol-version",
-        "Authorization",
-    ],
+    allowedHeaders: ["Content-Type", "mcp-session-id", "mcp-protocol-version", "Authorization"],
     methods: ["GET", "POST", "OPTIONS"],
-    preflightContinue: false
+    preflightContinue: false,
 }));
 app.use(express.json());
 // Define session configuration schema
 export const configSchema = z.object({
     scrapiApiKey: z.string().optional().describe("ScrAPI API key for scraping. Leave empty for default limited usage."),
 });
+const BROWSER_COMMANDS_DESCRIPTION = "BROWSER COMMANDS: You can optionally provide browser commands to interact with the page before scraping (e.g., clicking buttons, filling forms, scrolling). " +
+    "Provide commands as a JSON array string. Available commands:\n" +
+    '- Click: {"click": "#buttonId"} - Click an element using CSS selector\n' +
+    '- Input: {"input": {"input[name=\'email\']": "value"}} - Fill an input field\n' +
+    '- Select: {"select": {"select[name=\'country\']": "USA"}} - Select from dropdown\n' +
+    '- Scroll: {"scroll": 1000} - Scroll down (negative values scroll up)\n' +
+    '- Wait: {"wait": 5000} - Wait milliseconds (max 15000)\n' +
+    '- WaitFor: {"waitfor": "#elementId"} - Wait for element to appear\n' +
+    '- JavaScript: {"javascript": "console.log(\'test\')"} - Execute custom JS\n' +
+    'Example: [{"click": "#accept-cookies"}, {"wait": 2000}, {"input": {"input[name=\'search\']": "query"}}]';
 // Parse configuration from query parameters
-function parseConfig(req) {
-    const configParam = req.query.config;
-    if (configParam) {
-        return JSON.parse(Buffer.from(configParam, "base64").toString());
+export function parseConfig(req) {
+    const configParam = req.query["config"];
+    if (typeof configParam !== "string") {
+        return {};
+    }
+    try {
+        const decoded = Buffer.from(configParam, "base64").toString("utf-8");
+        const parsed = JSON.parse(decoded);
+        if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
+            return parsed;
+        }
+        return {};
+    }
+    catch {
+        return {};
     }
-    return {};
 }
 // Create MCP server with your tools
-export default function createServer({ config, }) {
+export default function createServer({ config }) {
     const server = new McpServer({
         name: SCRAPI_SERVER_NAME,
         version: SCRAPI_SERVER_VERSION,
@@ -46,156 +63,130 @@ export default function createServer({ config, }) {
         description: "Use a URL to scrape a website using the ScrAPI service and retrieve the result as HTML. " +
             "Use this for scraping website content that is difficult to access because of bot detection, captchas or even geolocation restrictions. " +
             "The result will be in HTML which is preferable if advanced parsing is required.\n\n" +
-            "BROWSER COMMANDS: You can optionally provide browser commands to interact with the page before scraping (e.g., clicking buttons, filling forms, scrolling). " +
-            "Provide commands as a JSON array string. Available commands:\n" +
-            "- Click: {\"click\": \"#buttonId\"} - Click an element using CSS selector\n" +
-            "- Input: {\"input\": {\"input[name='email']\": \"value\"}} - Fill an input field\n" +
-            "- Select: {\"select\": {\"select[name='country']\": \"USA\"}} - Select from dropdown\n" +
-            "- Scroll: {\"scroll\": 1000} - Scroll down (negative values scroll up)\n" +
-            "- Wait: {\"wait\": 5000} - Wait milliseconds (max 15000)\n" +
-            "- WaitFor: {\"waitfor\": \"#elementId\"} - Wait for element to appear\n" +
-            "- JavaScript: {\"javascript\": \"console.log('test')\"} - Execute custom JS\n" +
-            "Example: [{\"click\": \"#accept-cookies\"}, {\"wait\": 2000}, {\"input\": {\"input[name='search']\": \"query\"}}]",
+            BROWSER_COMMANDS_DESCRIPTION,
         inputSchema: {
-            url: z
-                .string()
-                .url({ message: "Invalid URL" })
-                .describe("The URL to scrape"),
+            url: z.string().url({ message: "Invalid URL" }).describe("The URL to scrape"),
             browserCommands: z
                 .string()
                 .optional()
                 .describe("Optional JSON array of browser commands to execute before scraping. See tool description for available commands and format."),
         },
-    }, async ({ url, browserCommands }) => await scrapeUrl(url, "HTML", browserCommands));
+    }, async ({ url, browserCommands }) => await scrapeUrl(url, "HTML", config.scrapiApiKey || SCRAPI_API_KEY, browserCommands));
     server.registerTool("scrape_url_markdown", {
         title: "Scrape URL and respond with Markdown",
         description: "Use a URL to scrape a website using the ScrAPI service and retrieve the result as Markdown. " +
             "Use this for scraping website content that is difficult to access because of bot detection, captchas or even geolocation restrictions. " +
             "The result will be in Markdown which is preferable if the text content of the webpage is important and not the structural information of the page.\n\n" +
-            "BROWSER COMMANDS: You can optionally provide browser commands to interact with the page before scraping (e.g., clicking buttons, filling forms, scrolling). " +
-            "Provide commands as a JSON array string. Available commands:\n" +
-            "- Click: {\"click\": \"#buttonId\"} - Click an element using CSS selector\n" +
-            "- Input: {\"input\": {\"input[name='email']\": \"value\"}} - Fill an input field\n" +
-            "- Select: {\"select\": {\"select[name='country']\": \"USA\"}} - Select from dropdown\n" +
-            "- Scroll: {\"scroll\": 1000} - Scroll down (negative values scroll up)\n" +
-            "- Wait: {\"wait\": 5000} - Wait milliseconds (max 15000)\n" +
-            "- WaitFor: {\"waitfor\": \"#elementId\"} - Wait for element to appear\n" +
-            "- JavaScript: {\"javascript\": \"console.log('test')\"} - Execute custom JS\n" +
-            "Example: [{\"click\": \"#accept-cookies\"}, {\"wait\": 2000}, {\"input\": {\"input[name='search']\": \"query\"}}]",
+            BROWSER_COMMANDS_DESCRIPTION,
         inputSchema: {
-            url: z
-                .string()
-                .url({ message: "Invalid URL" })
-                .describe("The URL to scrape"),
+            url: z.string().url({ message: "Invalid URL" }).describe("The URL to scrape"),
             browserCommands: z
                 .string()
                 .optional()
                 .describe("Optional JSON array of browser commands to execute before scraping. See tool description for available commands and format."),
         },
-    }, async ({ url, browserCommands }) => await scrapeUrl(url, "Markdown", browserCommands));
-    async function scrapeUrl(url, format, browserCommands) {
-        const body = {
-            url: url,
-            useBrowser: true,
-            solveCaptchas: true,
-            acceptDialogs: true,
-            proxyType: "Residential",
-            responseFormat: format,
-        };
-        // Parse and add browser commands if provided
-        if (browserCommands && browserCommands.trim() !== "") {
-            try {
-                const commands = JSON.parse(browserCommands);
-                if (Array.isArray(commands)) {
-                    body.browserCommands = commands;
-                }
-                else {
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: "Error: Browser commands must be a JSON array.",
-                            },
-                        ],
-                        isError: true,
-                    };
-                }
+    }, async ({ url, browserCommands }) => await scrapeUrl(url, "Markdown", config.scrapiApiKey || SCRAPI_API_KEY, browserCommands));
+    return server.server;
+}
+export async function scrapeUrl(url, format, apiKey, browserCommands) {
+    const body = {
+        url,
+        useBrowser: true,
+        solveCaptchas: true,
+        acceptDialogs: true,
+        proxyType: "Residential",
+        responseFormat: format,
+    };
+    // Parse and add browser commands if provided
+    if (browserCommands && browserCommands.trim() !== "") {
+        try {
+            const commands = JSON.parse(browserCommands);
+            if (Array.isArray(commands)) {
+                body.browserCommands = commands;
             }
-            catch (error) {
-                const errorMessage = error instanceof Error ? error.message : "Unknown error";
+            else {
                 return {
                     content: [
                         {
                             type: "text",
-                            text: `Error: Invalid browser commands format. ${errorMessage}`,
+                            text: "Error: Browser commands must be a JSON array.",
                         },
                     ],
                     isError: true,
                 };
             }
         }
-        try {
-            const requestBody = JSON.stringify(body);
-            console.error(`Using ScrAPI on URL: ${url} with format: ${format}`);
-            console.error(`Request body: ${requestBody}`);
-            const response = await fetch("https://api.scrapi.tech/v1/scrape", {
-                method: "POST",
-                headers: {
-                    "User-Agent": `${SCRAPI_SERVER_NAME} - ${SCRAPI_SERVER_VERSION}`,
-                    "Content-Type": "application/json",
-                    "X-API-KEY": config.scrapiApiKey || SCRAPI_API_KEY,
-                },
-                body: requestBody,
-                signal: AbortSignal.timeout(300000),
-            });
-            const data = await response.text();
-            if (response.ok) {
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: data,
-                            _meta: {
-                                mimeType: `text/${format.toLowerCase()}`,
-                            },
-                        },
-                    ],
-                };
-            }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : "Unknown error";
             return {
                 content: [
                     {
                         type: "text",
-                        text: data,
+                        text: `Error: Invalid browser commands format. ${errorMessage}`,
                     },
                 ],
                 isError: true,
             };
         }
-        catch (error) {
-            console.error("Error calling API:", error);
-            const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+    }
+    try {
+        console.error(`Using ScrAPI on URL: ${url} with format: ${format}`);
+        const response = await fetch("https://api.scrapi.tech/v1/scrape", {
+            method: "POST",
+            headers: {
+                "User-Agent": `${SCRAPI_SERVER_NAME} - ${SCRAPI_SERVER_VERSION}`,
+                "Content-Type": "application/json",
+                "X-API-KEY": apiKey,
+            },
+            body: JSON.stringify(body),
+            // ScrAPI can take up to 5 minutes to solve captchas and load dynamic pages
+            signal: AbortSignal.timeout(300000),
+        });
+        const data = await response.text();
+        if (response.ok) {
             return {
                 content: [
                     {
                         type: "text",
-                        text: `Error: Failed to scrape URL. ${errorMessage}`,
+                        text: data,
+                        _meta: {
+                            mimeType: `text/${format.toLowerCase()}`,
+                        },
                     },
                 ],
-                isError: true,
             };
         }
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: data,
+                },
+            ],
+            isError: true,
+        };
+    }
+    catch (error) {
+        console.error("Error calling API:", error);
+        const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Error: Failed to scrape URL. ${errorMessage}`,
+                },
+            ],
+            isError: true,
+        };
     }
-    return server.server;
 }
 app.all("/mcp", async (req, res) => {
     try {
-        // Parse configuration
-        const rawConfig = parseConfig ? parseConfig(req) : {};
-        // Validate and parse configuration
-        const config = configSchema
-            ? configSchema.parse({ scrapiApiKey: rawConfig.scrapiApiKey || SCRAPI_API_KEY })
-            : {};
+        // Parse and validate configuration
+        const rawConfig = parseConfig(req);
+        const config = configSchema.parse({
+            scrapiApiKey: rawConfig["scrapiApiKey"] ?? SCRAPI_API_KEY,
+        });
         const server = createServer({ config });
         const transport = new StreamableHTTPServerTransport({
             sessionIdGenerator: undefined,

package/package.json CHANGED Viewed

@@ -1,52 +1,66 @@
-{
-  "name": "@deventerprisesoftware/scrapi-mcp",
-  "version": "0.2.8",
-  "description": "MCP server for using ScrAPI to scrape web pages.",
-  "keywords": [
-    "mcp",
-    "web scraper",
-    "web scraping",
-    "web data extractor",
-    "claude",
-    "ai"
-  ],
-  "homepage": "https://scrapi.tech",
-  "bugs": {
-    "url": "https://github.com/DevEnterpriseSoftware/scrapi-mcp/issues"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/DevEnterpriseSoftware/scrapi-mcp.git"
-  },
-  "license": "MIT",
-  "author": "DevEnterprise Software (https://deventerprise.com)",
-  "type": "module",
-  "bin": {
-    "scrapi-mcp": "dist/index.js"
-  },
-  "files": [
-    "dist"
-  ],
-  "scripts": {
-    "build": "tsc && shx chmod +x dist/*.js",
-    "publish": "npm run build && npm publish",
-    "watch": "tsc --watch",
-    "ncu": "npx npm-check-updates --interactive",
-    "docker:build": "docker build -f Dockerfile -t deventerprisesoftware/scrapi-mcp:v%npm_package_version% -t deventerprisesoftware/scrapi-mcp:latest .",
-    "docker:push": "docker push deventerprisesoftware/scrapi-mcp --all-tags",
-    "docker:release": "npm run build && npm run docker:build && npm run docker:push"
-  },
-  "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.28.0",
-    "cors": "^2.8.6",
-    "express": "^5.2.1",
-    "zod": "^3.25.76"
-  },
-  "devDependencies": {
-    "@types/cors": "^2.8.19",
-    "@types/express": "^5.0.6",
-    "@types/node": "^25.5.0",
-    "shx": "^0.4.0",
-    "typescript": "^6.0.2"
-  }
-}
+{
+  "name": "@deventerprisesoftware/scrapi-mcp",
+  "version": "0.3.0",
+  "description": "MCP server for using ScrAPI to scrape web pages.",
+  "keywords": [
+    "mcp",
+    "web scraper",
+    "web scraping",
+    "web data extractor",
+    "claude",
+    "ai"
+  ],
+  "homepage": "https://scrapi.tech",
+  "bugs": {
+    "url": "https://github.com/DevEnterpriseSoftware/scrapi-mcp/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/DevEnterpriseSoftware/scrapi-mcp.git"
+  },
+  "license": "MIT",
+  "author": "DevEnterprise Software (https://deventerprise.com)",
+  "type": "module",
+  "bin": {
+    "scrapi-mcp": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc && shx chmod +x dist/*.js",
+    "release": "npm run build && npm publish",
+    "watch": "tsc --watch",
+    "lint": "eslint index.ts",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "ncu": "npx npm-check-updates --interactive",
+    "docker:build": "docker build -f Dockerfile -t deventerprisesoftware/scrapi-mcp:v%npm_package_version% -t deventerprisesoftware/scrapi-mcp:latest .",
+    "docker:push": "docker push deventerprisesoftware/scrapi-mcp --all-tags",
+    "docker:release": "npm run build && npm run docker:build && npm run docker:push"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "cors": "^2.8.6",
+    "express": "^5.2.1",
+    "zod": "^3.25.76"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "@types/cors": "^2.8.19",
+    "@types/express": "^5.0.6",
+    "@types/node": "^25.9.1",
+    "eslint": "^10.4.0",
+    "eslint-config-prettier": "^10.1.8",
+    "prettier": "^3.8.3",
+    "shx": "^0.4.0",
+    "typescript": "^6.0.3",
+    "typescript-eslint": "^8.59.4",
+    "vitest": "^4.1.7"
+  }
+}

package/LICENSE DELETED Viewed

@@ -1,21 +0,0 @@
-MIT License
-Copyright (c) 2025 DevEnterprise Software
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/README.md DELETED Viewed

@@ -1,155 +0,0 @@
-![ScrAPI logo](https://raw.githubusercontent.com/DevEnterpriseSoftware/scrapi-sdk-dotnet/master/icon_small.png)
-# ScrAPI MCP Server
-[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](https://opensource.org/licenses/MIT)
-[![NPM Downloads](https://img.shields.io/npm/dm/@deventerprisesoftware/scrapi-mcp)](https://www.npmjs.com/package/@deventerprisesoftware/scrapi-mcp)
-[![Docker Pulls](https://img.shields.io/docker/pulls/deventerprisesoftware/scrapi-mcp)](https://hub.docker.com/r/deventerprisesoftware/scrapi-mcp)
-[![smithery badge](https://smithery.ai/badge/@DevEnterpriseSoftware/scrapi-mcp)](https://smithery.ai/server/@DevEnterpriseSoftware/scrapi-mcp)
-MCP server for using [ScrAPI](https://scrapi.tech) to scrape web pages.
-ScrAPI is your ultimate web scraping solution, offering powerful, reliable, and easy-to-use features to extract data from any website effortlessly.
-<a href="https://glama.ai/mcp/servers/@DevEnterpriseSoftware/scrapi-mcp">
-  <img width="380" height="200" src="https://glama.ai/mcp/servers/@DevEnterpriseSoftware/scrapi-mcp/badge" alt="ScrAPI Server MCP server" />
-</a>
-## Tools
-1. `scrape_url_html`
-   - Use a URL to scrape a website using the ScrAPI service and retrieve the result as HTML.
-     Use this for scraping website content that is difficult to access because of bot detection, captchas or even geolocation restrictions.
-     The result will be in HTML which is preferable if advanced parsing is required.
-   - Inputs:
-     - `url` (string, required): The URL to scrape
-     - `browserCommands` (string, optional): JSON array of browser commands to execute before scraping
-   - Returns: HTML content of the URL
-2. `scrape_url_markdown`
-   - Use a URL to scrape a website using the ScrAPI service and retrieve the result as Markdown.
-     Use this for scraping website content that is difficult to access because of bot detection, captchas or even geolocation restrictions.
-     The result will be in Markdown which is preferable if the text content of the webpage is important and not the structural information of the page.
-   - Inputs:
-     - `url` (string, required): The URL to scrape
-     - `browserCommands` (string, optional): JSON array of browser commands to execute before scraping
-   - Returns: Markdown content of the URL
-## Browser Commands
-Both tools support optional browser commands that allow you to interact with the page before scraping. This is useful for:
-- Clicking buttons (e.g., "Accept Cookies", "Load More")
-- Filling out forms
-- Selecting dropdown options
-- Scrolling to load dynamic content
-- Waiting for elements to appear
-- Executing custom JavaScript
-### Available Commands
-Commands are provided as a JSON array string. All commands are executed with human-like behavior (random mouse movements, variable typing speed, etc.):
-| Command | Format | Description |
-|---------|--------|-------------|
-| **Click** | `{"click": "#buttonId"}` | Click an element using CSS selector |
-| **Input** | `{"input": {"input[name='email']": "value"}}` | Fill an input field |
-| **Select** | `{"select": {"select[name='country']": "USA"}}` | Select from dropdown (by value or text) |
-| **Scroll** | `{"scroll": 1000}` | Scroll down by pixels (negative values scroll up) |
-| **Wait** | `{"wait": 5000}` | Wait for milliseconds (max 15000) |
-| **WaitFor** | `{"waitfor": "#elementId"}` | Wait for element to appear in DOM |
-| **JavaScript** | `{"javascript": "console.log('test')"}` | Execute custom JavaScript code |
-### Example Usage
-```json
-[
-  {"click": "#accept-cookies"},
-  {"wait": 2000},
-  {"input": {"input[name='search']": "web scraping"}},
-  {"click": "button[type='submit']"},
-  {"waitfor": "#results"},
-  {"scroll": 500}
-]
-```
-### Finding CSS Selectors
-Need help finding CSS selectors? Try the [Rayrun browser extension](https://chromewebstore.google.com/detail/rayrun/olljocejdgeipcaompahmnfebhkfmnma) to easily select elements and generate selectors.
-For more details, see the [Browser Commands documentation](https://scrapi.tech/docs/api_details/v1_scrape/browser_commands).
-## Setup
-### API Key (optional)
-Optionally get an API key from the [ScrAPI website](https://scrapi.tech).
-Without an API key you will be limited to one concurrent call and twenty free calls per day with minimal queuing capabilities.
-### Cloud Server
-The ScrAPI MCP Server is also available in the cloud over SSE at https://api.scrapi.tech/mcp/sse and streamable HTTP at https://api.scrapi.tech/mcp
-Cloud MCP servers are not widely supported yet but you can access this directly from your own custom clients or use [MCP Inspector](https://github.com/modelcontextprotocol/inspector) to test it. There is currently no facility to pass through your API key when connecting to the cloud MCP server.
-![MCP-Inspector](https://raw.githubusercontent.com/DevEnterpriseSoftware/scrapi-mcp/master/img/mcp-inspector.jpg)
-### Usage with Claude Desktop
-Add the following to your `claude_desktop_config.json`:
-#### Docker
-```json
-{
-  "mcpServers": {
-    "ScrAPI": {
-      "command": "docker",
-      "args": [
-        "run",
-        "-i",
-        "--rm",
-        "-e",
-        "SCRAPI_API_KEY",
-        "deventerprisesoftware/scrapi-mcp"
-      ],
-      "env": {
-        "SCRAPI_API_KEY": "<YOUR_API_KEY>"
-      }
-    }
-  }
-}
-```
-#### NPX
-```json
-{
-  "mcpServers": {
-    "ScrAPI": {
-      "command": "npx",
-      "args": [
-        "-y",
-        "@deventerprisesoftware/scrapi-mcp"
-      ],
-      "env": {
-        "SCRAPI_API_KEY": "<YOUR_API_KEY>"
-      }
-    }
-  }
-}
-```
-![Claude-Desktop](https://raw.githubusercontent.com/DevEnterpriseSoftware/scrapi-mcp/master/img/claude-desktop.jpg)
-## Build
-Docker build:
-```bash
-docker build -t deventerprisesoftware/scrapi-mcp -f Dockerfile .
-```
-## License
-This MCP server is licensed under the MIT License. This means you are free to use, modify, and distribute the software, subject to the terms and conditions of the MIT License. For more details, please see the LICENSE file in the project repository.