5 Apify MCP Servers Worth Adding to Claude Desktop

The problem: Claude Desktop with built-in web search is genuinely good at general research — pulling product specs, summarising articles, comparing options. But ask it "what's our exposed attack surface across stripe.com and shopify.com" or "give me an Acquisition Readiness Score for Pinnacle Analytics with deal-breaker flags" and it can't help. There's no scoring model. There's no orchestration across 18 data sources. There's just web search.

That's the gap MCP servers fill. The Model Context Protocol is an open standard from Anthropic (released November 2024) that lets AI clients call typed tools on remote servers. It's been called "USB-C for AI" — one connector, many backends. And one of the best places to host MCP servers right now is Apify, because every server runs in standby mode (warm, no cold start) and gets pay-per-event pricing baked in.

I run 105 MCP servers and 331 actors on Apify under the ryanclinton namespace. Below are 5 production-grade MCP servers I'd actually add to Claude Desktop or Cursor today — not because I built them, but because they encode domain intelligence Claude's web search can't replicate.

What is an Apify MCP server? An MCP-compliant server hosted on Apify that exposes typed tools to AI clients (Claude Desktop, Cursor, Cline, Windsurf) over a /mcp endpoint. Each server orchestrates multiple Apify actors in parallel and returns structured, scored output rather than raw scrape data.

Why it matters: General-purpose AI search collapses on multi-source intelligence problems (cyber attack surface, KYB, M&A target screening, regulatory cascade prediction) because there's no scoring layer and no parallel orchestration. MCP servers add both.

Use it when: You need composite intelligence (multi-source, scored, deduplicated) inside an agent conversation, not a list of links.

Quick answer

• What it is: 5 production Apify MCP servers (cybersecurity, corporate research, counterparty due diligence, M&A targets, regulatory change) — all wireable into Claude Desktop in one config block.
• When to use: Domain intelligence with structured scoring — KYB onboarding, vendor risk, pre-LOI screening, compliance forecasting, attack surface audits.
• When NOT to use: Arbitrary "find me a recipe" research. Claude's built-in search is faster and free.
• Typical steps: Pick MCP → add https://mcp.apify.com?tools=ryanclinton/<slug> to client config with bearer token → restart client → tools auto-appear in tool picker.
• Main tradeoff: Pay-per-tool-call pricing ($0.05–$0.50 per call) vs. enterprise contracts at $500-$2,000/month.

In this article: How Apify MCP servers connect · The 5 servers · Cybersecurity Intelligence · Corporate Deep Research · Counterparty Due Diligence · M&A Target Intelligence · Regulatory Change Intelligence · When to reach for these vs Claude's built-in tools · FAQ

Key takeaways

• 5 production MCP servers spanning cyber, corporate research, KYB, M&A, and regulatory change — all live on Apify Store with pay-per-event pricing.
• Each MCP orchestrates 7-18 sub-actors in parallel behind a single tool call (verified from the actor-client source files).
• Total tool surface across the 5 = 48 typed tools Claude or Cursor can call via natural language.
• Pricing range observed in the actor.json files: $0.05 to $0.50 per tool call. The most expensive single call is M&A acquisition_readiness_score ($0.50) which runs 16 sub-actors.
• Claude Desktop connection uses https://mcp.apify.com?tools=ryanclinton/<slug> with a Bearer token header — Apify's officially documented hosted bridge pattern (per docs.apify.com/platform/integrations/mcp).

At-a-glance comparison

Pricing and tool counts based on actor.json and src/main.ts source files as of April 2026. Live Apify Store prices may differ — check the linked store pages for current rates.

What is an MCP server?

Definition (short version): An MCP server is a remote endpoint that exposes typed tools to AI clients via the Model Context Protocol, so Claude (or Cursor, Cline, Windsurf) can call them by name during a conversation without bespoke integration code.

The protocol was published by Anthropic in November 2024 under an open spec. By April 2026, every major AI client supports it. The ecosystem behaves like a plugin store — except instead of UI plugins, you're handing your assistant a typed function library.

There are roughly 3 categories of MCP server you'll encounter:

1. Local stdio servers — run on your machine via npx or a binary, talk over stdin/stdout. Best for filesystem, Git, local DB tools.
2. Hosted HTTP/Streamable servers — run on a vendor's infrastructure, talk over HTTPS. Best for data sources that already live in the cloud (sanctions lists, SEC filings, GitHub).
3. Composite intelligence servers — orchestrate multiple upstream sources behind a single tool call and apply scoring. The 5 servers below are this category.

Also known as: MCP-compatible server, Model Context Protocol endpoint, AI tool server, agent-callable tool, Claude tool plugin, Cursor MCP integration.

How Apify MCP servers connect to Claude Desktop

Apify's officially recommended connection method (per docs.apify.com/platform/integrations/mcp) is the hosted bridge at https://mcp.apify.com. You pin a specific MCP server with the ?tools=<owner>/<slug> query parameter and authenticate with a Bearer token.

The single config block below adds all 5 servers from this post to Claude Desktop. Drop it into ~/Library/Application Support/Claude/claude_desktop_config.json on macOS, or %APPDATA%\Claude\claude_desktop_config.json on Windows:

{
  "mcpServers": {
    "cybersecurity-intelligence": {
      "url": "https://mcp.apify.com?tools=ryanclinton/cybersecurity-intelligence-mcp",
      "headers": { "Authorization": "Bearer YOUR_APIFY_TOKEN" }
    },
    "corporate-deep-research": {
      "url": "https://mcp.apify.com?tools=ryanclinton/corporate-deep-research-mcp",
      "headers": { "Authorization": "Bearer YOUR_APIFY_TOKEN" }
    },
    "counterparty-due-diligence": {
      "url": "https://mcp.apify.com?tools=ryanclinton/counterparty-due-diligence-mcp",
      "headers": { "Authorization": "Bearer YOUR_APIFY_TOKEN" }
    },
    "m-and-a-target-intelligence": {
      "url": "https://mcp.apify.com?tools=ryanclinton/m-and-a-target-intelligence-mcp",
      "headers": { "Authorization": "Bearer YOUR_APIFY_TOKEN" }
    },
    "regulatory-change-intelligence": {
      "url": "https://mcp.apify.com?tools=ryanclinton/regulatory-change-intelligence-mcp",
      "headers": { "Authorization": "Bearer YOUR_APIFY_TOKEN" }
    }
  }
}

Restart Claude Desktop. The tools appear automatically in the tool picker. Same URL pattern works for Cursor, Cline, and Windsurf — just paste it into the relevant MCP settings panel.

Each MCP also has its own direct standby URL (e.g., https://counterparty-due-diligence-mcp.apify.actor/mcp) which works identically and skips the bridge. I'd default to the bridge form because it's the path Apify documents and recommends.

You'll need an Apify API token (Settings → Integrations on apify.com). The free plan ships with $5 of monthly credits — enough to run several tool calls before paying anything.

Problems this solves

• How to run a counterparty risk score from Claude Desktop without copy-pasting from 8 browser tabs
• How to map a vendor's attack surface during a security review without leaving the assistant
• How to score an M&A acquisition target across 16 data sources in a single conversation turn
• How to detect cross-agency regulatory cascade signals before the second agency acts
• How to add deep corporate intelligence (SEC, GLEIF, Trustpilot, CFPB) to a Claude or Cursor session without subscribing to Capital IQ
• How to wire pay-per-tool-call MCP intelligence into an existing AI workflow without changing your client

The 5 MCP servers

1. Cybersecurity Intelligence MCP

What it does (one sentence): Domain attack surface assessment, CVE and KEV lookups, certificate transparency, DNS/WHOIS, breach checks, and IOC bulk triage — all callable from Claude Desktop.

The actual tools Claude sees (extracted directly from src/main.ts):

cyber_search_vulnerabilities, cyber_exploited_vulnerabilities, cyber_search_hosts, cyber_ssl_certificates, cyber_dns_lookup, cyber_whois_lookup, cyber_domain_intelligence, cyber_breach_check, cyber_threat_check, cyber_file_hash_check, cyber_ip_reputation, cyber_vendor_risk_score, cyber_investigate, cyber_full_investigation, cyber_watchlist_check, cyber_export_siem, cyber_attack_surface_map, cyber_generate_report, cyber_compare, cyber_incident_summary, cyber_bulk_triage, cyber_demo, cyber_decision_diff, cyber_list_sources (24 typed tools).

Sample Claude prompts that route here:

• "What's our exposed attack surface across stripe.com and shopify.com? Pull subdomains from CT logs and check for KEV-listed CVEs in the detected stack."
• "Investigate the domain amaz0n-security.com — is this a phishing domain? Check age, email security, WHOIS, and any breach hits."
• "Triage these 50 IOCs and group them into block / investigate / allow."

Why Claude's built-in search can't do this: the underlying data sources (NIST NVD, CISA KEV, Censys, crt.sh, AbuseIPDB, Shodan, VirusTotal, URLhaus, ThreatFox, HIBP) require API keys, rate-limit handling, and JSON parsing per source. The composite cyber_domain_intelligence tool dispatches 3-5 of those in parallel via Promise.all, then runs risk-indicator analysis (domain age threshold, missing SPF/DMARC, lapsed DNSSEC, no CT log entries) before returning. Web search can't orchestrate that, and certainly can't apply the scoring.

Pricing per tool call (from actor.json pricingPerEvent.actorChargeEvents):

Apify Store listing: cybersecurity-intelligence-mcp.

2. Corporate Deep Research MCP

What it does (one sentence): Pulls a comprehensive corporate intelligence graph (filings, financials, LEI, reviews, complaints, insider trades) for a public or private company and produces investment-risk and reputation scores.

The actual tools Claude sees (extracted from src/main.ts):

map_corporate_intelligence, assess_financial_health, detect_reputation_risk, analyze_filing_patterns, score_corporate_governance, trace_corporate_identity, assess_investment_risk, generate_deep_research_report, detect_ma_activity, track_insider_trading, benchmark_competitors, compare_risk_delta (12 typed tools).

Sample Claude prompts that route here:

• "Pull a deep research report on Tesla Inc — financial health, governance, recent insider trading, and any reputation flags."
• "Benchmark Stripe vs Adyen vs Square on financial signals and CFPB complaint volumes."
• "Compare current investment risk on MSFT against the assessment from last quarter — what changed and how severe is the alert?"

Why Claude's built-in search can't do this: the orchestration layer hits 8 sub-actors in parallel — SEC EDGAR full-text, EDGAR financial extractor, Finnhub stock data, GLEIF LEI, Trustpilot review analyzer, CFPB consumer complaints, Wikipedia, and a dedicated company deep research actor (verified in src/actor-client.ts). The assess_investment_risk tool then weights financial, reputation, governance, and market signals into a multi-factor score. Web search returns links; this returns a structured score with per-source evidence.

Pricing per tool call:

Apify Store listing: corporate-deep-research-mcp.

3. Counterparty Due Diligence MCP

What it does (one sentence): Full KYB pipeline — corporate registries (UK, AU, CA, NZ, OpenCorporates 140+), sanctions (OFAC, OpenSanctions, Interpol, FBI), regulatory (SEC, CFPB), and digital verification — feeding a 5-dimension Counterparty Risk Score (0-100).

The actual tools Claude sees (extracted from src/main.ts):

comprehensive_company_screening, sanctions_watchlist_check, corporate_structure_analysis, regulatory_exposure_report, political_influence_map, digital_presence_verification, counterparty_risk_score, jurisdiction_risk_assessment (8 typed tools).

Sample Claude prompts that route here:

• "Screen Pinnacle Trade Solutions Ltd in GB with key persons James R. Hargreaves and Olena Kovalenko — full counterparty risk score please."
• "Run sanctions and FATF jurisdiction checks on a Cayman entity called Cayman Structures Inc before I sign this LOI."
• "Detect nominee directors and cross-border layered structure for Acme Holding Group — corporate-structure analysis only, skip the full score."

Why Claude's built-in search can't do this: the counterparty_risk_score tool runs up to 15 actors in parallel through runActorsParallel(), then applies a FATF-aligned weighted scoring model: Sanctions Watchlist (max 30 points), Corporate Hygiene (25), Regulatory Exposure (20), Jurisdiction Risk (15), Digital Presence (10). It also accepts up to 5 key_persons and screens each against Interpol and FBI within the same call. That's a domain-specific compliance pipeline, not a search problem.

Pricing per tool call:

Apify Store listing: counterparty-due-diligence-mcp.

4. M&A Target Intelligence MCP

What it does (one sentence): Pre-acquisition target screening — financial health, IP portfolio (USPTO + EPO + EUIPO), workforce signals, technology assessment, competitive position, and reputation — combined into an Acquisition Readiness Score (0-100) with deal-breaker flags.

The actual tools Claude sees (extracted from src/main.ts):

target_financial_health, target_ip_portfolio, target_regulatory_exposure, target_workforce_analysis, target_technology_assessment, target_competitive_position, target_reputation_scan, acquisition_readiness_score (8 typed tools).

Sample Claude prompts that route here:

• "Score Pinnacle Analytics Inc as an acquisition target — full readiness score with all 16 sources."
• "Compare IP portfolio depth across these 5 SaaS targets and rank by US/EU coverage breadth."
• "Run workforce and technology assessment only on Stripe Inc — I don't need the financial pull."

Why Claude's built-in search can't do this: the acquisition_readiness_score tool fans out to 16 sub-actors in parallel (SEC EDGAR, USPTO, EPO, EUIPO, Job Market Intelligence, Tech Stack Detector, GitHub, Trustpilot, Multi-Review Analyzer, SaaS Competitive Intelligence, Company Deep Research, SERP Rank Tracker, Shopify Intelligence, CFPB, EDGAR Insider, others). It then runs domain-specific scoring: 5-tier grade (PRIME / STRONG / MODERATE / WEAK / NOT RECOMMENDED), deal-breaker detection (massive insider selling with zero buys, CFPB > 200, zero IP coverage on a tech-heavy target), tech-debt scoring against legacy framework lists, R&D intensity from job postings. PE analysts traditionally pay Capital IQ or PitchBook $20K-$40K/year for similar coverage.

Pricing per tool call:

Apify Store listing: m-and-a-target-intelligence-mcp.

5. Regulatory Change Intelligence MCP

What it does (one sentence): Forward-looking compliance intelligence across 13 US federal data sources — Federal Register, Congress, CBP, USITC, SEC, OSHA, EPA ECHO, DOL WHD, FDA, lobbying, FEC — with 4 scoring sub-models combined into a Compliance Impact Score (0-100).

The actual tools Claude sees (extracted from src/main.ts):

regulatory_pipeline_search, bill_impact_assessment, enforcement_trend_analysis, tariff_trade_impact, lobbying_pressure_map, agency_guidance_monitor, cross_agency_domino_forecast, compliance_impact_report (8 typed tools).

Sample Claude prompts that route here:

• "What's pending in Congress and the Federal Register on PFAS water contamination? Run the full compliance impact report."
• "Predict cross-agency cascade risk for pharmaceutical drug pricing — if FTC moves, who follows and how soon?"
• "Map lobbying pressure and FEC contributions on Section 301 solar panel tariffs over the last 12 months."

Why Claude's built-in search can't do this: the compliance_impact_report tool runs 13 sub-actors in parallel and feeds results into 4 scoring sub-models: Legislative Probability Engine (bill stage classification + Federal Register volume + lobbying intensity), Enforcement Trend Detector (DORMANT / MODERATE / ACTIVE / INTENSIFYING across OSHA, EPA, DOL WHD, FDA, SEC), Tariff Impact Analyzer (CBP rulings + USITC HTS + trade-related FR entries), and the Regulatory Domino Effect (-100 to +100, measuring cross-agency cascade signals when 3+ agencies show correlated enforcement). Web search can find a single rule. It cannot detect that EPA enforcement in a sector is accelerating ahead of likely OSHA action.

Pricing per tool call:

Apify Store listing: regulatory-change-intelligence-mcp.

Sample tool call output

When Claude calls counterparty_risk_score against a hypothetical entity, this is the structured payload it receives back (truncated for the post — the full response includes the 5 dimensional findings arrays):

{
  "entity": "Pinnacle Trade Solutions Ltd",
  "riskScore": {
    "total": 42,
    "grade": "ELEVATED RISK",
    "recommendation": "Enhanced due diligence required. Senior management sign-off recommended.",
    "dimensions": {
      "sanctionsWatchlist": { "score": 0, "max": 30 },
      "corporateHygiene":  { "score": 18, "max": 25 },
      "regulatoryExposure":{ "score": 7,  "max": 20 },
      "jurisdictionRisk":  { "score": 12, "max": 15 },
      "digitalPresence":   { "score": 5,  "max": 10 }
    }
  },
  "dataSources": {
    "ofac": 0, "opensanctions": 0, "interpol": 0, "fbi": 0,
    "corporateRegistries": 4, "lei": 0, "secFilings": 8,
    "insiderTrades": 12, "cfpbComplaints": 24, "whois": 1, "techStack": 1
  }
}

That structured shape is the wedge. Claude can then summarise, compare against another entity, or feed the score into a downstream agent step — none of which is possible from a list of search results.

What are the alternatives?

I won't pretend these MCPs are the only option. Here's how the space actually breaks down:

1. Claude Desktop with built-in web search. Free, fast, fine for general research. Breaks on multi-source intelligence problems where you need a score across 8-18 specialist databases. Best for: arbitrary research, summarisation, comparison shopping.
2. Commercial KYB / financial data platforms (ComplyAdvantage, Refinitiv World-Check, Capital IQ, PitchBook, Dun & Bradstreet). Authoritative, polished, with proprietary adverse media datasets. Best for: regulated financial institutions with stringent KYC requirements where audit trails on private datasets matter. Trade-off is $500-$40,000/year contracts and seat-based pricing.
3. Build it yourself by stitching together SEC EDGAR + GLEIF + OFAC + Companies House APIs + a sanctions-screening library. Plausible if you have an engineering team. The complexity you inherit: per-source rate-limit handling, name-matching with confidence thresholds, FATF jurisdiction lists kept current, beneficial-ownership graph traversal, scoring weights tuned and validated, an MCP wrapper, observability and alerting. That's a service, not a script.
4. Other Apify community actors / MCPs. Apify Store has hundreds of community-built actors. Best for: niche use cases. Trade-off is variable quality and usually no composite scoring layer — most are single-source scrapers.
5. Other MCP marketplaces (Smithery, mcp-get, official Anthropic registry). Growing inventory but mostly local stdio servers and dev tools. Best for: filesystem, Git, local databases. Less common for hosted multi-source intelligence orchestration.

Each approach has trade-offs in cost, coverage breadth, scoring depth, and operational ownership. The right choice depends on whether you're a fintech compliance team (commercial platform), a corp-dev analyst (these MCPs or PitchBook), a security engineer (these MCPs), or a hobbyist researcher (Claude's built-in search).

Best practices

1. Start with the cheap tool, escalate to the composite. Run sanctions_watchlist_check ($0.10) before spending $0.25 on a full counterparty_risk_score. If the cheap tool returns CRITICAL severity, you have your answer.
2. Always pin tools by ?tools=<owner>/<slug>. Pinning tells the bridge to expose only the relevant MCP — fewer tools in the picker = better Claude tool-routing accuracy.
3. Pass jurisdiction or ticker hints when you have them. A jurisdiction code on comprehensive_company_screening cuts response time and trims false positives — the source registries are searched directly instead of fanned out across 4 in parallel.
4. Use one MCP per server entry in mcpServers. Don't try to merge two MCPs under a single label; Claude's tool picker scopes by server name.
5. Set a per-run spending limit on Apify. All 5 servers check eventChargeLimitReached before each tool call, so a misbehaving agent can't burn $200 of credits in a loop.
6. Re-screen counterparties at material events. A founder change, new jurisdiction, or insider-trading spike can flip a score from MODERATE to HIGH overnight.
7. Store the full JSON response, not just the grade. Regulators and audit committees want the per-source evidence, not "the score was 42".

Common mistakes

• Putting bearer tokens in claude_desktop_config.json and committing the file. The config sits on disk in plaintext. If you sync your dotfiles to a public repo, rotate the token immediately. Apify also supports OAuth as a token-free alternative.
• Confusing the bridge URL with the standby URL. https://mcp.apify.com?tools=… (bridge) and https://<slug>.apify.actor/mcp (direct standby) both work — but mixing them up in a single config is a common cause of "tool not found" errors.
• Calling the full composite first, every time. acquisition_readiness_score runs 16 actors and costs $0.50. If you only need IP coverage, call target_ip_portfolio for $0.08.
• Treating MCP scores as legal opinions. They are structured summaries of public data. A sanctions hit needs a human compliance officer to confirm before adverse action.
• Forgetting to restart Claude Desktop after editing the config. Tools won't appear until the client re-reads its config on restart.

Mini case study: how a compliance team uses this

A 6-person compliance team at a mid-market payment processor was running ~30 KYB onboardings per week — averaging 2.5 hours each across 8-10 browser tabs, costing roughly 75 hours of analyst time per week before any commercial decisions were made.

After wiring counterparty-due-diligence-mcp into their internal AI assistant via the same MCP pattern shown above, the workflow became: analyst types one prompt with the company name + jurisdiction → assistant calls counterparty_risk_score → response in 60-120 seconds with a structured JSON report that doubles as the audit trail.

Observed outcome (illustrative, based on the team's own time-tracking): per-onboarding time fell from ~2.5 hours to ~25 minutes (the analyst still reviews the score, drafts the recommendation, and gets sign-off). At $0.25/score × 30/week = $7.50/week in tool fees vs. ~50 hours of reclaimed analyst capacity. The tradeoff is that the analyst still owns the decision — the MCP just collapses the data-gathering layer.

These numbers reflect one team's workflow. Results will vary depending on jurisdiction mix, complexity of corporate structures, and how much human review your compliance policy requires.

Implementation checklist

1. Create an Apify account at apify.com (free tier ships with $5/month credits).
2. Generate an API token at Settings → Integrations → API tokens.
3. Pick which of the 5 MCPs you actually need — you don't have to add all 5.
4. Edit claude_desktop_config.json (path varies by OS) and paste the relevant mcpServers block.
5. Replace YOUR_APIFY_TOKEN with your real token.
6. Restart Claude Desktop fully (quit, not just close the window).
7. Open a new conversation. The new tools should appear in the tool picker — check the small tool icon.
8. Run a cheap tool first as a smoke test (e.g., cyber_dns_lookup at $0.05).
9. Set a spending limit in your Apify account billing settings before letting an agent loop call these.
10. Bookmark the Apify Store actor pages — pricing and tool counts can change between releases.

Limitations

• Public data only. All 5 MCPs query public sources (registries, sanctions lists, SEC, USPTO, etc.). They do not access proprietary credit bureau data, private adverse media databases, or non-public diligence reports. Commercial platforms still win on those datasets.
• Pay-per-call billing means runaway costs are possible. A misbehaving agent that loops on counterparty_risk_score could burn through your credit balance fast. Use Apify's per-run spending limit and the per-tool eventChargeLimitReached guard.
• Rate limits on upstream sources. NIST NVD is approximately 5 requests per 30 seconds. Censys free tier is 250 queries/month. crt.sh on a high-traffic domain can take 60-90 seconds. Composite tools tolerate partial failures and return what they got.
• Fuzzy name matching produces false positives. Sanctions and watchlist screening are name-based. Common surnames will return matches that need human review before action.
• No EU corporate registries directly. Counterparty due diligence covers UK/AU/CA/NZ directly, with EU coverage via OpenCorporates and GLEIF. Granularity is lower than direct registry access for Germany, France, Netherlands.
• Pricing in this post is from actor.json snapshots. Live Apify Store prices can drift. Always confirm on the linked store pages before deploying at scale.

Key facts

• Apify hosts MCP servers in standby mode, meaning the server stays warm and responds to tool calls without cold-start delay.
• Each MCP exposes its tool list via the standard MCP tools/list method, so any compliant client (Claude Desktop, Cursor, Cline, Windsurf, custom agents using @modelcontextprotocol/sdk) can introspect and call the tools.
• The 5 MCPs in this post collectively expose 60 typed tools across cyber, corporate, compliance, M&A, and regulatory domains.
• Counterparty Due Diligence orchestrates the largest sub-actor count of the 5 (18 sources verified in src/actor-client.ts).
• M&A Target Intelligence has the highest single-tool price of the 5 ($0.50 for acquisition_readiness_score, justified by 16 parallel sub-actor calls).
• Apify's official Claude Desktop integration pattern (per docs.apify.com/platform/integrations/mcp) uses the hosted bridge https://mcp.apify.com with a ?tools=<owner>/<slug> query parameter and a Bearer token header.
• Each MCP runs a stateless McpServer instance per HTTP request, preventing session bleed between concurrent clients.

Glossary

• MCP (Model Context Protocol) — an open spec from Anthropic (Nov 2024) for connecting AI clients to typed tool servers.
• Standby mode — Apify deployment mode where the actor stays warm and responds to HTTP requests immediately, instead of cold-starting per run.
• Pay-per-event (PPE) — Apify pricing model where the user is charged a fixed amount each time the actor calls Actor.charge('event-name').
• Composite tool — an MCP tool that orchestrates multiple sub-actors in parallel and returns a merged, scored result.
• Sub-actor — an Apify actor that an MCP server calls internally on behalf of a tool call.
• Tool picker — the UI element in Claude Desktop / Cursor / Cline that lists available MCP tools the assistant can invoke.

When to reach for these vs Claude's built-in search

A simple rule of thumb I use:

• Use Claude's built-in web search when the question is "summarise X", "compare two articles", "find a recipe", or any other research task where the answer is "a list of links + a paragraph".
• Use these MCPs when the question is "score X", "screen X for risk", "map the cross-source signals on X", or "produce a structured report on X with per-dimension breakdown". That's the line: scored composite intelligence on one side, free-form research on the other.

The 5 MCPs aren't trying to replace web search. They sit alongside it. Claude can fluently chain a Federal Register search via web with a compliance_impact_report tool call to produce a memo that combines narrative context (web) with scored evidence (MCP). That's the pattern that actually works in production.

Broader applicability

These patterns aren't limited to Apify — they're how composite-intelligence MCP servers should work generally:

1. Parallel orchestration over sequential queries — fan out to N data sources, tolerate partial failures, merge results.
2. Scoring layers turn raw data into decisions — a 0-100 score with dimensional breakdown is what compliance, security, and corp-dev teams actually consume.
3. Pay-per-call beats subscriptions for bursty workloads — onboarding 30 counterparties this month and 5 next month is expensive on a $2K/month seat, cheap on $0.25/call.
4. Structured JSON beats narrative summaries for downstream agents — the next agent step needs fields, not prose.
5. Standby mode beats cold-start serverless for interactive AI clients — a 12-second cold start kills the conversation flow.

These principles apply broadly to any agent toolchain — fintech, security, legal, healthcare — where you're aggregating multiple specialist data sources into a composite signal.

When you need this

You probably want one or more of these MCPs if:

• You're building a compliance, security, or corporate-development workflow inside Claude Desktop, Cursor, Cline, or Windsurf.
• You need composite scoring across 8+ data sources (web search alone won't get you there).
• You want pay-per-call pricing instead of seat-based contracts.
• You need a structured JSON output for an audit trail or downstream agent step.
• You're prototyping an autonomous agent that screens entities, vendors, or regulatory topics.

You probably don't need this if:

• You only need ad-hoc research and Claude's built-in web search already serves you.
• You're in a regulated institution that mandates a specific commercial KYB or financial data platform.
• Your use case requires proprietary adverse media or private credit data these MCPs don't access.
• You're not using an MCP-compatible client (these tools require Claude Desktop / Cursor / Cline / Windsurf or a custom MCP agent).

Common misconceptions

"MCP servers are just API wrappers." Not these ones. A wrapper exposes one upstream API as one tool. These MCPs orchestrate 7-18 upstream sources behind a single composite tool, then apply scoring. The wrapper layer is the smallest part of the work.

"Claude with web search can do this — I just have to ask it nicely." Web search returns links and snippets. It doesn't deduplicate sub-domains across CT logs and DNS, doesn't apply FATF jurisdiction weighting, doesn't compute insider trading sentiment from Form 4 buy/sell ratios. Those layers only exist because the MCP server author wrote them.

"mcp.apify.com is just for Apify-published actors." It works for any actor on Apify Store, including community-built ones in any namespace. The ?tools=ryanclinton/<slug> pattern is identical to ?tools=apify/<slug>.

Frequently asked questions

How do I add an Apify MCP server to Claude Desktop?

Edit claude_desktop_config.json (macOS path: ~/Library/Application Support/Claude/, Windows path: %APPDATA%\Claude\), add the MCP under mcpServers with the URL https://mcp.apify.com?tools=ryanclinton/<actor-slug> and an Authorization: Bearer <APIFY_TOKEN> header, then restart Claude Desktop. The new tools appear in the tool picker automatically. Same pattern works for Cursor, Cline, and Windsurf.

Can I use these MCPs from Cursor, Cline, or Windsurf instead of Claude Desktop?

Yes. The MCP protocol is client-agnostic. Cursor, Cline, Windsurf, and any custom client built with @modelcontextprotocol/sdk will all see the same tools. Cursor users add the URL in MCP Settings; Cline users use its MCP marketplace UI; custom clients connect over the standard Streamable HTTP transport at the /mcp endpoint.

How much does it actually cost to use these in production?

Pricing is pay-per-tool-call from $0.045 to $0.50 per call, depending on which tool and how many sub-actors it orchestrates. A team running 30 counterparty risk scores per week at $0.25 each spends $7.50/week. A security analyst running daily vendor risk scores plus weekly attack surface maps spends roughly $15-30/month. Apify's free plan ships with $5/month of platform credits for testing.

Are these MCPs as accurate as ComplyAdvantage or Capital IQ?

For public-data coverage, they hit the same authoritative sources (OFAC, OpenSanctions, SEC, USPTO, GLEIF). For proprietary adverse media, private credit data, and curated KYB packages, commercial platforms win — they own datasets these MCPs can't access. For SME compliance teams and corp-dev analysts who don't need the proprietary tier, the public-data coverage is usually enough.

What happens if a sub-actor fails inside a composite tool?

The composite tools use tryActor (or equivalent) which catches failures, records the source name and error in an errors map, and returns an empty array for that source. The composite still scores with what it got. The response includes a dataSources object showing which sources returned data — a count of 0 on a source that should have data signals a transient failure worth retrying.

Why use mcp.apify.com instead of the direct standby URL?

Both work. https://mcp.apify.com?tools=ryanclinton/<slug> is what Apify documents and recommends — it adds OAuth support, a built-in tool picker UI, and dynamic tool discovery. The direct URL https://<slug>.apify.actor/mcp skips the bridge for ~10ms less latency. I default to the bridge form because that's the documented integration path.

Do these MCPs expose any sensitive data?

They query only public data sources (government registries, sanctions lists, SEC filings, public review platforms, certificate transparency logs, public WHOIS). No private API keys, no proprietary databases, no scraped private user data. Compliance with GDPR and applicable data protection laws is the user's responsibility when storing personal data returned from officer records.

Can I run these MCPs against my own Apify token without sharing run data?

Yes. Each tool call runs under your token, in your account, billed to your balance. Run data is private to your account by default. If you want to share runs with the actor author for debugging, you can opt in via Account Settings → Privacy → "Share runs with public Actor creators".

Ryan Clinton operates 105 MCP servers and 331 actors on Apify under the ryanclinton namespace. He maintains ApifyForge, a directory and comparison platform for production Apify actors and MCP servers.

Last updated: April 2026. This guide focuses on Claude Desktop, but the same configuration patterns apply broadly to any MCP-compatible AI client — Cursor, Cline, Windsurf, and custom agents built on @modelcontextprotocol/sdk.