Systemic Risk Contagion MCP

Systemic risk contagion analysis for financial networks, delivered as an MCP server your AI agent connects to directly. This server orchestrates 16 data sources spanning corporate registries, SEC filings, FDIC bank data, macroeconomic indicators, market prices, cryptocurrency, and sanctions lists to construct 4-layer multiplex financial networks and run rigorous quantitative analysis. It identifies globally and domestically systemically important banks (G-SIBs and D-SIBs), simulates cascade failures, detects stress clustering, and generates full financial stability reports — all from a single natural-language query.

The server implements four published mathematical frameworks: DebtRank (Battiston et al. 2012), Eisenberg-Noe clearing vectors (2001), multivariate Hawkes self-exciting processes, and supra-adjacency tensor spectral decomposition. Each query triggers 16 Apify actors running in parallel, assembles a multiplex network with inter-layer coupling tensors, and applies the selected algorithm. Use it from Claude Desktop, Cursor, Windsurf, or any MCP-compatible client.

⬇️ What data can you access?

❓ Why use the Systemic Risk Contagion MCP Server?

Building a systemic risk model manually requires subscribing to Bloomberg Terminal ($24,000/year), hiring a quant analyst to write network code, and licensing exposure data that central banks spend years assembling. Even then, most practitioners use only a single data layer — credit exposures alone — missing the cross-layer amplification dynamics that caused the 2008 cascade.

This server assembles all 16 publicly available data sources, constructs a 6-layer multiplex network including ownership, financial exposure, market correlation, supply chain, sanctions, and political layers, and applies the exact algorithms used in academic systemic risk literature. For $0.045 per tool call.

Platform benefits:

• Always-on standby — the server runs persistently via Apify's standby mode, responding to MCP requests in seconds without cold-start delays
• API access — connect from Claude Desktop, Cursor, Windsurf, Cline, or any HTTP client using the /mcp endpoint
• Spend controls — set a maximum spend per session so a runaway agent cannot exceed your budget
• Scheduled analysis — use Apify Scheduler to run recurring stability monitoring and track regime changes over time
• Webhooks — trigger downstream alerts when branching ratios or spectral radii exceed defined thresholds

MCP Tools

Use cases for systemic risk contagion analysis

G-SIB and D-SIB identification

Prudential regulators, financial stability boards, and risk managers at large banks need to quantify systemic importance. Run compute_debtrank against a sector like "US banking sector" or a specific institution like "JPMorgan Chase counterparty network" to rank entities by their DebtRank score — the fraction of total economic value affected by their individual distress. The output classifies each entity as G-SIB, D-SIB, or non-systemic based on threshold analysis, giving you a rigorous ranking without requiring proprietary bilateral exposure data.

Stress testing and resolution planning

Resolution planners and risk officers need to know how an initial shock amplifies. Run simulate_cascade_failure to apply the Eisenberg-Noe clearing payment framework: each node pays the minimum of its obligations and available assets, the shortfall propagates to creditors, and the algorithm iterates to the fixed-point clearing vector. The output shows defaults per round, cumulative loss, cascade depth, and convergence iterations — exactly the format needed for regulatory stress test documentation.

Criticality regime assessment

Central bank researchers and macro-prudential supervisors need to know whether the current system configuration is in subcritical, critical, or supercritical regime. identify_critical_nodes builds the NL x NL supra-adjacency matrix (intra-layer blocks plus inter-layer coupling tensors), computes its largest eigenvalue via power iteration, and classifies the regime. Supercritical means cross-layer cascades amplify rather than dampen — the signal that regulatory intervention is warranted.

Temporal stress event monitoring

Risk surveillance teams tracking early-warning indicators use detect_stress_clustering to run the multivariate Hawkes process EM estimation. The branching ratio (spectral radius of alpha/beta) is the key output: values approaching 1 indicate the system is becoming self-exciting, where each stress event triggers additional events. This provides a lead indicator of instability before defaults materialize.

Sanctions compliance stress testing

Compliance officers at banks with exposure to potentially sanctioned jurisdictions or entities use model_sanctions_shock to estimate contagion before new sanctions are imposed. The model severs network connections for sanctioned entities, propagates stress through BFS with a 60% loss-given-default assumption, and triggers further propagation when any node's loss exceeds 10% of equity. Output includes direct vs indirect impact and propagation depth per entity.

Cross-layer contagion channel mapping

Quantitative researchers and systemic risk academics use compute_contagion_channels to understand the mechanism of contagion, not just its severity. Supra-adjacency tensor decomposition identifies which layer-to-layer pathways carry the most amplification — for example, whether ownership-to-financial_exposure coupling or market_correlation-to-supply_chain coupling is the dominant transmission channel. The cross-layer amplification ratio shows how much worse multiplex contagion is than any single-layer model would predict.

How to connect this MCP server

Step 1: Get your Apify API token

Sign up at apify.com and find your token at Settings > Integrations > API token. The Apify Free plan includes $5 of monthly credits.

Step 2: Add to your MCP client

Claude Desktop — add to claude_desktop_config.json:

{
  "mcpServers": {
    "systemic-risk-contagion": {
      "url": "https://systemic-risk-contagion-mcp.apify.actor/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_APIFY_TOKEN"
      }
    }
  }
}

Cursor / Windsurf / Cline — add the same URL in your MCP server settings panel. The endpoint is https://systemic-risk-contagion-mcp.apify.actor/mcp.

Step 3: Run your first analysis

Ask your AI assistant:

"Use the systemic risk MCP to compute DebtRank for the US banking sector and identify the top G-SIBs."

"Run a cascade failure simulation for Goldman Sachs counterparty network and show me the default rounds."

"Generate a full stability report for the European banking sector."

Step 4: Interpret the results

Each tool returns structured JSON with the algorithmic output, network statistics, and interpretation signals. The generate_stability_report tool includes explicit threshold-breach flags and written recommendations.

Input parameters

This is an MCP server. It has no Apify actor input schema — configuration is entirely through your MCP client. Each tool accepts a single parameter:

All 16 data sources are queried using this string. More specific queries produce more focused network construction.

Query examples

Sector-level systemic risk:

"US banking sector 2024"

Single institution counterparty analysis:

"JPMorgan Chase counterparty network"

Geographic cross-border contagion:

"European banking systemic risk"

Asset class specific:

"crypto exchange systemic risk contagion"

Sanctions impact modeling:

"Russian banking sector OFAC sanctions impact"

Input tips

• Specific entity names produce denser networks — "Citibank" fetches more targeted FDIC and EDGAR data than "banking".
• Sector queries reveal macro-level structure — "US insurance sector" captures cross-entity correlation and supply chain layers better than single-institution queries.
• Add geographic context for cross-border analysis — "European sovereign debt" triggers stronger IMF and World Bank data retrieval.
• Use generate_stability_report for initial exploration — it runs all algorithms in one call, giving you the full picture before drilling into specific tools.
• Chain tools sequentially for deep analysis — start with build_systemic_network to understand network structure, then compute_debtrank for ranking, then simulate_cascade_failure for scenario stress testing.

⬆️ Output example

compute_debtrank — US banking sector:

{
  "query": "US banking sector",
  "networkSize": 147,
  "rankings": [
    {
      "entity": "FirstNational Bancorp",
      "debtRank": 0.312,
      "relativeImpact": 0.418,
      "tier": "G-SIB"
    },
    {
      "entity": "Meridian Trust Bank",
      "debtRank": 0.187,
      "relativeImpact": 0.251,
      "tier": "G-SIB"
    },
    {
      "entity": "Pinnacle Capital Group",
      "debtRank": 0.094,
      "relativeImpact": 0.127,
      "tier": "D-SIB"
    },
    {
      "entity": "Coastal Community Bank",
      "debtRank": 0.021,
      "relativeImpact": 0.028,
      "tier": "non-systemic"
    }
  ],
  "systemicLoss": 0.743,
  "averageDebtRank": 0.048,
  "gSibCount": 6
}

generate_stability_report — European banking sector:

{
  "query": "European banking systemic risk",
  "networkSize": 203,
  "edgeCount": 1847,
  "metrics": [
    { "metric": "network_density", "value": 0.089, "threshold": 0.05, "breached": true },
    { "metric": "average_leverage", "value": 18.4, "threshold": 15.0, "breached": true },
    { "metric": "asset_concentration_hhi", "value": 0.241, "threshold": 0.25, "breached": false },
    { "metric": "cross_border_exposure", "value": 0.63, "threshold": 0.50, "breached": true },
    { "metric": "crypto_exposure_ratio", "value": 0.031, "threshold": 0.10, "breached": false },
    { "metric": "hawkes_branching_ratio", "value": 0.71, "threshold": 0.80, "breached": false },
    { "metric": "supra_spectral_radius", "value": 1.14, "threshold": 1.00, "breached": true }
  ],
  "overallRisk": "elevated",
  "riskScore": 68,
  "debtRankSummary": {
    "systemicLoss": 0.812,
    "gSibCount": 8,
    "averageDebtRank": 0.062
  },
  "cascadeSummary": {
    "totalDefaults": 12,
    "totalLoss": 0.341,
    "cascadeDepth": 4
  },
  "hawkesSummary": {
    "branchingRatio": 0.71,
    "criticalityIndicator": "moderate — stress events clustering but below critical threshold"
  },
  "spectralSummary": {
    "spectralRadius": 1.14,
    "regime": "supercritical — cross-layer cascades amplify"
  },
  "recommendations": [
    "Spectral radius exceeds 1.0: system is in supercritical regime. Cross-layer cascade amplification is active.",
    "Network density and leverage breach thresholds simultaneously — heightened contagion probability.",
    "Cross-border exposure at 63% suggests significant foreign contagion transmission pathways.",
    "Monitor Hawkes branching ratio — currently 0.71 but trending toward critical threshold of 0.80."
  ],
  "dataSources": {
    "corporates": 58,
    "leis": 37,
    "filings": 54,
    "banks": 61,
    "stocks": 39,
    "crypto": 28,
    "sanctions": 42,
    "totalActors": 16
  }
}

Output fields

How much does it cost to run systemic risk contagion analysis?

Each tool call costs $0.045. Platform compute costs are included. All 16 actors run in parallel per call, so the cost per data point is exceptionally low for the volume processed.

The Apify Free plan includes $5 of monthly credits — enough for 111 tool calls per month at no cost.

Compare this to Bloomberg Terminal at $24,000/year or a dedicated quant infrastructure build at $50,000+ in engineering time. With this server, a monthly budget of $10–20 covers comprehensive ongoing monitoring.

You can set a maximum spending limit per MCP session using Apify's spend controls. The server stops and returns an error when your budget is reached, preventing runaway agent costs.

How the Systemic Risk Contagion MCP works

Phase 1: Parallel data collection across 16 sources

Each tool call triggers 16 Apify actors via Promise.all() — all running simultaneously with individual 120-second timeouts. Actors are grouped by domain: corporate registries (OpenCorporates, GLEIF), financial regulators (EDGAR, SEC, FDIC, CFPB), market data (Finnhub, CoinGecko, Exchange Rates, Congress Stock), macroeconomic indicators (FRED, BLS, IMF, World Bank), and sanctions (OFAC). Failed actors return empty arrays and are gracefully excluded from network construction rather than causing the entire call to fail.

Phase 2: Multiplex network construction

buildMultiplexNetwork() ingests all 16 data streams and constructs typed FinancialNode objects for 8 entity types: bank, insurer, fund, corporation, sovereign, exchange, crypto, and indicator. FDIC bank records become bank nodes with assets, liabilities, equity, and leverage fields. OpenCorporates records become corporation nodes with sector and jurisdiction. IMF records become sovereign nodes. FRED series become indicator nodes (capped at 20 to control network size).

The function then builds four N×N adjacency matrices: ownership (from GLEIF parent-child LEI relationships and corporate registry structures), financial_exposure (from SEC filing exposure data and FDIC interbank indicators), market_correlation (from stock return co-movement, crypto prices, and FX co-movement), and supply_chain (inferred from sector co-occurrence). A third-order inter-layer coupling tensor C[l1][l2][i] captures how each node's connections correlate across layer pairs — the mechanism through which multiplex amplification occurs.

Phase 3: Algorithm execution

DebtRank (computeDebtRank): Each node is individually shocked to distress level 1.0. Stress propagates iteratively through the financial_exposure layer weight matrix W[i][j] = exposure[i][j] / equity[j]. Each iteration: h[j] = min(1, h[j] + Σ_i W[i][j] * h[i]), stopping when no node's stress changes by more than 0.001. DebtRank for node k = Σ_j (h_j^final - h_j^initial), normalized by total system equity. Nodes with DebtRank > 0.10 are classified G-SIB; > 0.05 D-SIB.

Eisenberg-Noe clearing (simulateCascadeFailure): The Fictitious Default Algorithm computes the fixed-point clearing vector. Each iteration sets p[i] = min(p_bar[i], assets[i] + Σ_j (L[j][i]/p_bar[j]) * p[j]) where p_bar[i] is total obligations and L is the liability matrix. The algorithm iterates until convergence (typically < 20 iterations). The cascade simulation then applies an initial shock (20% asset loss to the highest-exposure node) and propagates defaults in BFS rounds.

Supra-adjacency spectral analysis (identifyCriticalNodes): Builds the NL×NL supra-adjacency matrix with intra-layer blocks on the diagonal and inter-layer coupling matrices on off-diagonal blocks. Power iteration computes the largest eigenvalue. If this exceeds 1.0, the system is supercritical — perturbations grow rather than decay. Eigenvector centrality identifies the nodes most responsible for the supercritical regime.

Multivariate Hawkes EM (detectStressClustering): Estimates λ_i(t) = μ_i + Σ_j α_ij Σ_{t_k<t} β*exp(-β*(t-t_k)) via 10 EM iterations. E-step computes event responsibilities; M-step updates μ, α, and β. The branching ratio is ρ = spectral_radius(α/β) — the key criticality indicator. Nodes with correlated stress histories are grouped into clusters via threshold-based adjacency.

Supra-adjacency tensor decomposition (computeContagionChannels): Evaluates all ordered layer pairs as contagion channels. Channel strength is proportional to the inter-layer coupling magnitude and the product of each layer's spectral radius. The CP tensor rank estimates the minimum number of rank-1 components needed to represent the full cross-layer transmission structure — a measure of contagion pathway complexity.

Tips for best results

1. Start with generate_stability_report before drilling into individual tools. It runs all algorithms in one $0.045 call and gives you the full picture — regime classification, DebtRank summary, cascade depth, Hawkes branching ratio, and written recommendations — so you know which specific tools to run next.

2. Use institution names for exposure mapping, sector terms for systemic structure. "Bank of America interbank lending" produces a denser financial_exposure layer. "US commercial banking sector" produces a broader market_correlation layer with more nodes, better for sector-level criticality analysis.

3. Track branching ratio trends over time. The Hawkes branching ratio is the most sensitive early-warning indicator. Schedule weekly detect_stress_clustering runs and alert when the ratio moves above 0.70 (elevated) or 0.85 (critical warning zone).

4. Interpret spectral radius relative to 1.0, not in absolute terms. A spectral radius of 1.05 is more dangerous than 0.95, not because the difference is large, but because 1.0 is the phase transition point between subcritical damping and supercritical amplification.

5. Combine sanctions and cascade tools for compliance stress testing. Run model_sanctions_shock first to identify which entities propagate the most indirect impact, then run simulate_cascade_failure with those entities as the initial shock source to model worst-case cascade scenarios.

6. Set Apify spend limits to prevent agent cost overruns. An AI agent running in a loop could call all 8 tools multiple times. Set a session spend limit of $2–5 for exploratory analysis and $10–20 for comprehensive monitoring workflows.

7. Cross-reference identify_critical_nodes output with compute_debtrank. High DebtRank entities cause large losses when distressed; high spectral importance entities are structural bottlenecks. Entities appearing in both lists are the highest-priority systemic concerns.

Combine with other Apify MCP servers

Limitations

• No private bilateral exposure data. The financial_exposure layer is constructed from public SEC filings, FDIC call reports, and EDGAR data. Actual bilateral derivative and repo exposure data held on bank balance sheets is not publicly available. Results should be treated as scenario analysis, not precise exposure measurement.
• Network construction is query-dependent. The 16 actors all use your query string for search. A specific institution query produces a denser, more focused network. A vague query produces a sparser network with lower analytical confidence.
• 16-actor parallel execution takes 60–120 seconds. Each tool call waits for all 16 data sources with a 120-second per-actor timeout. Total wall-clock time is bounded by the slowest actor. Budget 2–3 minutes per tool call.
• Hawkes process estimates require sufficient event history. The EM estimation needs enough stress events in the network to produce reliable branching ratio estimates. Very sparse networks (fewer than 20 nodes) will produce lower-confidence Hawkes parameters.
• Cryptocurrency exposure is limited to CoinGecko public data. DeFi protocol interconnections and on-chain exposure data are not captured. Crypto layer reflects market price co-movement only, not smart contract counterparty risk.
• Political shock layer relies on STOCK Act disclosures. Congressional trading data provides a directional signal for sector political risk, but the methodology is necessarily inferential — significant trading volume in a sector correlates with regulatory or policy risk.
• OFAC sanctions data reflects the current list. Historical sanctions exposure (entities that have since been delisted) is not captured. For historical analysis, supplement with archived OFAC data.
• The server does not provide investment advice. All outputs are quantitative risk model results derived from public data. They do not constitute financial advice, regulatory guidance, or official systemic risk assessments.

Integrations

• Apify API — trigger systemic risk analysis programmatically from Python, JavaScript, or any HTTP client for automated monitoring pipelines
• Webhooks — fire alerts to Slack, PagerDuty, or custom endpoints when stability report risk scores breach defined thresholds
• Apify Scheduler — schedule weekly or daily stability report runs to track Hawkes branching ratio and spectral radius trends over time
• LangChain / LlamaIndex — embed systemic risk tools in agentic financial analysis workflows using the MCP protocol
• Claude Desktop — connect directly via the MCP server URL for interactive systemic risk Q&A and scenario analysis

Troubleshooting

Tool returns empty or very small network (fewer than 10 nodes). This usually means the query string did not match records in the major data sources. Try a more general query — "US banking" instead of a specific ticker, or add "sector" to the query. Check the dataSources object in the output to see which actors returned zero results.

Cascade simulation shows zero defaults. The Eisenberg-Noe cascade requires nodes with non-trivial leverage (liabilities > equity) for the cascade to propagate. If the network consists mostly of indicator and sovereign nodes with no bank nodes, defaults cannot occur. Use a query that retrieves FDIC bank data — include "bank" or "banking" in the query string to trigger FDIC actor results.

Hawkes branching ratio is exactly 0.0 or 1.0. These edge values indicate degenerate EM convergence, which occurs when the network has fewer than 5 nodes or all nodes are of the same type. The EM algorithm requires sufficient network diversity to estimate meaningful alpha/beta parameters. Broaden your query.

Supra-adjacency spectral analysis reports "subcritical" for a query that should be high risk. The spectral radius depends on network density. A query that retrieves few nodes or sparse connectivity will produce a low spectral radius regardless of the underlying sector's actual risk level. Run build_systemic_network first and check that edgeCount is at least 50 before interpreting regime classification.

Spend limit reached error. The server returns {"error": true, "message": "Spending limit reached for [event]"} when your Apify account's spend limit is hit. Increase your limit in Apify Console > Billing > Spend Limits, or use the generate_stability_report tool (one call, all algorithms) rather than calling each tool individually.

Responsible use

• This server accesses only publicly available government databases, regulatory filings, and open market data.
• All 16 underlying data sources are public: SEC EDGAR, FDIC call reports, OFAC, CFPB, FRED, BLS, IMF, World Bank, and open market data APIs.
• The outputs are quantitative risk model results intended for research, risk management, and regulatory analysis purposes only.
• Do not use the outputs as investment advice, trading signals, or official regulatory determinations.
• For guidance on web scraping legality, see Apify's guide.

❓ FAQ

How many data sources does this MCP query per tool call? Every tool call queries all 16 data sources simultaneously via parallel execution. The sources span 5 categories: corporate registries (OpenCorporates, GLEIF), financial regulators (EDGAR, SEC, FDIC, CFPB), market data (Finnhub, CoinGecko, Exchange Rates, Congress Stock), macroeconomic indicators (FRED, BLS, IMF, World Bank), and sanctions (OFAC). All 16 actors run with a 120-second individual timeout.

How does systemic risk contagion analysis work technically? The server builds a 6-layer multiplex network (ownership, financial_exposure, market_correlation, supply_chain, sanctions, political) with an inter-layer coupling tensor. It then applies published algorithms: DebtRank for systemic importance ranking, Eisenberg-Noe clearing for cascade simulation, supra-adjacency spectral analysis for criticality regime detection, and multivariate Hawkes EM for temporal stress clustering. Each algorithm operates on the same network, allowing consistent cross-algorithm comparison.

What is DebtRank and how is it different from simple network centrality? DebtRank (Battiston et al. 2012) measures the fraction of total economic value that would be affected by a given entity's distress, propagated through liability-weighted connections. Unlike betweenness centrality, it accounts for the magnitude of financial exposures, not just network topology. An entity with a DebtRank of 0.30 means 30% of total system equity is exposed to its distress through direct and indirect counterparty channels.

What is the Eisenberg-Noe clearing vector? The Eisenberg-Noe (2001) model computes the payment each institution makes when some institutions cannot meet all their obligations. Each institution pays min(total_obligations, available_assets). The Fictitious Default Algorithm finds the fixed-point clearing vector iteratively, converging in typically 5–20 rounds. This is the standard framework used in central bank stress testing exercises.

What does a supercritical supra-adjacency spectral radius mean? The supra-adjacency matrix captures both within-layer and cross-layer connections simultaneously. Its largest eigenvalue determines whether perturbations grow (spectral radius > 1.0, supercritical) or decay (< 1.0, subcritical). When the system is supercritical, an initial shock in one layer amplifies as it crosses to other layers — for example, a market correlation shock triggering ownership-layer distress that then amplifies through financial exposure. This is the multiplex amplification effect absent from single-layer models.

How accurate are the cascade simulations? The DebtRank and Eisenberg-Noe frameworks are mathematically rigorous implementations of published models. Accuracy depends on the completeness of public exposure data — SEC filings, FDIC call reports, and GLEIF LEI records provide good coverage of US and EU financial institutions, but private bilateral derivative and repo exposures are not publicly available. Results are best interpreted as relative risk rankings and scenario stress tests rather than precise loss forecasts.

What is the Hawkes branching ratio and when should I be concerned? The branching ratio ρ = spectral_radius(α/β) from the Hawkes process measures self-excitation intensity. A branching ratio of 0 means stress events are independent; a ratio approaching 1 means the process is near-critical — each stress event triggers additional events, creating self-reinforcing instability. Values above 0.70 warrant monitoring; values above 0.85 indicate elevated systemic concern; values approaching 1.0 indicate near-critical conditions.

How is this different from Bloomberg or other professional financial data terminals? Bloomberg Terminal provides raw data and basic analytics for individual institutions. This server specifically implements systemic contagion algorithms — network-level analysis that no terminal provides out of the box. It also integrates data from 16 sources automatically, whereas Bloomberg requires manual multi-source data assembly. The cost difference is also significant: Bloomberg Terminal costs approximately $24,000/year; this server costs $0.045 per analysis.

Can I use this MCP for sovereign debt and cross-border contagion analysis? This server includes IMF and World Bank data in the network, creating sovereign nodes and cross-border exposure signals. For dedicated sovereign fiscal stress modeling with bond spread analysis and sovereign CDS data, combine this server with the Sovereign Debt Contagion MCP, which models the bank-sovereign feedback loop explicitly.

Is it legal to use publicly available financial data for systemic risk analysis? All 16 data sources are public government databases and open market data. SEC EDGAR, FDIC call reports, OFAC sanctions lists, FRED, BLS, IMF, and World Bank data are all publicly mandated disclosures or freely available official datasets. Using them for risk analysis is lawful. See Apify's guide on web scraping legality for more detail.

Can I schedule recurring systemic risk monitoring? Yes. Use Apify Scheduler to run generate_stability_report on a weekly or daily cadence for your target sector or institution. Combine with Apify Webhooks to fire an alert when overallRisk changes category or when the Hawkes branching ratio exceeds a threshold. This creates an automated early-warning monitoring workflow without any custom infrastructure.

How long does a typical systemic risk analysis take? Each tool call runs 16 actors in parallel, then executes the scoring algorithm. Total wall-clock time is typically 60–120 seconds, bounded by the slowest of the 16 actors. The generate_stability_report tool is not significantly slower than individual tools because all 16 actors run in parallel regardless of which tool is called.

Help us improve

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

1. Go to Account Settings > Privacy
2. 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 or enterprise integrations — including private deployment, custom data source integration, or bespoke contagion model configuration — reach out through the Apify platform.