Entity Attack Surface MCP Server

View on ApifyForge | Use on Apify Store

Quick Start

Add to your MCP client (Claude Desktop, Cursor, Windsurf):

{
  "mcpServers": {
    "entity-attack-surface-mcp": {
      "url": "https://ryanclinton--entity-attack-surface-mcp.apify.actor/mcp"
    }
  }
}

Entity attack surface mapping for any domain — via the Model Context Protocol. This MCP server orchestrates 11 passive reconnaissance sources to build a complete picture of an organization's digital exposure: DNS infrastructure, SSL certificate sprawl, Censys-indexed open ports, technology stack vulnerabilities, CISA Known Exploited Vulnerabilities, public code leaks, and historical drift. Designed for MSSPs, cyber insurers, SOC teams, and M&A due diligence analysts who need structured, AI-ready security intelligence without active scanning.

Connect your AI assistant or security workflow to 8 purpose-built tools that run in parallel, score findings across four risk dimensions, and return structured JSON with Exposure Scores (0-100) and A-F letter grades. No setup beyond adding the MCP endpoint — the server runs in standby mode on Apify's infrastructure.

What data can you extract?

Data Point	Source	Example
📡 DNS records (A, AAAA, MX, TXT, CNAME, NS)	DNS Record Lookup	`mail.acmecorp.com → 192.0.2.45`
🔐 SSL certificates and subdomain enumeration	crt.sh Certificate Transparency	`api.acmecorp.com`, `staging.acmecorp.com`
🌐 Domain registration and ownership	WHOIS Lookup	Registrar, creation date, expiry, registrant
🖥 Internet-facing hosts and open ports	Censys Host Search	Ports 443, 3389, 6379 on 3 hosts
📍 IP address geolocation and ASN	IP Geolocation	US-East (AS14618 Amazon), DE (AS16509 Amazon)
🐛 CVEs by detected technology	NVD CVE Database	CVE-2024-1234, CVSS 9.8 — Apache HTTP
🚨 Actively exploited vulnerabilities	CISA KEV Catalog	2 KEV matches — urgent remediation required
🔧 Web technology fingerprinting	Tech Stack Detector	WordPress 6.4, jQuery 1.12, PHP 8.1, Nginx
📚 Historical web presence snapshots	Wayback Machine	847 snapshots from 2009 to present
💻 Public code and credential exposure	GitHub Repo Search	3 repos flagged: `internal-config`, `deploy-keys`
🔄 Recent website content changes	Website Change Monitor	2 changes detected, 1 change >50% content diff
📊 Exposure Score and letter grade	Scoring Engine	Score: 67/100 — HIGH EXPOSURE, Grade: D

Why use Entity Attack Surface MCP Server?

Security assessments done manually take days. A skilled analyst needs to query DNS manually, pull cert transparency logs, check Censys, look up CVEs for each detected technology, cross-reference CISA KEV, check GitHub for leaked repos, and compile findings into a coherent risk picture. That process spans 8-12 tools, takes 4-8 hours per domain, and produces inconsistent output that is hard to act on.

This MCP automates the entire passive reconnaissance pipeline in minutes. Call a single tool from any MCP-compatible AI client — Claude, Cursor, Windsurf, Cline — and receive a structured JSON response with dimensional scores, prioritized findings, and remediation recommendations ready for board reports, underwriting decisions, or SIEM ingestion.

Scheduling — run weekly attack surface sweeps across your client portfolio to detect new exposure before attackers do
API access — trigger assessments from Python, JavaScript, or any HTTP client for integration with GRC platforms or ticketing systems
Parallel execution — up to 11 actors run simultaneously, cutting assessment time from hours to minutes
Monitoring — get Slack or email alerts when scans complete or produce critical findings via Apify webhooks
Integrations — connect results to Zapier, Make, Google Sheets, HubSpot, or custom SIEM pipelines via webhooks

Features

8 specialized MCP tools covering discovery, vulnerability mapping, KEV checking, sprawl analysis, drift detection, code exposure, vendor rating, and full vector reporting
11-actor parallel orchestration — DNS, SSL/crt.sh, WHOIS, Censys, IP Geo, NVD CVE, CISA KEV, Tech Stack, Wayback Machine, GitHub, and Website Change Monitor all queried in a single call
Exposure Score (0-100) computed across four weighted dimensions: Infrastructure Exposure (0-30), Vulnerability Exposure (0-30), Code & Data Exposure (0-20), and Historical Drift (0-20)
Five exposure grades with automated recommendations: MINIMAL, LOW, MODERATE, HIGH, and CRITICAL EXPOSURE with specific remediation language
Tech-stack-to-CVE-to-KEV pipeline — detects web technologies, cross-references each against NVD, then escalates any CISA KEV matches as urgent with BOD 22-01 compliance context
CISA KEV cross-referencing with remediation deadline tracking — flags vulnerabilities past their required patch date
Dangerous port detection against 8 high-risk ports: FTP (21), Telnet (23), SMB (445), RDP (3389), VNC (5900), Redis (6379), MongoDB (27017), Elasticsearch (9200)
High-CVE technology fingerprinting against a curated set of 20 technologies with historically significant vulnerability records including Apache, Log4j, Struts, WordPress, Confluence, and Jenkins
Infrastructure sprawl scoring with composite formula: subdomains × 2 + IPs × 3 + open ports × 4 + countries × 5 — scored LOW/MODERATE/HIGH
Third-party cyber rating (A-F) using a weighted composite: email security 20%, SSL hygiene 25%, network exposure 35%, tech complexity 20%
Code exposure scanning against 11 sensitive keyword patterns across three risk tiers (HIGH: secret, credential, password, token, api-key; MEDIUM: private, internal, config, .env; LOW: deploy, infra)
Stale repository detection — flags public repos with no commits in over 12 months as unpatched dependency risks
Historical drift analysis — cross-references Wayback Machine archive depth with current tech stack to surface data that may persist in cached versions
Passive reconnaissance only — no packets sent to target, no active scanning, entirely safe and legal
Pay-per-event pricing — charged only on tool call, not per actor run or data row

Use cases for attack surface intelligence

MSSP client portfolio assessments

MSSPs managing 50-500 clients cannot manually assess each client's external attack surface each month. This MCP enables automated external exposure sweeps across the full client roster. Feed each client domain into discover_attack_surface and tech_stack_vulnerability_map on a weekly schedule. Surface clients with new CISA KEV matches or newly exposed dangerous ports before the next QBR. Deliver quantified Exposure Scores as part of your reporting package without increasing analyst headcount.

Cyber insurance underwriting and renewal

Underwriters need objective technical risk signals before binding a cyber policy. Manual questionnaire-based assessments miss real exposure. Call third_party_cyber_rating and attack_vector_report during pre-bind to generate a composite A-F cyber rating with dimensional breakdowns for email security, SSL hygiene, network exposure, and tech complexity. Use Exposure Scores to tier applicants, justify pricing decisions, and document due diligence in the underwriting file.

SOC continuous monitoring and threat detection

SOC teams need to know when their organization's attack surface changes — new subdomains appear, certificates expire, dangerous ports open, or CISA KEV matches emerge. Schedule discover_attack_surface and cisa_kev_exposure_check on daily or weekly intervals. Connect results via webhooks to your SIEM or ticketing platform. Detect infrastructure changes that may indicate shadow IT, unauthorized deployments, or active compromise before threat actors exploit them.

M&A technical due diligence

Acquiring a company means acquiring its security debt. Technical due diligence rarely surfaces hidden liabilities: shadow IT subdomains, vulnerable tech stacks, exposed credentials in public repos, or dangerous open ports in acquired infrastructure. Run attack_vector_report and exposed_code_secrets_scan against the acquisition target's domain and GitHub organization during the due diligence window. Quantify security liability before signing and negotiate remediation obligations into deal terms.

Vendor risk management and supply chain security

Third-party vendors with poor security posture are a primary breach vector. Use third_party_cyber_rating to generate a cyber risk rating for any vendor during onboarding or annual review. Flag vendors with missing SPF/DMARC, expired certificates, RDP exposed to the internet, or CISA KEV matches in their tech stack. Maintain a rated vendor registry and re-assess automatically on renewal cycles.

Developer and DevSecOps security auditing

Development teams expose organizational risk through public GitHub repositories containing internal tooling names, configuration references, or deployment scripts. Run exposed_code_secrets_scan against your organization's GitHub org before a security audit or pen test. Identify repos with HIGH-risk keywords (secret, credential, token, api-key) and stale repos that may contain unpatched dependencies. Use findings to drive a secrets rotation and repository hygiene sprint.

How to run an attack surface assessment

Add the MCP server to your AI client — Copy the endpoint URL https://entity-attack-surface-mcp.apify.actor/mcp and paste it into your Claude Desktop, Cursor, or Cline MCP configuration. Add your Apify API token as the Bearer token. See the connection section below for exact config syntax.
Ask your AI assistant to run an assessment — Type a plain-language request: "Run an attack surface assessment for acmecorp.com and flag any CISA KEV matches." The AI selects the appropriate tool, passes the domain, and returns structured results.
Review the Exposure Score and findings — The response includes a score (0-100), letter grade, and dimensional breakdown with specific findings per category. CISA KEV matches appear with urgent alerts and BOD 22-01 remediation language.
Export or route the results — JSON output can be saved to Google Sheets via Apify integrations, pushed to a SIEM via webhook, or formatted into a PDF report by your AI assistant.

MCP tools

Tool	Event price	Actors called	Best for
`discover_attack_surface`	$2.00	4-5	Initial recon, asset inventory, cyber insurance
`tech_stack_vulnerability_map`	$2.00	2+	Vulnerability assessment, security audits
`cisa_kev_exposure_check`	$2.00	3	Compliance (BOD 22-01), emergency patching
`infrastructure_sprawl_analysis`	$2.00	4	Shadow IT discovery, M&A due diligence
`historical_drift_detection`	$2.00	2	Compromise detection, change auditing
`exposed_code_secrets_scan`	$2.00	1	Code leak detection, developer security
`third_party_cyber_rating`	$4.00	5	Vendor risk management, cyber insurance
`attack_vector_report`	$4.00	10-11	Full assessment, board reporting

Tool input parameters

discover_attack_surface

Parameter	Type	Required	Default	Description
`domain`	string	Yes	—	Target domain, e.g. `"acmecorp.com"`
`include_ip_geo`	boolean	No	`true`	Include IP geolocation for discovered hosts

tech_stack_vulnerability_map

Parameter	Type	Required	Default	Description
`url`	string	Yes	—	Target URL, e.g. `"https://acmecorp.com"`
`max_cves_per_tech`	number	No	`5`	Max CVEs to return per detected technology

cisa_kev_exposure_check

Parameter	Type	Required	Default	Description
`url`	string	Yes	—	Target URL to check

infrastructure_sprawl_analysis

Parameter	Type	Required	Default	Description
`domain`	string	Yes	—	Root domain to analyze

historical_drift_detection

Parameter	Type	Required	Default	Description
`url`	string	Yes	—	URL to analyze
`wayback_limit`	number	No	`20`	Max Wayback Machine snapshots to retrieve

exposed_code_secrets_scan

Parameter	Type	Required	Default	Description
`organization`	string	Yes	—	GitHub org or company name to search
`max_repos`	number	No	`30`	Maximum repositories to analyze

third_party_cyber_rating

Parameter	Type	Required	Default	Description
`domain`	string	Yes	—	Vendor domain to rate

attack_vector_report

Parameter	Type	Required	Default	Description
`domain`	string	Yes	—	Target domain
`url`	string	No	`https://<domain>`	Specific URL for tech stack detection
`github_org`	string	No	—	GitHub org for code exposure analysis

Output examples

attack_vector_report for a mid-size SaaS company:

{
  "domain": "pinnaclesoftware.io",
  "exposureScore": 67,
  "exposureGrade": "HIGH EXPOSURE",
  "dimensions": {
    "infrastructure": {
      "score": 22,
      "max": 30,
      "findings": [
        "14 unique IP addresses — significant infrastructure sprawl",
        "No SPF record — vulnerable to email spoofing",
        "No DMARC record — no email authentication policy",
        "Dangerous ports exposed: 3389, 6379 (RDP/Redis)"
      ]
    },
    "vulnerability": {
      "score": 21,
      "max": 30,
      "findings": [
        "4 high-CVE-history technologies detected: wordpress, jquery, php, nginx",
        "3 CRITICAL CVE(s) found in detected technology stack",
        "7 HIGH severity CVE(s)",
        "2 CISA Known Exploited Vulnerability(ies) — ACTIVELY EXPLOITED IN THE WILD",
        "1 KEV(s) past remediation deadline"
      ]
    },
    "codeData": {
      "score": 11,
      "max": 20,
      "findings": [
        "2 public repo(s) with potentially sensitive names/descriptions: internal-config, deploy-credentials",
        "23 public repositories",
        "8 stale/unmaintained public repos (no updates >1 year) — potential unpatched dependencies"
      ]
    },
    "historicalDrift": {
      "score": 13,
      "max": 20,
      "findings": [
        "Web presence dates back 14 years (since ~2010) — long history of potential cached data",
        "312 Wayback Machine snapshots — extensive archived content",
        "3 recent website change(s) detected — active modification of attack surface",
        "1 large content change(s) (>50% diff) — potential compromise or major restructuring",
        "Historical data available for drift analysis — compare archived vs current technology stack"
      ]
    }
  },
  "recommendation": "High exposure. Immediate remediation recommended. Engage security team for attack surface reduction.",
  "actorsUsed": 11,
  "assetSummary": {
    "dnsRecords": 18,
    "sslCertificates": 34,
    "censysHosts": 7,
    "technologies": 22,
    "cves": 41,
    "cisaKevs": 2,
    "waybackSnapshots": 20,
    "githubRepos": 23
  }
}

third_party_cyber_rating for vendor assessment:

{
  "domain": "cloudsupplier.net",
  "cyberRating": "C",
  "compositeScore": 74,
  "components": {
    "emailSecurity": {
      "score": 60,
      "hasSPF": true,
      "hasDMARC": false
    },
    "sslHygiene": {
      "score": 100,
      "totalCerts": 12,
      "expiredCerts": 0
    },
    "networkExposure": {
      "score": 65,
      "openPorts": 8,
      "dangerousPortsExposed": [3389]
    },
    "techComplexity": {
      "score": 70,
      "technologies": 20
    }
  },
  "whois": [
    {
      "domain": "cloudsupplier.net",
      "registrar": "Namecheap Inc.",
      "createdDate": "2017-03-14",
      "expiresDate": "2026-03-14"
    }
  ]
}

cisa_kev_exposure_check — urgent alert:

{
  "url": "https://legacyapp.betaindustries.com",
  "technologiesScanned": 14,
  "kevCatalogSize": 1100,
  "matchingKEVs": 2,
  "alert": "URGENT: 2 actively exploited vulnerability(ies) found in detected tech stack. Immediate patching required per BOD 22-01.",
  "kevMatches": [
    {
      "cveID": "CVE-2021-44228",
      "vendorProject": "Apache",
      "product": "Log4j",
      "vulnerabilityName": "Apache Log4j2 Remote Code Execution Vulnerability",
      "dateAdded": "2021-12-10",
      "dueDate": "2021-12-24",
      "requiredAction": "Apply updates per vendor instructions"
    }
  ],
  "detectedTechnologies": ["apache", "log4j", "tomcat", "jquery", "wordpress"]
}

Output fields

`attack_vector_report`

Field	Type	Description
`domain`	string	Target domain assessed
`exposureScore`	number	Composite Exposure Score, 0-100. Higher = greater risk
`exposureGrade`	string	One of: MINIMAL, LOW, MODERATE, HIGH, CRITICAL EXPOSURE
`recommendation`	string	Prioritized remediation guidance tied to the score band
`actorsUsed`	number	Number of data sources queried (up to 11)
`dimensions.infrastructure.score`	number	Infrastructure Exposure sub-score (0-30)
`dimensions.infrastructure.findings`	string[]	Specific infrastructure findings
`dimensions.vulnerability.score`	number	Vulnerability Exposure sub-score (0-30)
`dimensions.vulnerability.findings`	string[]	CVE and CISA KEV findings
`dimensions.codeData.score`	number	Code & Data Exposure sub-score (0-20)
`dimensions.codeData.findings`	string[]	GitHub exposure findings
`dimensions.historicalDrift.score`	number	Historical Drift sub-score (0-20)
`dimensions.historicalDrift.findings`	string[]	Wayback and change monitoring findings
`assetSummary.dnsRecords`	number	Total DNS records retrieved
`assetSummary.sslCertificates`	number	SSL certificates / subdomains found
`assetSummary.censysHosts`	number	Internet-facing hosts indexed by Censys
`assetSummary.technologies`	number	Web technologies detected
`assetSummary.cves`	number	Total CVEs found across tech stack
`assetSummary.cisaKevs`	number	CISA KEV matches found
`assetSummary.waybackSnapshots`	number	Wayback Machine snapshots retrieved
`assetSummary.githubRepos`	number	GitHub repos analyzed

`third_party_cyber_rating`

Field	Type	Description
`cyberRating`	string	Letter grade: A, B, C, D, or F
`compositeScore`	number	Weighted composite score, 0-100. Higher = better posture
`components.emailSecurity.score`	number	Email security sub-score (0-100). Penalized for missing SPF/DMARC
`components.emailSecurity.hasSPF`	boolean	Whether an SPF record is present
`components.emailSecurity.hasDMARC`	boolean	Whether a DMARC record is present
`components.sslHygiene.score`	number	SSL hygiene sub-score. Penalized for expired or absent certificates
`components.sslHygiene.expiredCerts`	number	Count of expired SSL certificates
`components.networkExposure.score`	number	Network exposure sub-score. Penalized per dangerous port
`components.networkExposure.dangerousPortsExposed`	number[]	Dangerous port numbers found open
`components.techComplexity.score`	number	Technology complexity sub-score
`components.techComplexity.technologies`	number	Number of distinct technologies detected

How much does it cost to run attack surface assessments?

This MCP server uses pay-per-event pricing — you pay per tool call based on the event triggered. Platform compute costs are included. There is no subscription and no monthly minimum.

Scenario	Tool called	Cost
Quick infrastructure recon	`discover_attack_surface`	$2.00
CISA KEV exposure check	`cisa_kev_exposure_check`	$2.00
Tech stack vulnerability map	`tech_stack_vulnerability_map`	$2.00
Infrastructure sprawl analysis	`infrastructure_sprawl_analysis`	$2.00
Historical drift detection	`historical_drift_detection`	$2.00
Exposed code secrets scan	`exposed_code_secrets_scan`	$2.00
Third-party cyber rating	`third_party_cyber_rating`	$4.00
Full attack vector report	`attack_vector_report`	$4.00

You can set a maximum spending limit per run to control costs. The server stops processing when your budget is reached.

Compare this to SecurityScorecard at $2,000-10,000/year or BitSight at similar tiers. For MSSP client assessments or periodic vendor checks, this MCP delivers equivalent passive reconnaissance data at $2-4 per assessment with no subscription commitment.

The Apify Free plan includes $5 of monthly platform credits, covering 1-2 full assessments per month at no cost.

How to connect this MCP server

Claude Desktop

Add to your claude_desktop_config.json:

{
  "mcpServers": {
    "entity-attack-surface": {
      "url": "https://entity-attack-surface-mcp.apify.actor/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_APIFY_TOKEN"
      }
    }
  }
}

Cursor / Windsurf / Cline

Add the MCP server in your editor's MCP settings panel:

Endpoint: https://entity-attack-surface-mcp.apify.actor/mcp
Auth: Bearer token (your Apify API token from console.apify.com/account/integrations)

Programmatic (HTTP / cURL)

# Call the attack_vector_report tool
curl -X POST "https://entity-attack-surface-mcp.apify.actor/mcp" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_APIFY_TOKEN" \
  -d '{
    "jsonrpc": "2.0",
    "method": "tools/call",
    "params": {
      "name": "attack_vector_report",
      "arguments": {
        "domain": "acmecorp.com",
        "github_org": "acmecorp"
      }
    },
    "id": 1
  }'

Python (via Apify API)

from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run = client.actor("ryanclinton/entity-attack-surface-mcp").call(run_input={})

# The MCP server runs in standby mode — use the endpoint directly for MCP calls.
# For one-off programmatic use, call via HTTP as shown above.
print(f"Server URL: https://entity-attack-surface-mcp.apify.actor/mcp")
print(f"Run ID: {run['id']}")

JavaScript

import { ApifyClient } from "apify-client";

const client = new ApifyClient({ token: "YOUR_API_TOKEN" });

// For direct MCP tool calls, use the HTTP endpoint:
const response = await fetch("https://entity-attack-surface-mcp.apify.actor/mcp", {
  method: "POST",
  headers: {
    "Content-Type": "application/json",
    "Authorization": `Bearer YOUR_API_TOKEN`,
  },
  body: JSON.stringify({
    jsonrpc: "2.0",
    method: "tools/call",
    params: {
      name: "third_party_cyber_rating",
      arguments: { domain: "vendor-example.com" },
    },
    id: 1,
  }),
});

const result = await response.json();
const rating = JSON.parse(result.result.content[0].text);
console.log(`Cyber rating for vendor: ${rating.cyberRating} (${rating.compositeScore}/100)`);
console.log(`Dangerous ports exposed: ${rating.components.networkExposure.dangerousPortsExposed.join(", ") || "None"}`);

How Entity Attack Surface MCP Server works

Phase 1: Parallel data collection

Each tool call dispatches concurrent requests to multiple Apify actors via runActorsParallel(). The attack_vector_report tool sends 10-11 actor calls simultaneously: DNS record lookup (up to 50 records), crt.sh SSL certificate search (up to 50 certs), WHOIS registration data, Censys host enumeration (up to 20 hosts), IP geolocation, tech stack detection (up to 50 technologies), NVD CVE search, CISA KEV catalog pull (up to 100 entries), Wayback Machine snapshot retrieval, and website change monitor data. When a GitHub organization is provided, a GitHub repository search runs as the 11th parallel call. Each actor has a 120-second timeout.

Phase 2: Tech-stack-to-CVE-to-KEV pipeline

The vulnerability dimension uses a three-stage pipeline. First, the Tech Stack Detector identifies up to 10 technologies on the target URL. Second, each technology name is submitted as a separate parallel query to the NVD CVE database (up to max_cves_per_tech results per technology). Third, the CISA KEV catalog is pulled and cross-referenced against detected technology names by matching vendor and product fields. Any KEV match triggers a BOD 22-01 compliance alert with the required remediation date. Technologies are pre-screened against a curated set of 20 high-CVE-history names (Apache, Log4j, Struts, WordPress, Drupal, Confluence, Jenkins, etc.) to generate early risk signals before CVE data arrives.

Phase 3: Exposure scoring engine

The computeExposureScore() function processes all collected data through four independent dimension scorers:

Infrastructure Exposure (0-30): Scores DNS IP sprawl (6 pts for >10 unique IPs, 3 pts for >5), missing SPF (3 pts), missing DMARC (2 pts), SSL subdomain count (5 pts for >20, 3 pts for >10), expired certificates (4 pts), young domains (2 pts), open port count from Censys (6 pts for >10 ports, 3 pts for >5), presence of any of 8 dangerous ports (5 pts), and multi-country infrastructure (2 pts).
Vulnerability Exposure (0-30): Scores high-CVE technologies (2 pts each, max 8 pts), CRITICAL CVEs (3 pts each, max 12 pts), HIGH CVEs (2 pts each, max 6 pts), and CISA KEV matches (5 pts each, max 15 pts).
Code & Data Exposure (0-20): Scores repos with sensitive name patterns (8 pts), large public repo counts (5 pts for >50, 3 pts for >20), and stale repo count (4 pts for >5 stale).
Historical Drift (0-20): Scores large Wayback Machine archive (4 pts for >100 snapshots), detected website changes (3 pts), large content changes >50% diff (5 pts), and availability of tech-vs-history comparison data (2 pts).

Dimension scores are capped at their maximums and summed to produce a total capped at 100. The grade is assigned from five bands: MINIMAL (0-15), LOW (16-35), MODERATE (36-55), HIGH (56-75), CRITICAL (76-100).

Phase 4: Third-party rating weighted composite

The third_party_cyber_rating tool uses a separate weighted scoring model. Four components start at 100 and are penalized: email security loses 40 pts per missing SPF or DMARC record; SSL hygiene loses 30 pts for expired certs or 50 pts for no certs found; network exposure loses 15 pts per dangerous port exposed and 20 pts for >10 total open ports; tech complexity is penalized 1.5 pts per detected technology (capped at 30 technologies). Components are combined with weights: email security 20%, SSL hygiene 25%, network exposure 35%, tech complexity 20%. The composite (0-100) maps to letter grades A (90-100), B (80-89), C (70-79), D (60-69), F (0-59). Note: this model uses higher score = better posture, the inverse of the Exposure Score.

Tips for best results

Start with discover_attack_surface before running the full report. The surface discovery tool is $2 and surfaces subdomain count, IP sprawl, and Censys findings quickly. Use those results to decide whether a full attack_vector_report ($4) is warranted.
Provide github_org in attack_vector_report when assessing technology companies. Code and data exposure contributes up to 20 points to the Exposure Score. Skipping GitHub analysis leaves a significant dimension unscored.
Use cisa_kev_exposure_check as a fast triage tool. At $2 per call, it identifies the most urgent finding (actively exploited vulnerabilities) with minimal cost. Run this first for new vendor assessments or after a CISA KEV catalog update.
Schedule weekly discover_attack_surface sweeps to detect changes. Infrastructure changes — new subdomains from SSL cert transparency, new Censys-indexed hosts, changes in open ports — are the earliest indicators of shadow IT or unauthorized deployments. Weekly runs create a change baseline.
Cross-reference infrastructure_sprawl_analysis results with your CMDB. The subdomain list from SSL certificate transparency often contains systems not tracked in internal asset inventories. Any subdomain not in your CMDB is shadow IT.
For M&A due diligence, run attack_vector_report with github_org and then third_party_cyber_rating separately. The attack_vector_report uses the Exposure Score model (higher = worse); third_party_cyber_rating uses the cyber rating model (higher = better). Together they give you two independent views of the target's security posture.
Set a spending limit for batch assessments. If you are running assessments across a large vendor list via the API, set maxTotalChargeUsd in your actor call to prevent runaway costs.
For SOC integration, route webhook output to your SIEM. The JSON output from attack_vector_report is structured and consistent — each field maps cleanly to a SIEM alert schema. Configure Apify webhooks to POST results to your SIEM's HTTP input when runs complete with CISA KEV matches or Exposure Scores above your threshold.

Combine with other Apify actors

Actor	How to combine
Website Tech Stack Detector	Run standalone tech detection before calling `tech_stack_vulnerability_map` to preview which technologies will be found before triggering CVE lookups
WHOIS Domain Lookup	Supplement `discover_attack_surface` with deep registrant history — useful for M&A target domain age and ownership verification
Website Change Monitor	Schedule independent change monitoring on key pages after a `historical_drift_detection` baseline run to track ongoing modifications
Company Deep Research	Combine cyber exposure score with business intelligence — financial health, leadership, legal history — for complete M&A or vendor due diligence packages
Website Contact Scraper	After attack surface mapping identifies subdomains, use contact scraping to find security team contacts for responsible disclosure or vendor remediation outreach
B2B Lead Qualifier	For MSSPs using this MCP to identify at-risk prospects, feed domains with HIGH or CRITICAL Exposure Scores into lead qualification for targeted outreach
Trustpilot Review Analyzer	Combine cyber risk ratings with reputation data for comprehensive vendor due diligence — technical risk plus customer experience signals

Limitations

No active scanning — this MCP performs passive reconnaissance only. Open port detection relies on Censys's periodic internet-wide scan index, not real-time port probing. A port may have opened or closed since the last Censys scan.
Tech stack detection requires a live, crawlable URL — if the target URL returns a non-200 response or blocks the Tech Stack Detector, the vulnerability dimension of the Exposure Score will be incomplete (0 technologies detected = no CVE or KEV data).
CISA KEV cross-referencing is name-based — the KEV catalog is matched against tech names detected on the page. Version-specific matching is not performed. A matched technology may be running a patched version; manual verification is required before acting on KEV alerts.
GitHub code exposure is metadata-based only — the exposed_code_secrets_scan tool analyzes repository names, descriptions, and metadata. It does not read file contents or scan code for actual secrets. A HIGH-risk flag means the repo name suggests sensitive content, not that secrets are confirmed present.
Censys index coverage varies — not all IP addresses and organizations are indexed equally. Small or newly-provisioned infrastructure may not appear in Censys results.
Certificate transparency depends on public CT logs — SSL subdomain discovery via crt.sh covers certificates issued to public CAs. Internal/private PKI certificates will not appear.
Historical drift analysis is bounded by Wayback Machine coverage — pages not indexed by the Internet Archive (robots.txt disallowed, recently launched, or low-traffic) will return minimal snapshot data.
Exposure Score is a risk signal, not a penetration test — this tool identifies surface-level indicators of exposure. It does not exploit vulnerabilities, test authentication, or confirm whether detected CVEs are actually reachable on the target system.
SPF/DMARC detection relies on DNS record content parsing — records in non-standard formats may not be detected correctly.

Integrations

Zapier — trigger attack surface assessments from Zapier workflows and route findings to Slack, Jira, or HubSpot when new high-risk vendors are onboarded
Make — build automated vendor review workflows that call third_party_cyber_rating on a schedule and log results to a Google Sheets risk register
Google Sheets — push Exposure Scores and cyber ratings for entire vendor portfolios to a live spreadsheet for review and tracking
Apify API — call this MCP server programmatically from your GRC platform, SIEM, or security orchestration tool via JSON-RPC over HTTP
Webhooks — send POST notifications to your SIEM or ticketing system when attack_vector_report runs complete with scores above your alert threshold
LangChain / LlamaIndex — incorporate attack surface data as a retrieval source in AI security agents that synthesize cyber risk across multiple organizational signals

Troubleshooting

Exposure Score returned with all zeros in a dimension — if a specific dimension scores 0, the underlying actors likely returned empty results. The most common cause is the discover_attack_surface step timing out for domains with many subdomains. Try reducing actor result limits or running tools individually to isolate which data source is failing.
Tech stack detection returns 0 technologies — the Tech Stack Detector requires a live URL returning a 200 response. Check that https://yourdomain.com is accessible and not behind an IP whitelist. If the target is a SPA or JavaScript-rendered app, the tech stack detector may not fully parse it — this will affect the vulnerability and KEV dimensions of the Exposure Score.
CISA KEV check shows 0 matches even for software with known KEVs — KEV cross-referencing matches on technology name strings. If the tech stack detector returns a generic framework name that does not match the KEV catalog's vendor/product fields exactly, matches will be missed. Manually verify by searching the CISA KEV catalog for the specific product version.
exposed_code_secrets_scan returns 0 repos — if the GitHub organization name does not match the exact GitHub org slug, the search returns no results. Confirm the organization's exact GitHub username (case-sensitive) before calling the tool.
Rate limiting or timeout errors on large domains — large enterprise domains with hundreds of subdomains and many Censys-indexed hosts may trigger actor timeouts (120-second limit per actor). For large domains, run infrastructure_sprawl_analysis and tech_stack_vulnerability_map separately rather than using attack_vector_report, which runs all actors in parallel.

Responsible use

This MCP server performs passive reconnaissance using only publicly available data sources (DNS, WHOIS, certificate transparency logs, NVD, CISA KEV catalog, Wayback Machine, GitHub public repos, Censys).
No active scanning, packet injection, or vulnerability exploitation is performed at any point.
Always ensure you have authorization to assess the target domain, particularly for third-party vendor assessments.
CISA KEV data is sourced from the U.S. government's public catalog and is provided for informational purposes. Findings require verification before acting.
Comply with applicable laws and regulations when using security intelligence data in underwriting, vendor contracts, or disclosure contexts.
For guidance on web scraping and passive reconnaissance legality, see Apify's guide.

FAQ

How does attack surface mapping via this MCP differ from SecurityScorecard or BitSight? SecurityScorecard and BitSight are subscription platforms costing $2,000-10,000+/year with proprietary data collection. This MCP queries the same public sources at $2-4 per assessment with no subscription. Commercial platforms offer broader proprietary baselines; this MCP is better suited for on-demand assessments, API-driven workflows, and AI assistant integration.

Does attack surface discovery perform active scanning or send packets to the target? No. Every data source is passive. DNS queries go to public resolvers, SSL certificates come from the crt.sh public log, host data comes from Censys's pre-built scan index, and tech stack detection reads publicly accessible HTTP responses. Nothing is probed, injected, or exploited. The target domain receives no unusual traffic from this tool.

How accurate is the tech-stack-to-CVE pipeline? Accuracy depends on what the Tech Stack Detector can identify on the target URL. Publicly visible technologies (server headers, HTML meta tags, JavaScript library signatures, CMS indicators) are reliably detected. Technologies behind authentication walls, internal services, or heavily obfuscated stacks are not detectable. CVE matching is keyword-based against technology names — version-specific matching is not performed.

What is the CISA KEV catalog and why does it matter for attack surface assessment? The CISA Known Exploited Vulnerabilities catalog is maintained by the U.S. Cybersecurity and Infrastructure Security Agency and lists CVEs confirmed to be actively exploited by threat actors in the wild. Under Binding Operational Directive 22-01, U.S. federal agencies must patch KEV entries within prescribed deadlines. Finding KEV matches in a vendor's or target's tech stack is the highest-urgency finding in any attack surface assessment — it indicates confirmed exploitation capability, not just theoretical risk.

How many domains can I assess in a single run? Each tool call assesses one domain or URL. For batch portfolio assessments, call the tools programmatically via the HTTP API in a loop from your application. Use the Apify Scheduler to run recurring sweeps and set a maxTotalChargeUsd limit to control batch costs.

Can I schedule this MCP for continuous monitoring? Yes. Use the Apify Scheduler to trigger discover_attack_surface or cisa_kev_exposure_check on daily, weekly, or monthly schedules. Combine with webhooks to notify your team when new high-risk findings appear. For change-detection use cases, the historical_drift_detection tool combined with a weekly schedule creates a practical compromise detection workflow.

Is it legal to perform attack surface mapping on third-party domains? Passive reconnaissance using publicly available data (DNS records, WHOIS, certificate transparency logs, published vulnerability databases) is legal in most jurisdictions. This tool does not exploit vulnerabilities, access private systems, or perform unauthorized access. For vendor assessments, passive reconnaissance is standard practice in third-party risk management. See Apify's web scraping legality guide for more detail.

How long does a full attack_vector_report take? The full report runs up to 11 actors in parallel, each with a 120-second timeout. In practice, most assessments complete in 60-180 seconds depending on how quickly each underlying actor returns data. Data-rich domains with many subdomains and Censys results take longer than minimal domains.

What Exposure Score should trigger escalation? The recommended thresholds: scores above 55 (MODERATE+) warrant scheduling a security review within the next sprint. Scores above 75 (CRITICAL) should trigger immediate engagement of the security team. Any run returning CISA KEV matches should be escalated regardless of the total score — KEV matches indicate active exploitation risk.

Can I use this MCP with AI frameworks like LangChain or LlamaIndex? Yes. The MCP endpoint at https://entity-attack-surface-mcp.apify.actor/mcp is compatible with any MCP client. For LangChain and LlamaIndex, use the Apify integration or call the HTTP endpoint directly as a custom tool. The structured JSON responses make it straightforward to build security intelligence agents that synthesize attack surface data with other data sources.

What happens if an underlying actor fails or times out? The orchestration layer catches individual actor failures and returns empty arrays for that data source rather than failing the entire run. Results from other actors are still returned. If a critical actor (such as Tech Stack Detector) times out, the corresponding dimension score will reflect zero findings — the Exposure Score will be understated. The actorsUsed field shows how many actors successfully returned data.

How does the exposed code secrets scan work? The tool queries GitHub for public repositories matching the target organization name, then checks each repo's name, description, and full name against 11 keyword patterns across three risk tiers: HIGH (secret, credential, password, token, api-key), MEDIUM (private, internal, config, .env), and LOW (deploy, infra). Stale repositories (no commits in over 12 months) are also flagged. File contents are not read — this is metadata analysis only.

Help us improve

If you encounter issues, you can help us debug faster by enabling run sharing in your Apify account:

Go to Account Settings > Privacy
Enable Share runs with public Actor creators

This lets us see your run details when something goes wrong, so we can fix issues faster. Your data is only visible to the actor developer, not publicly.

Support

Found a bug or have a feature request? Open an issue in the Issues tab on this actor's page. For custom solutions, enterprise integrations, or MSSP volume pricing, reach out through the Apify platform.

Name		Name	Last commit message	Last commit date
Latest commit History 2 Commits
LICENSE		LICENSE
README.md		README.md
glama.json		glama.json

Folders and files

Latest commit

History

Repository files navigation

Entity Attack Surface MCP Server

Quick Start

What data can you extract?

Why use Entity Attack Surface MCP Server?

Features

Use cases for attack surface intelligence

MSSP client portfolio assessments

Cyber insurance underwriting and renewal

SOC continuous monitoring and threat detection

M&A technical due diligence

Vendor risk management and supply chain security

Developer and DevSecOps security auditing

How to run an attack surface assessment

MCP tools

Tool input parameters

Output examples

Output fields

attack_vector_report

third_party_cyber_rating

How much does it cost to run attack surface assessments?

How to connect this MCP server

Claude Desktop

Cursor / Windsurf / Cline

Programmatic (HTTP / cURL)

Python (via Apify API)

JavaScript

How Entity Attack Surface MCP Server works

Phase 1: Parallel data collection

Phase 2: Tech-stack-to-CVE-to-KEV pipeline

Phase 3: Exposure scoring engine

Phase 4: Third-party rating weighted composite

Tips for best results

Combine with other Apify actors

Limitations

Integrations

Troubleshooting

Responsible use

FAQ

Help us improve

Support

About

Topics

Resources

License

Uh oh!

Stars

Watchers

Forks

Releases

Packages 0

Uh oh!

Contributors

Uh oh!

`attack_vector_report`

`third_party_cyber_rating`

Packages