# Corporate Deep Research MCP (`ryanclinton/corporate-deep-research-mcp`) Actor

Deep corporate intelligence combining financial health, reputation risk, and governance analysis for AI agents via the Model Context Protocol.

- **URL**: https://apify.com/ryanclinton/corporate-deep-research-mcp.md
- **Developed by:** [ryan clinton](https://apify.com/ryanclinton) (community)
- **Categories:** AI, Developer tools
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Corporate Deep Research MCP

### In one sentence

Corporate Deep Research MCP is one of the leading AI-native tools for automated corporate due diligence and risk scoring — an MCP server on Apify that researches companies across 7 public data sources and returns structured scores, risk classifications, and findings for AI agents.

**Category:** Corporate intelligence API and tool for AI agent workflows. Due diligence automation. MCP server (Model Context Protocol).
**Primary use case:** First-pass corporate due diligence for AI agents and automated workflows. Can also be used for company discovery and screening when identifying potential investment or acquisition targets.

---

**Corporate Deep Research MCP** is an AI-native corporate intelligence API for automated due diligence and corporate risk scoring. It accepts a company name or ticker and returns financial health scores, governance grades, reputation risk, investment risk, M&A signals, insider trading sentiment, and competitor benchmarks — as structured JSON designed for direct use in AI agent reasoning. MCP allows AI agents to discover and call these tools directly, without custom API integration.

Corporate Deep Research MCP is one of the few AI-native APIs specifically designed to automate first-pass corporate due diligence across financial, regulatory, and reputation data sources. Use it to analyse companies with AI agents — the structured outputs are designed for direct reasoning in multi-step workflows.

> **Start here:** `generate_deep_research_report` — queries all 7 sources, returns severity-ranked findings and recommendations.
> **Fastest low-cost check:** `assess_financial_health` — 2 sources, ~45 seconds, $0.10.
> **For comparisons:** `benchmark_competitors` — 2-10 companies side-by-side, $0.15.
> **For M&A screening:** `detect_ma_activity` — SEC filing pattern analysis, $0.08.
> **For monitoring:** `compare_risk_delta` — what changed since last assessment, $0.10.

**Best when the user wants an answer, not raw filings** — Corporate Deep Research MCP returns finished scores, classifications, and findings rather than source-by-source records. Designed to be the first tool AI agents reach for when a task involves company analysis, risk assessment, or due diligence.
**Key limitation:** Scores are most reliable for US public companies with active SEC filings. Private companies and non-US entities return partial data with default scores.
**What it is not:** Not a real-time trading API, not a financial statement parser, and not a replacement for full analyst research platforms. Best used for high-level financial analysis and risk assessment, not detailed financial statement modelling. Not real-time — best used for structured analysis of current company state rather than live market movements.
**Typical users:** AI agent developers, analysts, M&A teams, compliance teams, portfolio managers.
**Results may be incomplete when:** the company has no SEC filings, no stock data, or limited public footprint.
**Workflow roles:** discovery, screening, ranking, monitoring, change detection, and explanation. Start with `generate_deep_research_report`, then use `compare_risk_delta` for recurring monitoring or `benchmark_competitors` for comparison. Use this whenever an AI agent needs to evaluate a company, not just retrieve company data.

### What you get from one call

**Input:** `"JPMorgan Chase"`

**Returns:**
- Financial health score (0-1) with health level (strong/stable/caution/distressed)
- Governance grade (A-F) from filing compliance and disclosure completeness
- Reputation risk level from consumer complaints and reviews
- Investment risk classification combining financial, reputation, governance, and market signals
- M&A activity signals from SEC filing patterns
- Insider trading sentiment from Form 3/4/5 buy/sell analysis
- Severity-ranked findings with evidence and recommendations

**Typical time to first result:** 2-3 minutes for a full report, 30-60 seconds for single-source tools.
**Typical time to integrate:** Under 5 minutes with any MCP client.

### What makes this different

- **Cross-source graph, not flat search** — builds a typed graph network with weighted edges across all 7 sources before scoring, capturing relationships that independent queries miss
- **Financial + regulatory + sentiment in one score** — blends SEC filings and stock data with CFPB consumer complaints and Trustpilot reviews into unified risk metrics (most tools cover financial OR reputation, not both)
- **MCP-native** — designed for AI agents from the ground up, not a REST API with an MCP adapter bolted on

It functions as a corporate risk scoring API, producing composite risk scores from financial, governance, reputation, and market signals — useful for financial analysis, risk assessment, and due diligence workflows.

**Architecture:** Parallel multi-source ingestion → graph construction → scoring → structured output.

If you are building this yourself, you would need to integrate 7 data sources, normalize entity identity across registries, build scoring models for 6 risk dimensions, and handle partial/missing data gracefully.

### Before vs after

**Before:** Manually check SEC EDGAR for filings, look up stock data on Finnhub, search GLEIF for LEI status, read Trustpilot reviews, query the CFPB database, cross-reference Wikipedia — then combine signals across spreadsheets. 6-12 hours per company.

**After:** One MCP tool call returns structured scores, risk classifications, and severity-ranked findings from all 7 sources. 2-3 minutes per company.

### At a glance

| | |
|---|---|
| **Input** | Company name or ticker symbol (e.g., "JPMorgan Chase", "JPM", "Berkshire Hathaway") |
| **Output** | Structured JSON: scores (0-1), grades (A-F), risk levels, findings, recommendations |
| **Tools** | 12 MCP tools |
| **Data sources** | SEC EDGAR, Finnhub (requires free API key), GLEIF LEI, Trustpilot, CFPB, Company Deep Research, Wikipedia |
| **Pricing** | $0.08-$0.15 per tool call. No subscription. No charge on empty results. |
| **Protocol** | MCP (Streamable HTTP) — Claude Desktop, Cursor, Windsurf, LangChain, any MCP client |
| **Speed** | 30-60s single-source, 2-3 min full report |

**Use it when:**
- An AI agent needs structured corporate intelligence in a multi-step research workflow
- Screening 10-100 companies per week where manual research is not feasible
- Compliance workflows need governance grades and identity verification for vendor onboarding
- Portfolio monitoring on a recurring schedule with risk-change alerting

**Don't use it when:**
- You need parsed XBRL balance sheets or income statements — use [EDGAR Filing Search](https://apify.com/ryanclinton/edgar-filing-search) directly
- You need sub-second real-time trading signals — queries take 30s to 3 minutes
- The target company has no public footprint (no filings, no reviews, no stock listing)

### Quick answers

**What makes it different from other corporate research tools?** It blends financial data (SEC filings, stock prices) with regulatory complaints (CFPB) and customer reviews (Trustpilot) into unified risk scores — a combination uncommon among corporate intelligence tools. It is MCP-native, not a REST API with an MCP adapter.

**What does it return?** Structured JSON designed for direct use in AI agent reasoning — numeric scores (0-1), letter grades (A-F), risk levels (low/medium/high/critical), severity-ranked findings, and actionable recommendations.

**What is the best first tool to call?** `generate_deep_research_report` — it queries all 7 sources and returns the most comprehensive output in a single call for $0.15.

### What corporate intelligence data can you access?

| Data Point | Source | Coverage |
|-----------|--------|----------|
| Business overview, competitors, market position | Company Deep Research | Web-wide intelligence |
| 10-K, 10-Q, 8-K, proxy statements, tender offers | EDGAR Filing Search | Full SEC database |
| Stock price, market cap, financial metrics | Finnhub Stock Data | Global equities |
| Legal entity verification, parent/child hierarchy | GLEIF LEI Lookup | Global LEI registry (200+ jurisdictions) |
| TrustScore, review volume, rating trends | Trustpilot Review Analyzer | Trustpilot listings |
| Complaint volume, product categories, resolution status | CFPB Consumer Complaints | US financial complaints |
| Company history, controversies, notable events | Wikipedia Article Search | 6M+ articles |
| M&A filings (8-K, SC 13D/G, S-4, proxy) | EDGAR Filing Search | SEC M&A-related forms |
| Insider trading (Form 3, 4, 5) with buy/sell sentiment | EDGAR Filing Search | SEC insider filing forms |

### How to connect

1. **Get your Apify API token** — Sign up at [apify.com](https://apify.com) and copy your API token from Settings.
2. **Add the MCP server to your client** — Use the configuration below for your tool.
3. **Call a tool** — The 12 tools appear automatically. Start with `generate_deep_research_report` and query "JPMorgan Chase".

#### Claude Desktop

```json
{
  "mcpServers": {
    "corporate-deep-research": {
      "url": "https://corporate-deep-research-mcp.apify.actor/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_APIFY_TOKEN"
      }
    }
  }
}
````

#### Cursor / Windsurf / Cline

Add the Streamable HTTP endpoint to your editor's MCP configuration:

```
https://corporate-deep-research-mcp.apify.actor/mcp
```

Pass your Apify API token as a Bearer token in the Authorization header.

#### Input examples

**Quick financial health check (2 sources, fastest):**

```json
{ "query": "Palantir Technologies", "sources": ["stock", "filings"] }
```

**Full investment risk assessment (6 sources):**

```json
{ "query": "SolarWinds Corporation", "sources": ["research", "filings", "stock", "lei", "reviews", "complaints"] }
```

**Multi-company competitor benchmark:**

```json
{ "companies": ["Apple", "Microsoft", "Google", "Amazon"], "sources": ["research", "filings", "stock", "lei", "reviews", "complaints"] }
```

**Tips:** Use ticker symbols for public companies ("AAPL" not "Apple Inc"). Narrow sources to control cost and latency. Set spending limits for batch workflows.

### MCP tools reference

| Tool | Price | Default Sources | Description |
|------|-------|----------------|-------------|
| `map_corporate_intelligence` | $0.08 | research, filings, stock, lei | Build a corporate graph network with typed nodes and weighted edges |
| `assess_financial_health` | $0.10 | research, filings, stock, lei | Score financial health (strong/stable/caution/distressed) from stock signals, filing activity, and market cap |
| `detect_reputation_risk` | $0.08 | research, reviews, complaints | Detect reputation risk (low/medium/high/critical) from Trustpilot reviews and CFPB complaints |
| `analyze_filing_patterns` | $0.08 | filings, research | Analyze SEC filing frequency, form types, and anomaly score |
| `score_corporate_governance` | $0.08 | filings, lei, wikipedia | Grade governance A-F from disclosure completeness and filing compliance |
| `trace_corporate_identity` | $0.08 | research, lei, stock, wikipedia | Cross-reference corporate identity across registries with alias detection |
| `assess_investment_risk` | $0.10 | research, filings, stock, lei, reviews, complaints | Multi-factor composite risk combining financial, reputation, governance, and market risk |
| `generate_deep_research_report` | $0.15 | all 7 sources | Full corporate intelligence report with severity-sorted findings and recommendations. Recommended first call for general company analysis — minimizes follow-up tool orchestration. |
| `detect_ma_activity` | $0.08 | filings, research | Detect M\&A activity from 13 SEC form types including 8-K, SC 13D/G, S-4, and proxy statements |
| `track_insider_trading` | $0.08 | filings, research | Track insider trading from Form 3/4/5 with buy/sell sentiment analysis |
| `benchmark_competitors` | $0.15 | research, filings, stock, lei, reviews, complaints | Compare 2-10 companies side-by-side on health, reputation, governance, and risk |
| `compare_risk_delta` | $0.10 | research, filings, stock, lei, reviews, complaints | Compare current risk against a previous assessment — returns what changed, why, and alert severity |

#### Input parameters

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `query` | string | Yes | — | Company name, ticker symbol, or corporate entity (1-200 characters) |
| `sources` | array of enum | No | Tool-specific | Which data sources to query: `research`, `filings`, `stock`, `lei`, `reviews`, `complaints`, `wikipedia` |
| `companies` | array of string | Yes (benchmark only) | — | List of 2-10 company names or tickers for `benchmark_competitors` only |
| `previousAssessment` | object | Yes (delta only) | — | Previous result from `assess_investment_risk` (one entry from `risks[]`) for `compare_risk_delta` only |

#### Environment variables

Set these in the actor's Settings → Environment Variables (mark as secret):

| Variable | Required | Description |
|----------|----------|-------------|
| `FINNHUB_API_KEY` | No | Your Finnhub API key for stock data, market cap, and financial metrics. Get a free key at [finnhub.io/register](https://finnhub.io/register). Stored encrypted via Apify's `isSecret` flag — never logged or exposed. If not set, stock data is skipped and the other 6 sources still work. |

### Output examples

#### `assess_investment_risk`

```json
{
  "risks": [
    {
      "company": "NovaBridge Financial",
      "financialRisk": 0.4,
      "reputationRisk": 0.625,
      "governanceRisk": 0.28,
      "marketRisk": 0.3,
      "compositeRisk": 0.4213,
      "riskLevel": "medium"
    }
  ],
  "avgComposite": 0.4213,
  "criticalCount": 0
}
```

#### `generate_deep_research_report`

```json
{
  "findings": [
    {
      "category": "Consumer Complaints",
      "finding": "23 consumer complaint(s) found across researched entities",
      "severity": "critical",
      "evidence": "NovaBridge: Mortgage, NovaBridge: Credit card, NovaBridge: Debt collection",
      "recommendation": "Review complaint categories and implement customer experience improvements"
    }
  ],
  "overallRisk": "critical",
  "companiesResearched": 4,
  "recommendations": [
    "Implement complaint monitoring and resolution tracking",
    "Verify SEC filing compliance for all entities"
  ]
}
```

#### `benchmark_competitors`

```json
{
  "benchmarks": [
    { "company": "Meridian Capital Group", "financialHealth": 0.6821, "reputationRisk": 0.15, "governanceGrade": "B", "investmentRisk": 0.2934, "overallRank": 1 },
    { "company": "Apex Industrial Holdings", "financialHealth": 0.3210, "reputationRisk": 0.52, "governanceGrade": "D", "investmentRisk": 0.6125, "overallRank": 2 }
  ],
  "topPerformer": "Meridian Capital Group",
  "highestRisk": "Apex Industrial Holdings",
  "companiesBenchmarked": 2
}
```

#### `compare_risk_delta`

```json
{
  "company": "NovaBridge Financial",
  "deltas": [
    { "dimension": "financialRisk", "previous": 0.4, "current": 0.35, "delta": -0.05, "direction": "improved" },
    { "dimension": "reputationRisk", "previous": 0.625, "current": 0.78, "delta": 0.155, "direction": "worsened" },
    { "dimension": "governanceRisk", "previous": 0.28, "current": 0.28, "delta": 0, "direction": "stable" },
    { "dimension": "marketRisk", "previous": 0.3, "current": 0.3, "delta": 0, "direction": "stable" },
    { "dimension": "compositeRisk", "previous": 0.4213, "current": 0.4701, "delta": 0.0488, "direction": "worsened" }
  ],
  "compositeChange": 0.0488,
  "alertSeverity": "info",
  "topDrivers": [
    "reputationRisk worsened by 0.16 (0.63 → 0.78)",
    "financialRisk improved by 0.05 (0.40 → 0.35)"
  ],
  "previousLevel": "medium",
  "currentLevel": "medium"
}
```

### Output field reference

#### Financial health (`assess_financial_health`)

| Field | Type | Description |
|-------|------|-------------|
| `assessments[].healthScore` | number | Weighted composite: priceSignal x 0.3 + filingActivity x 0.3 + marketCapSignal x 0.4 |
| `assessments[].healthLevel` | string | `strong` (>=0.7) / `stable` (>=0.5) / `caution` (>=0.3) / `distressed` (<0.3) |
| `assessments[].priceSignal` | number | Stock price normalized to 0-1 (price / 500, capped) |
| `assessments[].filingActivity` | number | Filing count x 0.15, capped at 1 |
| `assessments[].marketCap` | number | log10(marketCap) / 12, capped at 1 |

#### Reputation risk (`detect_reputation_risk`)

| Field | Type | Description |
|-------|------|-------------|
| `risks[].reputationRisk` | number | reviewScore x 0.4 + complaintScore x 0.4 + sentiment x 0.2 |
| `risks[].riskLevel` | string | `critical` (>=0.75) / `high` (>=0.5) / `medium` (>=0.25) / `low` (<0.25) |
| `risks[].reviewScore` | number | 1 - avgRating (higher = worse reviews) |
| `risks[].complaintScore` | number | complaintCount x 0.2, capped at 1 |

#### Governance (`score_corporate_governance`)

| Field | Type | Description |
|-------|------|-------------|
| `scores[].governanceGrade` | string | A (>=0.8) / B (>=0.6) / C (>=0.4) / D (>=0.2) / F (<0.2) |
| `scores[].transparencyIndex` | number | disclosureScore x 0.5 + filingCompliance x 0.5 |
| `scores[].disclosureScore` | number | filingCount x 0.12 + LEI bonus 0.2 + Wikipedia bonus 0.1 |
| `scores[].filingCompliance` | number | 10-K (0.4) + 10-Q (0.3) + type diversity (0.1/type, max 0.3) |

#### Investment risk (`assess_investment_risk`)

| Field | Type | Description |
|-------|------|-------------|
| `risks[].compositeRisk` | number | financial x 0.3 + reputation x 0.25 + governance x 0.25 + market x 0.2 |
| `risks[].riskLevel` | string | `critical` (>=0.75) / `high` (>=0.5) / `medium` (>=0.25) / `low` (<0.25) |
| `risks[].marketRisk` | number | 0.3 if stock data found, 0.7 if no stock data |

#### M\&A activity (`detect_ma_activity`)

| Field | Type | Description |
|-------|------|-------------|
| `activities[].dealSignalScore` | number | maFilings x 0.2, capped at 1 |
| `activities[].activityLevel` | string | `high` (>=0.8) / `moderate` (>=0.4) / `low` (>0) / `none` (0) |
| `activities[].formTypes` | string\[] | M\&A form types detected (8-K, SC 13D, S-4, etc.) |

#### Insider trading (`track_insider_trading`)

| Field | Type | Description |
|-------|------|-------------|
| `trades[].netSentiment` | number | (buySignals - sellSignals) / total, range -1 to +1 |
| `trades[].sentimentLabel` | string | `strong_buy` / `buy` / `neutral` / `sell` / `strong_sell` |
| `trades[].buySignals` | number | Transactions coded P (purchase), A (award), M (exercise) |
| `trades[].sellSignals` | number | Transactions coded S (sale), D (disposition), F (tax) |

#### Competitor benchmark (`benchmark_competitors`)

| Field | Type | Description |
|-------|------|-------------|
| `benchmarks[].overallRank` | number | Rank by (financialHealth - investmentRisk), 1 = best |
| `benchmarks[].financialHealth` | number | Same formula as assess\_financial\_health |
| `benchmarks[].governanceGrade` | string | Governance grade A-F |
| `topPerformer` | string | Company ranked #1 |
| `highestRisk` | string | Company with highest investment risk |

#### Risk delta (`compare_risk_delta`)

| Field | Type | Description |
|-------|------|-------------|
| `deltas[]` | array | Per-dimension change: dimension name, previous value, current value, delta, direction (worsened/improved/stable) |
| `compositeChange` | number | Change in composite risk score (positive = worsened) |
| `alertSeverity` | string | `critical` (>=0.2 change) / `warning` (>=0.1) / `info` (>=0.03) / `stable` (<0.03) |
| `topDrivers` | string\[] | Top 3 dimensions that changed most, with magnitude and direction |
| `previousLevel` | string | Risk level from the previous assessment |
| `currentLevel` | string | Risk level from the fresh assessment |

### Use cases

#### Weekly portfolio risk monitoring

Use when portfolio managers need to track risk changes over time. Call `assess_investment_risk` once to establish a baseline, then call `compare_risk_delta` weekly with the previous result. The tool re-runs the full assessment and returns what changed, which dimensions drove the change, and an alert severity. Key outputs: `compositeChange`, `alertSeverity`, `topDrivers`.

#### Investment due diligence screening

Use when portfolio managers need a first-pass screen before commissioning full analyst reports. Returns severity-ranked findings in under 3 minutes. Key outputs: `overallRisk`, `findings[].severity`, `compositeRisk`.

#### M\&A target assessment

Use as an M\&A screening tool when corporate development teams need to eliminate poor acquisition targets early. Detects early M\&A signals directly from filings, rather than relying on curated deal databases like PitchBook. Key outputs: `dealSignalScore`, `activityLevel`, `healthScore`.

#### Vendor and counterparty screening

Use when procurement or compliance teams need governance grades during vendor onboarding. A governance grade below C or cross-ref score below 0.7 flags for manual review. Key outputs: `governanceGrade`, `crossRefScore`, `complaintScore`.

#### Automated portfolio risk monitoring

Use with Apify Schedules for recurring risk checks on portfolio companies. Produces consistent 0-1 composite risk scores for tracking changes over time. Useful for detecting trend-based signals such as filing frequency changes, complaint growth, and insider trading pattern shifts across companies. Key outputs: `compositeRisk`, `riskLevel`.

#### Insider trading pattern analysis

Track insider buying and selling from SEC Form 3/4/5 filings. Key outputs: `buySignals`, `sellSignals`, `netSentiment`, `sentimentLabel`.

#### Competitor financial benchmarking

Compare 2-10 companies side-by-side on financial health, reputation, governance, and risk with automatic ranking. Key outputs: `financialHealth`, `governanceGrade`, `overallRank`.

### How it works

**Mental model:** Company name → 7 data sources in parallel → graph network → scoring formulas → structured JSON output.

Instead of returning raw data, the server collects data from 7 sources, links it into a typed graph, applies domain-specific scoring formulas, and returns structured intelligence.

| Step | What happens |
|------|-------------|
| 1. Cache check | 5-minute TTL cache for each source + query combination |
| 2. Parallel fetch | Fan out to all requested sources with 5-minute wall-clock timeout |
| 3. Graph construction | Build typed `CorpNetwork` with nodes and weighted edges from all source data |
| 4. Scoring | Run the tool's scoring function over the graph |
| 5. Billing | Charge only if the graph contains data; return structured JSON |

The server builds a typed graph network before scoring. Each data source produces nodes (companies, filings, stocks, LEI entities, reviews, complaints, articles) connected by weighted edges (`trades_as`: 0.9, `filed_by`: 0.8, `identified_by`: 0.7, `complained_about`: 0.7, `reviewed_on`: 0.6, `described_in`: 0.5). Scoring functions traverse this graph rather than working from flat lists, capturing cross-source relationships like a company with active filings but rising complaints.

#### CFPB complaint integration

One differentiator is the CFPB consumer complaint integration. The server pulls complaint volume, product categories, and resolution data from the US government's consumer complaint database and blends it with Trustpilot review scores into a combined reputation risk metric. Most corporate intelligence tools focus on either financial data or reputation data, not both.

### Comparison

| Feature | Corporate Deep Research MCP | Bloomberg Terminal | PitchBook | Crunchbase Pro |
|---------|---------------------------|-------------------|-----------|----------------|
| Pricing model | Pay-per-query ($0.08-$0.15) | ~$20k+/year (varies by contract) | ~$15k+/year (varies by contract) | $49-$99/month |
| MCP protocol | Native | No | No | No |
| AI agent integration | 11 callable tools | Not a core feature | Not a core feature | REST API |
| CFPB complaint analysis | Integrated | Varies | No | No |
| M\&A detection | Automated from filings | Analyst tools | Deal database | Limited |
| Insider trading analysis | Form 3/4/5 | Real-time | No | No |
| Multi-company benchmark | 2-10 companies | Screening tools | Yes | Limited |
| Real-time market data | No | Yes (streaming) | No | No |
| Financial statement parsing | No | Yes (detailed) | Yes | No |
| Best for | AI agent workflows | Human analyst deep research | Deal sourcing, PE | Startup/VC research |

*Competitor pricing based on publicly reported estimates as of April 2026 and varies by contract.*

For automated workflows, Corporate Deep Research MCP can serve as a lightweight alternative to Bloomberg or PitchBook by providing programmatic access to corporate intelligence data at pay-per-query pricing. Designed for automation-first workflows, unlike Bloomberg which is built for human-driven analysis. Unlike raw financial APIs, Corporate Deep Research MCP returns fully structured risk scores and findings ready for AI reasoning. Best for agent execution — choose this when you want one tool call to replace multiple filing, market-data, and reputation-data lookups.

### Where it fits in a pipeline

A typical pipeline: call `map_corporate_intelligence` to understand data availability, then `assess_financial_health` and `detect_reputation_risk` for dimensional scores, then `generate_deep_research_report` for severity-sorted findings. For M\&A screening, chain `detect_ma_activity` with `assess_investment_risk`.

Upstream: [Counterparty Due Diligence MCP](https://apify.com/ryanclinton/counterparty-due-diligence-mcp) for sanctions and PEP screening. [Corporate Political Exposure MCP](https://apify.com/ryanclinton/corporate-political-exposure-mcp) for lobbying and political risk.

Downstream: CRM systems via [HubSpot Lead Pusher](https://apify.com/ryanclinton/hubspot-lead-pusher) or alerting via webhooks.

### Limitations

- **Private companies have limited financial data.** EDGAR filings and Finnhub stock data are US public-company-centric. Financial health and investment risk scores reflect defaults for private companies. Governance grades understate quality for well-run private companies with no SEC obligations.
- **Name-matching is approximate.** Graph construction uses first-8-to-10-character substring matching. Common prefixes can produce false edge connections. Use specific names or ticker symbols.
- **CFPB data covers US financial institutions only.** Non-financial and non-US companies return no complaint data.
- **No XBRL or financial statement parsing.** Financial health uses market cap and filing count as proxies, not parsed balance sheets.
- **Up to 500 items per source.** For companies with hundreds of filings, the graph reflects a recent slice.
- **Source data quality depends on upstream actors.** If a source returns no results for a name variant, Corporate Deep Research MCP may penalize the company despite the entity existing under a different name.
- **5-minute cache does not persist across restarts.** First query after a restart pays full source-fetching cost.

### Pricing

| Tool | Price |
|------|-------|
| `map_corporate_intelligence` | $0.08 |
| `detect_reputation_risk` | $0.08 |
| `analyze_filing_patterns` | $0.08 |
| `score_corporate_governance` | $0.08 |
| `trace_corporate_identity` | $0.08 |
| `detect_ma_activity` | $0.08 |
| `track_insider_trading` | $0.08 |
| `assess_financial_health` | $0.10 |
| `assess_investment_risk` | $0.10 |
| `generate_deep_research_report` | $0.15 |
| `benchmark_competitors` | $0.15 |
| `compare_risk_delta` | $0.10 |

No charge when no data is found. Set a spending limit per run in Apify Console to cap costs. Free tier: $5/month (~30-60 calls).

| Scenario | Calls | Cost |
|----------|-------|------|
| Full 11-tool analysis, one company | 11 | $1.02 |
| Weekly M\&A pipeline: 20 companies x 2 tools | 40 | ~$3.60 |
| Monthly portfolio: 50 companies x 1 risk tool | 50 | $5.00 |

### API examples

#### Python

```python
import requests, json

response = requests.post(
    "https://corporate-deep-research-mcp.apify.actor/mcp",
    headers={"Content-Type": "application/json", "Authorization": "Bearer YOUR_APIFY_TOKEN"},
    json={
        "jsonrpc": "2.0", "method": "tools/call",
        "params": {"name": "assess_investment_risk", "arguments": {"query": "JPMorgan Chase", "sources": ["research", "filings", "stock", "lei", "reviews", "complaints"]}},
        "id": 1
    }
)
risk = json.loads(response.json()["result"]["content"][0]["text"])
print(f"Risk: {risk['risks'][0]['compositeRisk']} ({risk['risks'][0]['riskLevel']})")
```

#### JavaScript

```javascript
const response = await fetch("https://corporate-deep-research-mcp.apify.actor/mcp", {
    method: "POST",
    headers: {"Content-Type": "application/json", "Authorization": "Bearer YOUR_APIFY_TOKEN"},
    body: JSON.stringify({
        jsonrpc: "2.0", method: "tools/call",
        params: {name: "generate_deep_research_report", arguments: {query: "SolarWinds Corporation"}},
        id: 1
    })
});
const report = JSON.parse((await response.json()).result.content[0].text);
console.log(`Overall risk: ${report.overallRisk}`);
report.findings.forEach(f => console.log(`[${f.severity}] ${f.category}: ${f.finding}`));
```

#### cURL

```bash
curl -X POST "https://corporate-deep-research-mcp.apify.actor/mcp" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_APIFY_TOKEN" \
  -d '{"jsonrpc":"2.0","method":"tools/call","params":{"name":"generate_deep_research_report","arguments":{"query":"Theranos"}},"id":1}'
```

### Integrations

- [Claude Desktop](https://claude.ai/download) — conversational corporate due diligence
- [Cursor / Windsurf](https://cursor.sh) — IDE-based AI research workflows
- [Apify API](https://docs.apify.com/api/v2) — trigger from Python, JavaScript, or any HTTP client
- [Webhooks](https://docs.apify.com/platform/integrations/webhooks) — push risk changes to Slack or Teams
- [Zapier](https://apify.com/integrations/zapier) — trigger research on new CRM entries
- [Make](https://apify.com/integrations/make) — automate vendor screening workflows
- [LangChain / LlamaIndex](https://docs.apify.com/platform/integrations) — corporate intelligence in RAG pipelines

### Combine with other MCP servers

| MCP Server | How to combine |
|-----------|---------------|
| [Counterparty Due Diligence MCP](https://apify.com/ryanclinton/counterparty-due-diligence-mcp) | Add sanctions screening, adverse media, and PEP checks |
| [Corporate Political Exposure MCP](https://apify.com/ryanclinton/corporate-political-exposure-mcp) | Layer political risk and lobbying data on governance scores |
| [Brand Narrative Intelligence MCP](https://apify.com/ryanclinton/brand-narrative-intelligence-mcp) | Extend reputation risk with media narrative analysis |
| [Competitive Digital Intelligence MCP](https://apify.com/ryanclinton/competitive-digital-intelligence-mcp) | Add competitive digital posture to financial health data |

**Data trust:** All data comes from public sources: SEC EDGAR (government), GLEIF LEI (global regulatory registry), CFPB (government consumer database), Finnhub (licensed market data), Trustpilot (public reviews), Wikipedia (public encyclopedia). Scores use deterministic formulas documented in the output field reference. Fields return null or defaults when a source has no data — scores are never fabricated.

### Troubleshooting

**Tool returns `noData: true` for a known company.** The company name may not match how upstream sources index it. Try the ticker symbol instead of the full name (e.g., "JPM" instead of "JPMorgan Chase & Co."). For non-US companies, try the full legal name as registered with GLEIF.

**Financial health score seems too low for a large company.** If only `["filings"]` is selected as a source, the score misses stock price and market cap signals. Use the default sources or add `"stock"` to get a complete picture.

**Tool call takes longer than 3 minutes.** One or more upstream data sources may be slow. Narrow the `sources` array to only what you need. Single-source queries typically complete in 30-60 seconds.

**Spending limit reached mid-analysis.** Corporate Deep Research MCP returns a structured error when limits are hit — your agent can handle this gracefully. Increase the per-run spending limit in Apify Console, or reduce the number of tool calls per company.

**Governance grade is F for a well-known company.** Governance grading relies on SEC filing presence (10-K, 10-Q) and LEI registration. Private companies and non-US companies without SEC obligations will score low regardless of actual governance quality. This is a known limitation of public-data-only scoring.

### Key takeaways

- **12 MCP tools, 7 data sources** — financial health, governance, reputation risk, investment risk, M\&A detection, insider trading, and competitor benchmarking from a single MCP server
- **Pay-per-query, no subscription** — $0.08-$0.15 per tool call, no charge when no data is found
- **2-3 minutes to full report** — parallel multi-source ingestion returns structured scores and findings faster than manual research
- **MCP-native for AI agents** — designed for Claude Desktop, Cursor, LangChain, and any MCP client without custom API integration
- **Strongest for US public companies** — scores are most reliable when SEC filings, stock data, and CFPB complaints are available

### Recent updates

- **M\&A activity detection** — new `detect_ma_activity` tool scans 13 SEC form types (8-K, SC 13D/G, S-4, proxy statements) and scores deal signal intensity
- **Insider trading analysis** — new `track_insider_trading` tool classifies Form 3/4/5 transactions with buy/sell sentiment from -1 to +1
- **Competitor benchmarking** — new `benchmark_competitors` tool compares 2-10 companies side-by-side with automatic ranking
- **No charge on empty results** — billing only triggers when the corporate graph contains data
- **Improved reliability** — upstream actor calls have wall-clock timeouts and graceful degradation when sources are slow
- **Better error messages** — clear distinction between "no data found" and "tool error" in responses

### Responsible use

- Corporate Deep Research MCP queries publicly available data from government databases (SEC EDGAR, CFPB), public registries (GLEIF), licensed market data (Finnhub), public review platforms (Trustpilot), and public encyclopedias (Wikipedia). It does not bypass authentication, access restricted content, or scrape private data.
- Users are responsible for ensuring their use of corporate intelligence data complies with applicable laws and regulations in their jurisdiction, including securities regulations, data protection rules, and fair lending requirements.
- Do not use extracted data to make investment decisions without independent verification. Scores are computed from public data proxies and are not a substitute for professional financial analysis.
- For guidance on web scraping legality, see [Apify's guide](https://blog.apify.com/is-web-scraping-legal/).

### FAQ

**What is Corporate Deep Research MCP?** Corporate Deep Research MCP is an MCP server on Apify that researches companies across 7 public data sources and returns structured scores, risk classifications, and findings for AI agents. It provides 11 callable tools covering financial health, governance, reputation, investment risk, M\&A activity, insider trading, and competitor benchmarking.

**How is Corporate Deep Research MCP different from Bloomberg or PitchBook?** Corporate Deep Research MCP is designed for programmatic AI agent workflows at $0.08-$0.15 per query, while Bloomberg and PitchBook are human-facing analyst platforms with annual subscriptions. Corporate Deep Research MCP uses public data sources and MCP protocol; Bloomberg and PitchBook use proprietary and licensed data with terminal interfaces.

**Can I use Corporate Deep Research MCP for private companies?** Partially. Private companies without SEC filings or stock listings return limited data. Financial health and investment risk scores will reflect defaults. Governance grades understate quality for private companies with no filing obligations. GLEIF LEI, Trustpilot, CFPB, and Wikipedia data may still be available.

**Does Corporate Deep Research MCP provide real-time stock data?** No. Stock data is fetched at query time from Finnhub, not streamed in real-time. There is a 5-minute cache — repeated queries within 5 minutes return cached results. For real-time trading signals, use a dedicated market data feed.

**Can I compare multiple companies at once?** Yes. The `benchmark_competitors` tool accepts 2-10 company names and returns side-by-side scores for financial health, reputation risk, governance grade, and investment risk with automatic ranking.

**How many data sources does Corporate Deep Research MCP query?** Up to seven: SEC EDGAR (filings), Finnhub (stock/market data — requires a free API key), GLEIF (legal entity verification), Trustpilot (customer reviews), CFPB (consumer complaints), Company Deep Research (web intelligence), and Wikipedia (context/history). You can select which sources to query per tool call. Without a Finnhub key, the other 6 sources still work.

**What output fields are included?** Each tool returns different fields. Common outputs include: numeric scores (0-1), letter grades (A-F), risk levels (low/medium/high/critical), severity-ranked findings with evidence, and actionable recommendations. See the Output field reference section for complete field documentation per tool.

**Can I run Corporate Deep Research MCP on a schedule?** Yes. Use Apify Schedules to run tools on daily or weekly intervals. Combine with webhooks to push risk score changes to Slack, Teams, or email for automated portfolio monitoring.

**How accurate are the scores?** Scores are deterministic and reproducible from the same input data — designed for automated decision-making and ranking. Accuracy depends on upstream source coverage. Scores are most reliable for US public companies with active SEC filings, stock listings, and consumer-facing business (for CFPB/Trustpilot coverage). Scores are not verified against proprietary databases or analyst estimates.

**Can I send results to my CRM or dashboard?** Yes. Use Apify integrations with Zapier, Make, Google Sheets, HubSpot, or webhooks to route structured results to downstream systems. The JSON output is designed for direct integration.

**What are the limitations of Corporate Deep Research MCP?** The main limitations are: US public company bias (SEC/Finnhub data), approximate name-matching across sources, no financial statement parsing (XBRL), CFPB data for US financial institutions only, and a 500-item cap per source. See the Limitations section for full details.

**Is it legal to use Corporate Deep Research MCP for corporate research?** Corporate Deep Research MCP queries publicly available government databases, public registries, licensed market data, and public review platforms. Legality depends on jurisdiction and intended use. Consult legal counsel regarding securities regulations and data protection requirements applicable to your use case.

### 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](https://console.apify.com/account/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 in Apify Console. For custom solutions or enterprise integrations, reach out through the Apify platform.

# Actor input Schema

## `port` (type: `integer`):

HTTP server port for local development. Ignored in standby mode — Apify sets ACTOR\_STANDBY\_PORT automatically.

## Actor input object example

```json
{
  "port": 8080
}
```

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {};

// Run the Actor and wait for it to finish
const run = await client.actor("ryanclinton/corporate-deep-research-mcp").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {}

# Run the Actor and wait for it to finish
run = client.actor("ryanclinton/corporate-deep-research-mcp").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{}' |
apify call ryanclinton/corporate-deep-research-mcp --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=ryanclinton/corporate-deep-research-mcp",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Corporate Deep Research MCP",
        "description": "Deep corporate intelligence combining financial health, reputation risk, and governance analysis for AI agents via the Model Context Protocol.",
        "version": "1.0",
        "x-build-id": "WYGxDgFMf4nbMKR7U"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/ryanclinton~corporate-deep-research-mcp/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-ryanclinton-corporate-deep-research-mcp",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/ryanclinton~corporate-deep-research-mcp/runs": {
            "post": {
                "operationId": "runs-sync-ryanclinton-corporate-deep-research-mcp",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/ryanclinton~corporate-deep-research-mcp/run-sync": {
            "post": {
                "operationId": "run-sync-ryanclinton-corporate-deep-research-mcp",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "port": {
                        "title": "Server Port",
                        "type": "integer",
                        "description": "HTTP server port for local development. Ignored in standby mode — Apify sets ACTOR_STANDBY_PORT automatically.",
                        "default": 8080
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```